add a dev only writing system editor

backend/FwLite/FwDataMiniLcmBridge/Api/FwDataMiniLcmApi.cs

@@ -136,9 +136,15 @@
         };
     }
 
-    public Task<WritingSystem> GetWritingSystem(WritingSystemId id, WritingSystemType type)
+    public async Task<WritingSystem> GetWritingSystem(WritingSystemId id, WritingSystemType type)
     {
-        throw new NotImplementedException();
+        var writingSystems = await GetWritingSystems();
+        return type switch
+        {
+            WritingSystemType.Vernacular => writingSystems.Vernacular.FirstOrDefault(ws => ws.WsId == id),
+            WritingSystemType.Analysis => writingSystems.Analysis.FirstOrDefault(ws => ws.WsId == id),
+            _ => throw new ArgumentOutOfRangeException(nameof(type), type, null)
+        } ?? throw new NullReferenceException($"unable to find writing system with id {id}");
     }
 
     internal void CompleteExemplars(WritingSystems writingSystems)
@@ -206,15 +212,14 @@
         }
         await Cache.DoUsingNewOrCurrentUOW("Update WritingSystem",
             "Revert WritingSystem",
             async () =>
             {
-                var updateProxy = new UpdateWritingSystemProxy(lcmWritingSystem, this)
+                var updateProxy = new UpdateWritingSystemProxy(lcmWritingSystem)
                 {
                     Id = Guid.Empty,
                     Type = type,
                 };
                 update.Apply(updateProxy);
-                updateProxy.CommitUpdate(Cache);
             });
         return await GetWritingSystem(id, type);
     }

backend/FwLite/FwDataMiniLcmBridge/Api/UpdateProxy/UpdateWritingSystemProxy.cs

@@ -9,60 +9,43 @@ namespace FwDataMiniLcmBridge.Api.UpdateProxy;
 
 public record UpdateWritingSystemProxy : WritingSystem
 {
-    private readonly CoreWritingSystemDefinition _origLcmWritingSystem;
-    private readonly CoreWritingSystemDefinition _workingLcmWritingSystem;
-    private readonly FwDataMiniLcmApi _lexboxLcmApi;
+    private readonly CoreWritingSystemDefinition _lcmWritingSystem;
 
     [SetsRequiredMembers]
-    public UpdateWritingSystemProxy(CoreWritingSystemDefinition lcmWritingSystem, FwDataMiniLcmApi lexboxLcmApi)
+    public UpdateWritingSystemProxy(CoreWritingSystemDefinition lcmWritingSystem)
     {
-        _origLcmWritingSystem = lcmWritingSystem;
-        _workingLcmWritingSystem = new CoreWritingSystemDefinition(lcmWritingSystem, cloneId: true);
-        base.Abbreviation = Abbreviation = _origLcmWritingSystem.Abbreviation ?? "";
-        base.Name = Name = _origLcmWritingSystem.LanguageName ?? "";
-        base.Font = Font = _origLcmWritingSystem.DefaultFontName ?? "";
-        _lexboxLcmApi = lexboxLcmApi;
-    }
-
-    public void CommitUpdate(LcmCache cache)
-    {
-        if (_workingLcmWritingSystem.Id == _origLcmWritingSystem.Id)
-        {
-            cache.ServiceLocator.WritingSystemManager.Set(_workingLcmWritingSystem);
-        }
-        else
-        {
-            // Changing the ID of a writing system requires LCM to do a lot of work, so only go through that process if absolutely required
-            WritingSystemServices.MergeWritingSystems(cache, _workingLcmWritingSystem, _origLcmWritingSystem);
-        }
+        _lcmWritingSystem = lcmWritingSystem;
+        base.Abbreviation = Abbreviation = _lcmWritingSystem.Abbreviation ?? "";
+        base.Name = Name = _lcmWritingSystem.LanguageName ?? "";
+        base.Font = Font = _lcmWritingSystem.DefaultFontName ?? "";
     }
 
     public override required WritingSystemId WsId
     {
-        get => _workingLcmWritingSystem.Id;
-        set => _workingLcmWritingSystem.Id = value;
+        get => _lcmWritingSystem.Id;
+        set => throw new NotSupportedException("Changing the ID of a writing system is not supported");
     }
 
     public override required string Name
     {
-        get => _workingLcmWritingSystem.LanguageName;
+        get => _lcmWritingSystem.LanguageName;
         set { } // Silently do nothing; name should be derived from WsId at all times, so if the name should change then so should the WsId
     }
 
     public override required string Abbreviation
     {
-        get => _workingLcmWritingSystem.Abbreviation;
-        set => _workingLcmWritingSystem.Abbreviation = value;
+        get => _lcmWritingSystem.Abbreviation;
+        set => _lcmWritingSystem.Abbreviation = value;
     }
 
     public override required string Font
     {
-        get => _workingLcmWritingSystem.DefaultFontName;
+        get => _lcmWritingSystem.DefaultFontName;
         set
         {
-            if (value != _workingLcmWritingSystem.DefaultFontName)
+            if (value != _lcmWritingSystem.DefaultFontName)
             {
-                _workingLcmWritingSystem.DefaultFont = new FontDefinition(value);
+                _lcmWritingSystem.DefaultFont = new FontDefinition(value);
             }
         }
     }

backend/FwLite/FwLiteShared/TypeGen/ReinforcedFwLiteTypingConfig.cs

@@ -74,7 +74,7 @@ private static void ConfigureMiniLcmTypes(ConfigurationBuilder builder)
                 exportBuilder.Ignore();
             }
         }));
