@likec4/diagram 1.46.4 → 1.48.0

package/dist/editor/LikeC4EditorProvider.d.ts

@@ -1,22 +1,34 @@
-import { PropsWithChildren, Context } from 'react';
-import type * as t from '@likec4/core/types';
-export type LikeC4EditorPort = {
-    /**
-     * Fetch a view by its ID and layout type.
-     *
-     * @param viewId - The ID of the view to fetch.
-     * @param layout - The layout type to use when fetching the view.
-     */
-    fetchView(viewId: t.ViewId, layout?: t.LayoutType): t.LayoutedView | Promise<t.LayoutedView>;
-    /**
-     * Callback invoked when the view changes.
-     */
-    handleChange(viewId: t.ViewId, change: t.ViewChange): void | Promise<void>;
-};
+import { PropsWithChildren } from 'react';
+import { LikeC4EditorCallbacks } from './LikeC4EditorCallbacks';
 export type LikeC4EditorProviderProps = PropsWithChildren<{
-    editor: LikeC4EditorPort;
+    editor: LikeC4EditorCallbacks;
 }>;
-export declare const LikeC4EditorReactContext: Context<LikeC4EditorPort | null>;
+/**
+ * Provider for the LikeC4 Editor.
+ * @example
+ * ```tsx
+ *
+ * // Not required to use memo for editor callbacks
+ * const editor = createLikeC4Editor({
+ *   fetchView: async (viewId, layout) => {
+ *     // fetch view logic
+ *   },
+ *   handleChange: (viewId, change) => {
+ *     // handle change logic
+ *   }
+ * })
+ *
+ * <LikeC4EditorProvider
+ *  editor={editor}>
+ *   <App />
+ * </LikeC4EditorProvider>
+ * ```
+ */
 export declare function LikeC4EditorProvider({ children, editor }: LikeC4EditorProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Component that ensures the editor context is available.
+ *
+ * @param children - The children to render.
+ */
 export declare function EnsureEditorContext({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element | null;
-export declare function useOptionalLikeC4EditorPort(): LikeC4EditorPort | null;
+export declare function useOptionalLikeC4Editor(): LikeC4EditorCallbacks | null;

package/dist/editor/LikeC4EditorProvider.js

@@ -5,8 +5,8 @@ const LikeC4EditorReactContext = createContext(null);
 function LikeC4EditorProvider({ children, editor }) {
   return /* @__PURE__ */ jsx(LikeC4EditorReactContext.Provider, { value: editor, children });
 }
-function useOptionalLikeC4EditorPort() {
+function useOptionalLikeC4Editor() {
   return useContext(LikeC4EditorReactContext);
 }
 
-export { LikeC4EditorProvider, LikeC4EditorReactContext, useOptionalLikeC4EditorPort };
+export { LikeC4EditorProvider, useOptionalLikeC4Editor };

package/dist/editor/applyChangesToManualLayout.js

@@ -144,6 +144,7 @@ function makeAsStraightLine(edge, sourceNode, targetNode) {
   const controlPoints = edgeControlPoints(sourceNode, targetNode);
   const labelPos = controlPoints[0];
   return produce(edge, (draft) => {
+    draft.points = controlPoints.map((p) => [p.x, p.y]);
     draft.controlPoints = controlPoints;
     if (edge.labelBBox) {
       draft.labelBBox.x = labelPos.x;

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,6 +1,6 @@
 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) {
   return system.get("diagram");
@@ -10,7 +10,7 @@ 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 }) => {

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" },
@@ -125,7 +92,7 @@ const applyLatestToManual = machine.createStateConfig({
     "*": {
       actions: [
         log(({ event }) => `applyLatestToManual received unexpected event: ${event.type}`),
-        reschedule(350)
+        reschedule(500)
       ]
     }
   },
@@ -170,8 +137,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 +190,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 +208,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 +228,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 +279,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';