@likec4/diagram 1.47.0 → 1.49.0

package/dist/editor/editorActor.actions.d.ts

@@ -1,10 +1,10 @@
 import { ViewChange } from '@likec4/core/types';
 import { ActionFunction, CancelAction, Values, PromiseActorLogic, EventObject, NonReducibleUnknown, StopAction } from 'xstate';
-import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './editorActor';
+import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './editorActor.setup';
 import { HotkeyActorLogic } from './hotkeyActor';
-export declare const raiseSync: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+export declare const raiseSync: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "waitBeforeSync", never>;
 export declare const cancelSync: () => CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
-export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+export declare const reschedule: (delay?: number) => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "waitBeforeSync", never>;
 type LayoutChanges = ViewChange.ResetManualLayout | ViewChange.SaveViewSnapshot;
 export declare const isLayoutChange: (change: ViewChange) => change is LayoutChanges;
 export declare const withoutSnapshotChanges: (data: ViewChange[]) => (ViewChange.ChangeElementStyle | ViewChange.ChangeAutoLayout)[];
@@ -16,12 +16,12 @@ export declare const saveStateBeforeEdit: () => ActionFunction<EditorActorContex
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, never, never, never>;
@@ -33,12 +33,12 @@ export declare const startEditing: () => ActionFunction<EditorActorContext, Edit
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, Values<{
@@ -50,7 +50,7 @@ export declare const startEditing: () => ActionFunction<EditorActorContext, Edit
         type: "can undo";
         params: unknown;
     };
-}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+}>, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
 export declare const stopHotkey: () => StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>;
 export declare const ensureHotKey: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
     hotkey: {
@@ -60,12 +60,12 @@ export declare const ensureHotKey: () => ActionFunction<EditorActorContext, Edit
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, Values<{
@@ -77,7 +77,7 @@ export declare const ensureHotKey: () => ActionFunction<EditorActorContext, Edit
         type: "can undo";
         params: unknown;
     };
-}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+}>, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
 export declare const pushHistory: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
     hotkey: {
         src: "hotkey";
@@ -86,12 +86,12 @@ export declare const pushHistory: () => ActionFunction<EditorActorContext, Edito
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, never, never, never>;
@@ -103,12 +103,12 @@ export declare const stopEditing: () => ActionFunction<EditorActorContext, Edito
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, Values<{
@@ -120,7 +120,7 @@ export declare const stopEditing: () => ActionFunction<EditorActorContext, Edito
         type: "can undo";
         params: unknown;
     };
-}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+}>, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
 export declare const markHistoryAsSynched: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
     hotkey: {
         src: "hotkey";
@@ -129,12 +129,12 @@ export declare const markHistoryAsSynched: () => ActionFunction<EditorActorConte
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, never, never, never>;
@@ -146,12 +146,12 @@ export declare const popHistory: () => ActionFunction<EditorActorContext, Editor
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, never, never, never>;
@@ -163,12 +163,12 @@ export declare const undo: () => ActionFunction<EditorActorContext, EditorActorE
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, Values<{
@@ -180,7 +180,7 @@ export declare const undo: () => ActionFunction<EditorActorContext, EditorActorE
         type: "can undo";
         params: unknown;
     };
-}>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+}>, "500ms" | "waitBeforeSync", EditorActorEmitedEvent>;
 export declare const addSnapshotToPendingChanges: () => ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
     hotkey: {
         src: "hotkey";
@@ -189,12 +189,12 @@ export declare const addSnapshotToPendingChanges: () => ActionFunction<EditorAct
     };
     applyLatest: {
         src: "applyLatest";
-        logic: PromiseActorLogic<import("./editorActor").EditorCalls.ApplyLatestToManual.Output, import("./editorActor").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        logic: PromiseActorLogic<import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Output, import("./editorActor.setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
         id: string | undefined;
     };
     executeChange: {
         src: "executeChange";
-        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor").EditorCalls.ExecuteChange.Input, EventObject>;
+        logic: PromiseActorLogic<NonReducibleUnknown, import("./editorActor.setup").EditorCalls.ExecuteChange.Input, EventObject>;
         id: string | undefined;
     };
 }>, never, never, never, never>;

package/dist/editor/editorActor.actions.js