-        builder.ExportAsEnum<WritingSystemType>().UseString();
+        builder.ExportAsEnum<WritingSystemType>();
         builder.ExportAsInterface<MiniLcmJsInvokable>()
             .FlattenHierarchy()
             .WithPublicProperties()

backend/FwLite/LcmCrdt/CrdtProjectsService.cs

@@ -24,7 +24,7 @@
         return GetProject(name);
     }
 
     IMiniLcmApi IProjectProvider.OpenProject(IProjectIdentifier project, bool saveChangesOnDispose = true)
     {
         //todo not sure if we should implement this, it's mostly there for the FwData version
         throw new NotImplementedException();
@@ -150,6 +150,18 @@
             ]
         });
 
+        await lexboxApi.CreateWritingSystem(WritingSystemType.Vernacular,
+            new()
+            {
+                Id = Guid.NewGuid(),
+                Type = WritingSystemType.Vernacular,
+                WsId = "de",
+                Name = "German",
+                Abbreviation = "de",
+                Font = "Arial",
+                Exemplars = WritingSystem.LatinExemplars
+            });
+
         await lexboxApi.CreateWritingSystem(WritingSystemType.Vernacular,
             new()
             {
@@ -173,5 +185,16 @@
                 Font = "Arial",
                 Exemplars = WritingSystem.LatinExemplars
             });
+        await lexboxApi.CreateWritingSystem(WritingSystemType.Analysis,
+            new()
+            {
+                Id = Guid.NewGuid(),
+                Type = WritingSystemType.Analysis,
+                WsId = "fr",
+                Name = "French",
+                Abbreviation = "fr",
+                Font = "Arial",
+                Exemplars = WritingSystem.LatinExemplars
+            });
     }
 }

backend/FwLite/MiniLcm.Tests/WritingSystemTestsBase.cs

@@ -64,4 +64,15 @@ await Api.CreateWritingSystem(WritingSystemType.Vernacular,
             });
         await action.Should().ThrowAsync<DuplicateObjectException>();
     }
+
+    [Fact]
+    public async Task UpdateExistingWritingSystem_Works()
+    {
+        var writingSystems = await Api.GetWritingSystems();
+        var writingSystem = writingSystems.Vernacular.First();
+        var original = writingSystem.Copy();
+        writingSystem.Abbreviation = "New Abbreviation";
+        var updatedWritingSystem = await Api.UpdateWritingSystem(original, writingSystem);
+        updatedWritingSystem.Abbreviation.Should().Be("New Abbreviation");
+    }
 }

backend/FwLite/MiniLcm/Models/WritingSystem.cs

@@ -1,6 +1,8 @@
-namespace MiniLcm.Models;
+using System.Text.Json.Serialization;
 
