@likec4/diagram 1.56.0 → 1.57.0

package/dist/editor/actor/machine.js

@@ -0,0 +1,22 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { machine } from "./setup.js";
+import { editor } from "./state.editor.js";
+import { syncQueue } from "./state.sync-queue.js";
+var editorActorLogic = machine.createMachine({
+	id: "editor",
+	context: ({ input }) => ({
+		viewId: input.viewId,
+		editing: null,
+		history: null,
+		pending: null,
+		syncQueue: [],
+		processing: null
+	}),
+	type: "parallel",
+	states: {
+		editor,
+		syncQueue
+	}
+});
+//#endregion
+export { editorActorLogic };

package/dist/editor/{editorActor.setup.d.ts → actor/setup.d.ts}

@@ -1,6 +1,6 @@
 import { NonReducibleUnknown, SetupReturn, PromiseActorLogic, EventObject, MetaObject } from 'xstate';
-import { Types } from '../likec4diagram/types';
-import { HotKeyEvent, HotkeyActorLogic } from './hotkeyActor';
+import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, EditorActorStateTag } from './types';
+import { HotkeyActorLogic } from './hotkey';
 import type * as t from '@likec4/core/types';
 export declare namespace EditorCalls {
     type ApplyLatestToManual = (params: {
@@ -15,6 +15,15 @@ export declare namespace EditorCalls {
             updated: t.LayoutedView;
         };
     }
+    type ApplySemanticLayout = (params: {
+        input: ApplySemanticLayout.Input;
+    }) => Promise<ApplySemanticLayout.Output>;
+    namespace ApplySemanticLayout {
+        type Input = {
+            viewId: t.ViewId;
+        };
+        type Output = {};
+    }
     type ExecuteChange = (params: {
         input: ExecuteChange.Input;
     }) => Promise<ExecuteChange.Output>;
@@ -26,59 +35,14 @@ export declare namespace EditorCalls {
         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>;
+    applySemanticLayout: PromiseActorLogic<EditorCalls.ApplySemanticLayout.Output, EditorCalls.ApplySemanticLayout.Input, EventObject>;
     hotkey: HotkeyActorLogic;
 }, {
     hotkey: "hotkey";
 }, {}, {
     'has pending': unknown;
     'can undo': unknown;
-}, "500ms" | "waitBeforeSync", "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;
+}, "500ms" | "wait-after-edit", EditorActorStateTag, EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;

package/dist/editor/{editorActor.setup.js → actor/setup.js}

@@ -1,5 +1,5 @@
-import "../_virtual/_rolldown/runtime.js";
-import { hotkeyActorLogic } from "./hotkeyActor.js";
+import "../../_virtual/_rolldown/runtime.js";
+import { hotkey } from "./hotkey.js";
 import { fromPromise, setup } from "xstate";
 var machine = setup({
 	types: {
@@ -8,11 +8,7 @@ var machine = setup({
 		emitted: {},
 		input: {},
 		children: {},
-		tags: {}
-	},
-	delays: {
-		"500ms": 500,
-		"waitBeforeSync": 1e3
+		tags: ""
 	},
 	actors: {
 		applyLatest: fromPromise(() => {
@@ -21,11 +17,18 @@ var machine = setup({
 		executeChange: fromPromise(() => {
 			throw new Error("Not implemented");
 		}),
-		hotkey: hotkeyActorLogic
+		applySemanticLayout: fromPromise(() => {
+			throw new Error("Not implemented");
+		}),
+		hotkey
+	},
+	delays: {
+		"500ms": 500,
+		"wait-after-edit": 1e3
 	},
 	guards: {
-		"has pending": ({ context }) => context.pendingChanges.length > 0,
-		"can undo": ({ context }) => context.history.length > 0
+		"has pending": ({ context }) => context.syncQueue.length > 0 || !!context.processing,
+		"can undo": ({ context }) => context.history !== null
 	}
 });
 //#endregion

package/dist/editor/actor/state.editor.d.ts

@@ -0,0 +1,97 @@
+import { StopAction, ActionFunction, PromiseActorLogic, EventObject, NonReducibleUnknown } from 'xstate';
+import { EditorActorContext, EditorActorEvent, EditorActorEmitedEvent } from './types';
+import { HotkeyActorLogic } from './hotkey';
+export declare const editor: {
+    initial: string;
+    states: {
+        idle: {
+            on: {
+                'edit.move.start': {
+                    target: "#moving";
+                };
+            };
+            id: string;
+        };
+        moving: {
+            entry: StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            on: {
+                'edit.move.end': {
+                    target: "#idle";
+                    actions: ( ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "500ms" | "wait-after-edit", never> | ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>)[];
+                };
+                'edit.move.cancel': {
+                    target: "#idle";
+                    actions: ActionFunction<EditorActorContext, {
+                        type: "edit.move.cancel";
+                    }, EditorActorEvent, undefined, {
+                        src: "hotkey";
+                        logic: HotkeyActorLogic;
+                        id: "hotkey";
+                    } | {
+                        src: "applyLatest";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "executeChange";
+                        logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                        id: string | undefined;
+                    } | {
+                        src: "applySemanticLayout";
+                        logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                        id: string | undefined;
+                    }, never, never, never, never>[];
+                };
+                undo: {
+                    target: "#idle";
+                };
+            };
+            id: string;
+        };
+    };
+    on: {
+        cancel: {
+            target: "#idle";
+        };
+        '*': {
+            actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, {
+                src: "hotkey";
+                logic: HotkeyActorLogic;
+                id: "hotkey";
+            } | {
+                src: "applyLatest";
+                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplyLatestToManual.Output, import("./setup").EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                id: string | undefined;
+            } | {
+                src: "executeChange";
+                logic: PromiseActorLogic<NonReducibleUnknown, import("./setup").EditorCalls.ExecuteChange.Input, EventObject>;
+                id: string | undefined;
+            } | {
+                src: "applySemanticLayout";
+                logic: PromiseActorLogic<import("./setup").EditorCalls.ApplySemanticLayout.Output, import("./setup").EditorCalls.ApplySemanticLayout.Input, EventObject>;
+                id: string | undefined;
+            }, never, {
+                type: "has pending";
+                params: unknown;
+            } | {
+                type: "can undo";
+                params: unknown;
+            }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+        };
+    };
+};

package/dist/editor/actor/state.editor.js

@@ -0,0 +1,55 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { machine } from "./setup.js";
+import { pushHistory, saveBeforeEditing, scheduleSync } from "./actions.js";
+import { assign } from "xstate";
+//#region src/editor/actor/state.editor.ts
+var to = {
+	idle: { target: "#idle" },
+	moving: { target: "#moving" }
+};
+var idOf = (t) => ({ id: t.target.substring(1) });
+var stopHotkey = () => machine.stopChild("hotkey");
+var ensureHotKey = () => machine.enqueueActions(({ check, enqueue, self }) => {
+	const hasUndo = check("can undo");
+	const hotkey = self.getSnapshot().children["hotkey"];
+	if (!hasUndo && hotkey) {
+		enqueue.stopChild(hotkey);
+		return;
+	}
+	if (hasUndo && !hotkey) enqueue.spawnChild("hotkey", { id: "hotkey" });
+});
+/**
+* Idle state, no pending operations
+*/
+var idle = machine.createStateConfig({
+	...idOf(to.idle),
+	on: { "edit.move.start": { ...to.moving } }
+});
+var moving = machine.createStateConfig({
+	...idOf(to.moving),
+	entry: [saveBeforeEditing, stopHotkey()],
+	on: {
+		"edit.move.end": {
+			actions: [pushHistory(), scheduleSync()],
+			...to.idle
+		},
+		"edit.move.cancel": {
+			actions: [assign({ editing: null })],
+			...to.idle
+		},
+		"undo": { ...to.idle }
+	}
+});
+var editor = machine.createStateConfig({
+	initial: "idle",
+	states: {
+		idle,
+		moving
+	},
+	on: {
+		"cancel": { ...to.idle },
+		"*": { actions: ensureHotKey() }
+	}
+});
+//#endregion
+export { editor };