@@ -1,8 +1,8 @@
 import { last, filter, isNot, omit } from 'remeda';
 import { createViewChange } from '../likec4diagram/state/createViewChange.js';
-import { machine } from './editorActor.js';
+import { machine } from './editorActor.setup.js';
 
-const diagramActorRef = function(system) {
+const diagramActorRef = (system) => {
   return system.get("diagram");
 };
 const getDiagramContext = function(system) {
@@ -10,28 +10,24 @@ const getDiagramContext = function(system) {
 };
 const raiseSync = () => machine.raise({ type: "sync" }, { delay: 200, id: "sync" });
 const cancelSync = () => machine.cancel("sync");
-const reschedule = (delay = 50) => machine.raise(({ event }) => event, { delay });
+const reschedule = (delay = 350) => machine.raise(({ event }) => event, { delay });
 const isLayoutChange = (change) => change.op === "reset-manual-layout" || change.op === "save-view-snapshot";
 const withoutSnapshotChanges = filter(isNot(isLayoutChange));
 const saveStateBeforeEdit = () => machine.assign(({ system }) => {
   const parentContext = getDiagramContext(system);
   return {
     beforeEditing: {
-      xynodes: parentContext.xynodes.map(
-        ({ measured, ...n }) => ({
-          ...omit(n, ["selected", "dragging", "resizing"]),
-          data: omit(n.data, ["dimmed", "hovered"]),
-          measured,
-          initialWidth: measured?.width ?? n.width ?? n.initialWidth,
-          initialHeight: measured?.height ?? n.height ?? n.initialHeight
-        })
-      ),
-      xyedges: parentContext.xyedges.map(
-        (e) => ({
-          ...omit(e, ["selected"]),
-          data: omit(e.data, ["active", "dimmed", "hovered"])
-        })
-      ),
+      xynodes: parentContext.xynodes.map(({ measured, data, ...n }) => ({
+        ...omit(n, ["selected", "dragging", "resizing"]),
+        data: omit(data, ["dimmed", "hovered"]),
+        measured,
+        initialWidth: measured?.width ?? n.width ?? n.initialWidth,
+        initialHeight: measured?.height ?? n.height ?? n.initialHeight
+      })),
+      xyedges: parentContext.xyedges.map(({ data, ...e }) => ({
+        ...omit(e, ["selected"]),
+        data: omit(data, ["active", "dimmed", "hovered"])
+      })),
       change: createViewChange(parentContext),
       view: parentContext.view,
       synched: false
@@ -67,13 +63,17 @@ const pushHistory = () => machine.assign(({ context }) => {
       editing: null
     };
   }
+  const history = [
+    ...context.history,
+    snapshot
+  ];
+  if (history.length > 50) {
+    history.shift();
+  }
   return {
     beforeEditing: null,
     editing: null,
-    history: [
-      ...context.history,
-      snapshot
-    ]
+    history
   };
 });
 const stopEditing = () => machine.enqueueActions(({ event, enqueue }) => {

package/dist/editor/editorActor.setup.d.ts

@@ -0,0 +1,84 @@
+import { NonReducibleUnknown, SetupReturn, PromiseActorLogic, EventObject, MetaObject } from 'xstate';
+import { Types } from '../likec4diagram/types';
+import { HotKeyEvent, HotkeyActorLogic } from './hotkeyActor';
+import type * as t from '@likec4/core/types';
+export declare namespace EditorCalls {
+    type ApplyLatestToManual = (params: {
+        input: ApplyLatestToManual.Input;
+    }) => Promise<ApplyLatestToManual.Output>;
+    namespace ApplyLatestToManual {
+        type Input = {
+            viewId: t.ViewId;
+            current: t.LayoutedView | undefined;
+        };
+        type Output = {
+            updated: t.LayoutedView;
+        };
+    }
+    type ExecuteChange = (params: {
+        input: ExecuteChange.Input;
+    }) => Promise<ExecuteChange.Output>;
+    namespace ExecuteChange {
+        type Input = {
+            viewId: t.ViewId;
+            changes: t.ViewChange[];
+        };
+        type Output = NonReducibleUnknown;
+    }
+}
+export type EditorActorEvent = {
+    type: 'sync';
+} | {
+    type: 'change';
+    change: t.ViewChange;
+} | {
+    type: 'edit.start';
+    subject: 'node' | 'edge';
+} | {
+    type: 'edit.finish';
+    wasChanged?: boolean;
+} | {
+    type: 'applyLatestToManual';
+} | {
+    type: 'synced';
+} | {
+    type: 'cancel';
+} | {
+    type: 'reset';
+} | HotKeyEvent;
+export type HistorySnapshot = {
+    view: t.LayoutedView;
+    change: t.ViewChange.SaveViewSnapshot;
+    xynodes: Types.Node[];
+    xyedges: Types.Edge[];
+    synched: boolean;
+};
+export interface EditorActorInput {
+    viewId: t.ViewId;
+}
+export interface EditorActorContext {
+    viewId: t.ViewId;
+    pendingChanges: t.ViewChange[];
+    history: ReadonlyArray<HistorySnapshot>;
+    /**
+     * The state before editing started
+     */
+    beforeEditing: HistorySnapshot | null;
+    /**
+     * The subject of the edit
+     */
+    editing: 'node' | 'edge' | null;
+}
+export type EditorActorEmitedEvent = {
+    type: 'idle';
+};
+export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
+    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+    executeChange: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+    hotkey: HotkeyActorLogic;
+}, {
+    hotkey: "hotkey";
+}, {}, {
+    'has pending': unknown;
+    'can undo': unknown;
+}, "500ms" | "waitBeforeSync", "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;

package/dist/editor/editorActor.setup.js

@@ -0,0 +1,38 @@
+import { setup, fromPromise } from 'xstate';
+import { hotkeyActorLogic } from './hotkeyActor.js';
+
+const applyLatest = fromPromise(
+  () => {
+    throw new Error("Not implemented");
+  }
+);
+const executeChange = fromPromise(
+  () => {
+    throw new Error("Not implemented");
+  }
+);
+const machine = setup({
+  types: {
+    context: {},
+    events: {},
+    emitted: {},
+    input: {},
+    children: {},
+    tags: {}
+  },
+  delays: {
+    "500ms": 500,
+    "waitBeforeSync": 2e3
+  },
+  actors: {
+    applyLatest,
+    executeChange,
+    hotkey: hotkeyActorLogic
+  },
+  guards: {
+    "has pending": ({ context }) => context.pendingChanges.length > 0,
+    "can undo": ({ context }) => context.history.length > 0
+  }
+});
+
+export { machine };

package/dist/editor/editorActor.states.d.ts

@@ -0,0 +1,9 @@
+import { ActorRef, SnapshotFrom, StateMachine } from 'xstate';
+import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput } from './editorActor.setup';
+export type { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, } from './editorActor.setup';
+export interface EditorActorLogic extends StateMachine<EditorActorContext, EditorActorEvent, any, any, any, any, any, 'idle' | 'editing' | 'pending' | 'afterEdit' | 'applyLatestToManual' | 'executeChanges', any, EditorActorInput, any, EditorActorEmitedEvent, any, any> {
+}
+export declare const editorActorLogic: EditorActorLogic;
+export type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;
+export interface EditorActorRef extends ActorRef<EditorActorSnapshot, EditorActorEvent, EditorActorEmitedEvent> {
+}

package/dist/editor/{editorActor.js → editorActor.states.js}

@@ -1,44 +1,11 @@
 import { find } from 'remeda';
-import { setup, assign, fromPromise, enqueueActions, sendTo, log } from 'xstate';
-import { cancelSync, stopHotkey, undo, markHistoryAsSynched, reschedule, isLayoutChange, withoutSnapshotChanges, addSnapshotToPendingChanges, ensureHotKey, pushHistory, saveStateBeforeEdit, stopEditing, startEditing } from './editorActor.actions.js';
-import { hotkeyActorLogic } from './hotkeyActor.js';
+import { assign, enqueueActions, log, sendTo } from 'xstate';
+import { cancelSync, stopHotkey, undo, markHistoryAsSynched, isLayoutChange, withoutSnapshotChanges, addSnapshotToPendingChanges, ensureHotKey, reschedule, pushHistory, saveStateBeforeEdit, stopEditing, startEditing } from './editorActor.actions.js';
+import { machine } from './editorActor.setup.js';
 
-const applyLatest = fromPromise(
-  () => {
-    throw new Error("Not implemented");
-  }
-);
-const executeChange = fromPromise(
-  () => {
-    throw new Error("Not implemented");
-  }
-);
 const diagramActorRef = function(params) {
   return params.system.get("diagram");
 };
-const machine = setup({
-  types: {
-    context: {},
-    events: {},
-    emitted: {},
-    input: {},
-    children: {},
-    tags: {}
-  },
-  delays: {
-    "350ms": 350,
-    "waitBeforeSync": 2e3
-  },
-  actors: {
-    applyLatest,
-    executeChange,
-    hotkey: hotkeyActorLogic
-  },
-  guards: {
-    "has pending": ({ context }) => context.pendingChanges.length > 0,
-    "can undo": ({ context }) => context.history.length > 0
-  }
-});
 const to = {
   idle: { target: "#idle" },
   editing: { target: "#editing" },
@@ -120,15 +87,6 @@ const applyLatestToManual = machine.createStateConfig({
     saveStateBeforeEdit()
   ],
   initial: "call",
-  on: {
-    // catch all events
-    "*": {
-      actions: [
-        log(({ event }) => `applyLatestToManual received unexpected event: ${event.type}`),
-        reschedule(350)
-      ]
-    }
-  },
   states: {
     // Fetch latest and manual layouts
     // Apply changes, send update to diagram
@@ -170,8 +128,16 @@ const applyLatestToManual = machine.createStateConfig({
     // Now we wait 350ms, take new snapshot and send save-view-snapshot
     wait: {
       entry: pushHistory(),
+      on: {
+        "*": {
+          actions: [
+            log(({ event }) => `wait received unexpected event: ${event.type}`),
+            reschedule(500)
+          ]
+        }
+      },
       after: {
-        "350ms": {
+        "500ms": {
           actions: [
             addSnapshotToPendingChanges(),
             ensureHotKey()
@@ -215,7 +181,7 @@ const executeChanges = machine.createStateConfig({
       viewId: context.viewId
     }),
     onDone: {
-      actions: enqueueActions(({ context, enqueue }) => {
+      actions: enqueueActions(({ context, event, enqueue }) => {
         const snapshot = find(context.pendingChanges, (c) => c.op === "save-view-snapshot");
         if (snapshot) {
           enqueue.sendTo(
@@ -233,15 +199,13 @@ const executeChanges = machine.createStateConfig({
       ...to.idle
     },
     onError: {
-      actions: ({ event }) => {
-        console.error(event.error);
-      },
-      ...to.afterEdit
-    }
-  },
-  on: {
-    "*": {
-      actions: reschedule()
+      actions: assign(({ event }) => {
+        console.error("executeChanges onError", { error: event.error });
+        return {
+          pendingChanges: []
+        };
+      }),
+      ...to.idle
     }
   }
 });
@@ -255,21 +219,6 @@ const _editorActorLogic = machine.createMachine({
     history: []
   }),
   initial: "idle",
-  // TODO: listen to diagram actor, if switches to "sequence" dynamic view, cancel editing
-  // entry: ({ self, system }) => {
-  //   // let previous = ''
-  //   // const a = (self._parent as DiagramMachineRef).subscribe({
-  //   //   next({ context }) {
-  //   //     const current = context.view._type === 'dynamic' ? context.dynamicViewVariant
-  //   //   },
-  //   // })
-  //   const s = self.subscribe({
-  //     complete: () => {
-  //       console.log('editor actor completed')
-  //       s.unsubscribe()
-  //     },
-  //   })
-  // },
   states: {
     idle,
     editing,
@@ -321,4 +270,4 @@ const _editorActorLogic = machine.createMachine({
 });
 const editorActorLogic = _editorActorLogic;
 
-export { editorActorLogic, machine };
+export { editorActorLogic };

package/dist/editor/index.d.ts

@@ -1,3 +1,4 @@
-export { EnsureEditorContext, LikeC4EditorProvider, useOptionalLikeC4EditorPort, } from './LikeC4EditorProvider';
-export type { LikeC4EditorPort } from './LikeC4EditorProvider';
-export type * from './editorActor';
+export type * from './editorActor.states';
+export { createLikeC4Editor } from './LikeC4EditorCallbacks';
+export type { LikeC4EditorCallbacks } from './LikeC4EditorCallbacks';
+export { EnsureEditorContext, LikeC4EditorProvider, useOptionalLikeC4Editor, } from './LikeC4EditorProvider';