@likec4/diagram 1.56.0 → 1.58.0

package/dist/editor/{hotkeyActor.js → actor/hotkey.js}

@@ -1,8 +1,8 @@
-import "../_virtual/_rolldown/runtime.js";
+import "../../_virtual/_rolldown/runtime.js";
 import { getHotkeyHandler } from "@mantine/hooks";
 import { fromCallback } from "xstate";
-//#region src/editor/hotkeyActor.ts
-var hotkeyActorLogic = fromCallback(({ sendBack }) => {
+//#region src/editor/actor/hotkey.ts
+var hotkey = fromCallback(({ sendBack }) => {
 	const ctrlZHandler = getHotkeyHandler([[
 		"mod + z",
 		(event) => {
@@ -10,6 +10,13 @@ var hotkeyActorLogic = fromCallback(({ sendBack }) => {
 			sendBack({ type: "undo" });
 		},
 		{ preventDefault: true }
+	], [
+		"mod + shift + z",
+		(event) => {
+			event.stopPropagation();
+			sendBack({ type: "redo" });
+		},
+		{ preventDefault: true }
 	]]);
 	document.body.addEventListener("keydown", ctrlZHandler, { capture: true });
 	return () => {
@@ -17,4 +24,4 @@ var hotkeyActorLogic = fromCallback(({ sendBack }) => {
 	};
 });
 //#endregion
-export { hotkeyActorLogic };
+export { hotkey };

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

@@ -1,7 +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> {
+import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, EditorActorStateTag } from './types';
+export interface EditorActorLogic extends StateMachine<EditorActorContext, EditorActorEvent, any, any, any, any, any, {
+    editor: 'idle' | 'moving';
+    syncQueue: 'idle' | 'pending' | 'suspended' | 'process';
+}, EditorActorStateTag, EditorActorInput, any, EditorActorEmitedEvent, any, any> {
 }
 export declare const editorActorLogic: EditorActorLogic;
 export type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;

package/dist/editor/actor/machine.js

@@ -0,0 +1,23 @@
+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,
+		redo: null,
+		pending: null,
+		syncQueue: [],
+		processing: null
+	}),
+	type: "parallel",
+	states: {
+		editor,
+		syncQueue
+	}
+});
+//#endregion
+export { editorActorLogic };

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

@@ -0,0 +1,55 @@
+import { EditorActorContext, EditorActorEmitedEvent, EditorActorEvent, EditorActorInput, EditorActorStateTag } from './types';
+import { SetupReturn, PromiseActorLogic, EventObject, NonReducibleUnknown, MetaObject } from 'xstate';
+import { HotkeyActorLogic } from './hotkey';
+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 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>;
+    namespace ExecuteChange {
+        type Input = {
+            viewId: t.ViewId;
+            changes: t.ViewChange[];
+        };
+        /**
+         * Returns the changes that were applied to the view
+         */
+        type Output = {
+            requested: t.ViewChange[];
+            applied: t.ViewChange[];
+        };
+    }
+}
+export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
+    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+    executeChange: PromiseActorLogic<EditorCalls.ExecuteChange.Output, EditorCalls.ExecuteChange.Input, EventObject>;
+    applySemanticLayout: PromiseActorLogic<EditorCalls.ApplySemanticLayout.Output, EditorCalls.ApplySemanticLayout.Input, EventObject>;
+    hotkey: HotkeyActorLogic;
+}, {
+    hotkey: "hotkey";
+}, {}, {
+    'has pending': unknown;
+    'can undo': unknown;
+    'can redo': unknown;
+}, "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,19 @@ 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,
+		"can undo": ({ context }) => context.history !== null,
+		"can redo": ({ context }) => context.redo !== null
 	}
 });
 //#endregion

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

@@ -0,0 +1,147 @@
+import { StopAction, ActionFunction, PromiseActorLogic, EventObject } 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>[];
+            exit: 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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
+            } | {
+                type: "can redo";
+                params: unknown;
+            }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>[];
+            on: {
+                'edit.move.end': {
+                    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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
+                    } | {
+                        type: "can redo";
+                        params: unknown;
+                    }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+                };
+                'edit.move.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<import("./setup").EditorCalls.ExecuteChange.Output, 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>;
+                };
+                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<import("./setup").EditorCalls.ExecuteChange.Output, 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>;
+                };
+            };
+            id: string;
+        };
+    };
+    on: {
+        '*': {
+            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<import("./setup").EditorCalls.ExecuteChange.Output, 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;
+            } | {
+                type: "can redo";
+                params: unknown;
+            }, "500ms" | "wait-after-edit", EditorActorEmitedEvent>;
+        };
+    };
+};

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

@@ -0,0 +1,56 @@
+import "../../_virtual/_rolldown/runtime.js";
+import { machine } from "./setup.js";
+import { pushHistory, saveBeforeEditing } from "./actions.js";
+//#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") || check("can redo");
+	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 clearEditing = () => machine.assign({ editing: null });
+var moving = machine.createStateConfig({
+	...idOf(to.moving),
+	entry: [saveBeforeEditing(), stopHotkey()],
+	exit: [ensureHotKey()],
+	on: {
+		"edit.move.end": {
+			actions: pushHistory(),
+			...to.idle
+		},
+		"edit.move.cancel": {
+			actions: clearEditing(),
+			...to.idle
+		},
+		"cancel": {
+			actions: clearEditing(),
+			...to.idle
+		}
+	}
+});
+var editor = machine.createStateConfig({
+	initial: "idle",
+	states: {
+		idle,
+		moving
+	},
+	on: { "*": { actions: ensureHotKey() } }
+});
+//#endregion
+export { editor };