-public record WritingSystem: IObjectWithId
+namespace MiniLcm.Models;
+
+public record WritingSystem: IObjectWithId<WritingSystem>
 {
     public required Guid Id { get; set; }
     public virtual required WritingSystemId WsId { get; set; }
@@ -26,7 +28,7 @@ public void RemoveReference(Guid id, DateTimeOffset time)
     {
     }
 
-    public IObjectWithId Copy()
+    public WritingSystem Copy()
     {
         return new WritingSystem
         {

frontend/viewer/src/lib/dotnet-types/generated-types/MiniLcm/Models/WritingSystemType.ts

@@ -4,7 +4,7 @@
 //     the code is regenerated.
 
 export enum WritingSystemType {
-	Vernacular = "Vernacular",
-	Analysis = "Analysis"
+	Vernacular = 0,
+	Analysis = 1
 }
 /* eslint-enable */

frontend/viewer/src/lib/entry-data.ts

@@ -49,7 +49,7 @@ export const writingSystems: IWritingSystems = {
       'abbreviation': 'Por',
       'font': '???',
       'exemplars': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'],
-      'type': WritingSystemType.Vernacular,
+      'type': WritingSystemType.Analysis,
       'order': 1
     }
   ],

frontend/viewer/src/lib/layout/AppBarMenu.svelte

@@ -2,11 +2,13 @@
   import AboutDialog from '$lib/about/AboutDialog.svelte';
   import ActivityView from '$lib/activity/ActivityView.svelte';
   import {useFeatures} from '$lib/services/feature-service';
-  import {mdiDotsVertical, mdiEyeSettingsOutline, mdiHistory, mdiInformationVariantCircle} from '@mdi/js';
+  import {mdiDotsVertical, mdiEyeSettingsOutline, mdiHistory, mdiInformationVariantCircle, mdiNoteEdit} from '@mdi/js';
   import {createEventDispatcher} from 'svelte';
   import {Button, MenuItem, ResponsiveMenu, Toggle} from 'svelte-ux';
   import {asScottyPortal} from './Scotty.svelte';
   import {useProjectViewState} from '$lib/services/project-view-state-service';
+  import WritingSystemDialog from '$lib/writing-system/WritingSystemDialog.svelte';
+  import DevContent from '$lib/layout/DevContent.svelte';
 
   const dispatch = createEventDispatcher<{
     showOptionsDialog: void;
@@ -20,6 +22,7 @@
 
   let activityViewOpen = false;
   let aboutDialogOpen = false;
+  let wsEditDialogOpen = false;
 </script>
 
 <!-- #key prevents rendering ugly delayed state updates -->
@@ -41,6 +44,11 @@
             <MenuItem icon={mdiInformationVariantCircle} on:click={() => aboutDialogOpen = true}>About</MenuItem>
           </div>
         {/if}
+        <DevContent>
+          <MenuItem icon={mdiNoteEdit} on:click={() => wsEditDialogOpen = true}>
+            Edit WS
+          </MenuItem>
+        </DevContent>
       </button>
     </ResponsiveMenu>
   </Button>
@@ -50,11 +58,12 @@
 {#if $features.history}
   <ActivityView bind:open={activityViewOpen} {projectName} />
 {/if}
-
 {#if about}
   <AboutDialog bind:open={aboutDialogOpen} text={about} />
 {/if}
 
+<WritingSystemDialog bind:open={wsEditDialogOpen}/>
+
 <style lang="postcss" global>
   .app-bar-menu .MenuItem {
     @apply justify-start;

frontend/viewer/src/lib/services/service-provider.ts

@@ -72,6 +72,10 @@ export function useLexboxApi(): IMiniLcmJsInvokable {
   return window.lexbox.ServiceProvider.getService(DotnetService.MiniLcmApi);
 }
 
+export function useMiniLcmApi(): IMiniLcmJsInvokable {
+  return window.lexbox.ServiceProvider.getService(DotnetService.MiniLcmApi);
+}
+
 export function useProjectsService(): ICombinedProjectsService {
   return window.lexbox.ServiceProvider.getService(DotnetService.CombinedProjectsService);
 }

frontend/viewer/src/lib/utils.ts

@@ -1,4 +1,4 @@
-import type {IEntry, IExampleSentence, ISense} from '$lib/dotnet-types';
+import type {IEntry, IExampleSentence, ISense, IWritingSystem, WritingSystemType} from '$lib/dotnet-types';
 
 export function randomId(): string {
   return crypto.randomUUID();
@@ -48,3 +48,17 @@ export function defaultExampleSentence(senseId: string): IExampleSentence {
     reference: '',
   };
 }
+
+export function defaultWritingSystem(type: WritingSystemType): IWritingSystem {
+  return {
+    id: randomId(),
+    wsId: 'en',
+    name: 'English',
+    abbreviation: 'en',
+    font: 'Arial',
+    exemplars: [],
+    order: 0,
+    deletedAt: undefined,
+    type
+  };
+}

frontend/viewer/src/lib/writing-system/WritingSystemDialog.svelte

@@ -0,0 +1,55 @@
+<script lang="ts">
+  import {Button, Dialog, MenuItem, SelectField} from 'svelte-ux';
+  import WritingSystemEditor from '$lib/writing-system/WritingSystemEditor.svelte';
+  import {useWritingSystemService} from '$lib/writing-system-service';
+  import {type IWritingSystem, WritingSystemType} from '$lib/dotnet-types';
+  import {defaultWritingSystem} from '$lib/utils';
+  import {mdiNoteEdit} from '@mdi/js';
+
+  export let open = false;
+  let loading = false;
+  const writingSystemService = useWritingSystemService();
+  let vernacular = writingSystemService.vernacular;
+  let analysis = writingSystemService.analysis;
+  let options: Array<{ value: IWritingSystem, label: string, group: 'Vernacular' | 'Analysis' }> = [];
+  let newVernacular = defaultWritingSystem(WritingSystemType.Vernacular);
+  let newAnalysis = defaultWritingSystem(WritingSystemType.Analysis);
+  $: options = [
+    ...vernacular.map(ws => mapOption(ws)),
+    {value: newVernacular, label: 'New Vernacular Writing System', group: 'Vernacular'},
+    ...analysis.map(ws => mapOption(ws)),
+    {value: newAnalysis, label: 'New Analysis Writing System', group: 'Analysis'},
+  ];
+
+  function mapOption(ws: IWritingSystem): {
+    value: IWritingSystem,
+    label: string,
+    group: 'Vernacular' | 'Analysis'
+  } {
+    return {value: ws, label: `${ws.name} (${ws.wsId})`, group: ws.type === WritingSystemType.Vernacular ? 'Vernacular' : 'Analysis'};
+  }
+
+  let selectedOption: IWritingSystem = vernacular[0] ?? analysis[0];
+
+  function onCreate(_writingSystem: IWritingSystem) {
+    //todo need a better way to invalidate the writing system service
+    location.reload();
+  }
+  function onChange(_writingSystem: IWritingSystem) {
+    //todo need a better way to invalidate the writing system service
+    location.reload();
+  }
+</script>
+
+<Dialog bind:open={open} {loading} persistent={loading} style="height: auto">
+  <div slot="title">Edit Writing Systems</div>
+  <SelectField label="Writing System" bind:value={selectedOption} {options} clearable={false}/>
+  <WritingSystemEditor
+    writingSystem={selectedOption}
+    newWs={selectedOption === newVernacular || selectedOption === newAnalysis}
+    on:create={(e) => onCreate(e.detail.writingSystem)}
+  on:change={(e) => onChange(e.detail.writingSystem)}/>
+  <div slot="actions">
+    <Button on:click={() => open = false}>Close</Button>
+  </div>
+</Dialog>

frontend/viewer/src/lib/writing-system/WritingSystemEditor.svelte

@@ -0,0 +1,43 @@
+<script lang="ts">
+    import type {IWritingSystem} from '$lib/dotnet-types';
+    import {Button} from 'svelte-ux';
+    import CrdtTextField from '$lib/entry-editor/inputs/CrdtTextField.svelte';
+    import {useMiniLcmApi} from '$lib/services/service-provider';
+    import {createEventDispatcher} from 'svelte';
+
+    const dispatch = createEventDispatcher<{
+        change: { writingSystem: IWritingSystem },
+        create: { writingSystem: IWritingSystem }
+    }>();
+    const miniLcmApi = useMiniLcmApi();
+    export let writingSystem: IWritingSystem;
+    $: initialWs = JSON.parse(JSON.stringify(writingSystem));
+    function updateInitialWs() {
+        // eslint-disable-next-line svelte/no-reactive-reassign
+        initialWs = JSON.parse(JSON.stringify(writingSystem));
+    }
+    export let newWs: boolean = false;
+    async function onChange() {
+        if (newWs) return;
+        await miniLcmApi.updateWritingSystem(initialWs, writingSystem);
+        updateInitialWs();
+        dispatch('change', {writingSystem});
+    }
+
+    async function createNew() {
+        await miniLcmApi.createWritingSystem(writingSystem.type, writingSystem);
+        dispatch('create', {writingSystem});
+    }
+</script>
+<form class="flex flex-col gap-2 p-2">
+    <CrdtTextField label="Language Code" readonly={!newWs} on:change={() => onChange()} bind:value={writingSystem.wsId}/>
+<!--    todo changing the name for FieldWorks writing systems is not yet supported-->
+    <CrdtTextField label="Name" readonly={!newWs} on:change={() => onChange()} bind:value={writingSystem.name}/>
+    <CrdtTextField label="Abbreviation" on:change={() => onChange()} bind:value={writingSystem.abbreviation}/>
+    <CrdtTextField label="Font" on:change={() => onChange()} bind:value={writingSystem.font}/>
+    {#if newWs}
+        <Button variant="outline" on:click={createNew}>Create new Writing System</Button>
+    {:else}
+        <span>Changes are saved automatically</span>
+    {/if}
+</form>