@likec4/diagram 1.44.0 → 1.46.0

package/dist/editor/useEditorActorLogic.d.ts

@@ -0,0 +1,565 @@
+import { EditorCalls, EditorActorContext, EditorActorEvent, EditorActorInput, EditorActorEmitedEvent } from './editorActor';
+import { StateMachine, ActorRefFromLogic, PromiseActorLogic, EventObject, NonReducibleUnknown, Values, MetaObject, ConditionalRequired, InputFrom, RequiredActorOptions, IsNotNever, GetConcreteByKey, AnyActorLogic, RequiredLogicInput, ActorRef, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, CancelAction, ActionFunction, LogAction, DoneActorEvent, ErrorActorEvent, ActionArgs, StopAction } from 'xstate';
+import { HotkeyActorLogic } from './hotkeyActor';
+import type * as t from '@likec4/core/types';
+export declare function useEditorActorLogic(viewId: t.ViewId): StateMachine<EditorActorContext, EditorActorEvent, {
+    [x: string]: ActorRefFromLogic<HotkeyActorLogic> | ActorRefFromLogic<PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>> | ActorRefFromLogic<PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>> | undefined;
+    hotkey?: ActorRefFromLogic<HotkeyActorLogic>;
+}, Values<{
+    hotkey: {
+        src: "hotkey";
+        logic: HotkeyActorLogic;
+        id: "hotkey";
+    };
+    applyLatest: {
+        src: "applyLatest";
+        logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+        id: string | undefined;
+    };
+    executeChange: {
+        src: "executeChange";
+        logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+        id: string | undefined;
+    };
+}>, never, Values<{
+    "has pending": {
+        type: "has pending";
+        params: unknown;
+    };
+    "can undo": {
+        type: "can undo";
+        params: unknown;
+    };
+}>, "350ms" | "waitBeforeSync", "pending" | "idle" | "editing" | "afterEdit" | "executeChanges" | {
+    applyLatestToManual: "call" | "wait";
+}, "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject, {
+    readonly id: "editor";
+    readonly context: ({ input }: {
+        spawn: {
+            <TSrc extends "hotkey" | "applyLatest" | "executeChange">(logic: TSrc, ...[options]: ({
+                src: "hotkey";
+                logic: HotkeyActorLogic;
+                id: "hotkey";
+            } extends infer T ? T extends {
+                src: "hotkey";
+                logic: HotkeyActorLogic;
+                id: "hotkey";
+            } ? T extends {
+                src: TSrc;
+            } ? ConditionalRequired<[options?: {
+                id?: T["id"];
+                systemId?: string;
+                input?: InputFrom<T["logic"]>;
+                syncSnapshot?: boolean;
+            } & { [K in RequiredActorOptions<T>]: unknown; }], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
+                src: "applyLatest";
+                logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                id: string | undefined;
+            } extends infer T_1 ? T_1 extends {
+                src: "applyLatest";
+                logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                id: string | undefined;
+            } ? T_1 extends {
+                src: TSrc;
+            } ? ConditionalRequired<[options?: {
+                id?: T_1["id"];
+                systemId?: string;
+                input?: InputFrom<T_1["logic"]>;
+                syncSnapshot?: boolean;
+            } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never) | ({
+                src: "executeChange";
+                logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                id: string | undefined;
+            } extends infer T_2 ? T_2 extends {
+                src: "executeChange";
+                logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                id: string | undefined;
+            } ? T_2 extends {
+                src: TSrc;
+            } ? ConditionalRequired<[options?: {
+                id?: T_2["id"];
+                systemId?: string;
+                input?: InputFrom<T_2["logic"]>;
+                syncSnapshot?: boolean;
+            } & { [K_2 in RequiredActorOptions<T_2>]: unknown; }], IsNotNever<RequiredActorOptions<T_2>>> : never : never : never)): ActorRefFromLogic< GetConcreteByKey<Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, "src", TSrc>["logic"]>;
+            <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
+                id?: never;
+                systemId?: string;
+                input?: InputFrom<TLogic>;
+                syncSnapshot?: boolean;
+            } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+        };
+        input: EditorActorInput;
+        self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+    }) => {
+        viewId: t.ViewId;
+        beforeEditing: null;
+        editing: null;
+        pendingChanges: never[];
+        history: never[];
+    };
+    readonly initial: "idle";
+    readonly states: {
+        readonly idle: {
+            id: string;
+            on: {
+                sync: {
+                    target: "#pending";
+                };
+                'edit.start': {
+                    target: "#editing";
+                };
+            };
+        };
+        readonly editing: {
+            id: string;
+            tags: "pending";
+            entry: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            on: {
+                change: {
+                    target: "#executeChanges";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+                'edit.finish': {
+                    target: "#afterEdit";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+                undo: {
+                    target: "#idle";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+            };
+        };
+        readonly pending: {
+            id: string;
+            tags: "pending"[];
+            entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, Values<{
+                "has pending": {
+                    type: "has pending";
+                    params: unknown;
+                };
+                "can undo": {
+                    type: "can undo";
+                    params: unknown;
+                };
+            }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+            on: {
+                sync: {
+                    target: "#pending";
+                    reenter: true;
+                };
+                'edit.start': {
+                    target: "#editing";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, never, never, never>[];
+                };
+            };
+            after: {
+                waitBeforeSync: {
+                    target: "#executeChanges";
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, never, never, never>[];
+                };
+            };
+        };
+        readonly afterEdit: {
+            id: string;
+            always: ({
+                target: "#pending";
+                guard: "has pending";
+            } | {
+                target: "#idle";
+            })[];
+        };
+        readonly applyLatestToManual: {
+            id: string;
+            entry: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            initial: string;
+            on: {
+                '*': {
+                    actions: LogAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+                };
+            };
+            states: {
+                call: {
+                    invoke: {
+                        src: "applyLatest";
+                        input: ({ context }: {
+                            context: EditorActorContext;
+                            event: EditorActorEvent;
+                            self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                        }) => {
+                            current: t.DiagramView | undefined;
+                            viewId: t.ViewId;
+                        };
+                        onDone: {
+                            actions: ActionFunction<EditorActorContext, DoneActorEvent<EditorCalls.ApplyLatestToManual.Output, string>, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+                            target: string;
+                        };
+                        onError: {
+                            target: "#idle";
+                            actions: ( ActionFunction<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent, undefined, Values<{
+                                hotkey: {
+                                    src: "hotkey";
+                                    logic: HotkeyActorLogic;
+                                    id: "hotkey";
+                                };
+                                applyLatest: {
+                                    src: "applyLatest";
+                                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                                executeChange: {
+                                    src: "executeChange";
+                                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, never, never, never> | (({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void))[];
+                        };
+                    };
+                };
+                wait: {
+                    entry: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, never, never, never>;
+                    after: {
+                        '350ms': {
+                            target: "#executeChanges";
+                            actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                                hotkey: {
+                                    src: "hotkey";
+                                    logic: HotkeyActorLogic;
+                                    id: "hotkey";
+                                };
+                                applyLatest: {
+                                    src: "applyLatest";
+                                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                                executeChange: {
+                                    src: "executeChange";
+                                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                                    id: string | undefined;
+                                };
+                            }>, never, Values<{
+                                "has pending": {
+                                    type: "has pending";
+                                    params: unknown;
+                                };
+                                "can undo": {
+                                    type: "can undo";
+                                    params: unknown;
+                                };
+                            }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>[];
+                        };
+                    };
+                };
+            };
+        };
+        readonly executeChanges: {
+            id: string;
+            entry: CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>[];
+            invoke: {
+                src: "executeChange";
+                input: ({ context }: {
+                    context: EditorActorContext;
+                    event: EditorActorEvent;
+                    self: ActorRef<MachineSnapshot<EditorActorContext, EditorActorEvent, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, EditorActorEvent, AnyEventObject>;
+                }) => {
+                    changes: t.ViewChange[];
+                    viewId: t.ViewId;
+                };
+                onDone: {
+                    target: "#idle";
+                    actions: ActionFunction<EditorActorContext, DoneActorEvent<NonReducibleUnknown, string>, EditorActorEvent, undefined, Values<{
+                        hotkey: {
+                            src: "hotkey";
+                            logic: HotkeyActorLogic;
+                            id: "hotkey";
+                        };
+                        applyLatest: {
+                            src: "applyLatest";
+                            logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                        executeChange: {
+                            src: "executeChange";
+                            logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                            id: string | undefined;
+                        };
+                    }>, never, Values<{
+                        "has pending": {
+                            type: "has pending";
+                            params: unknown;
+                        };
+                        "can undo": {
+                            type: "can undo";
+                            params: unknown;
+                        };
+                    }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+                };
+                onError: {
+                    target: "#afterEdit";
+                    actions: ({ event }: ActionArgs<EditorActorContext, ErrorActorEvent<unknown, string>, EditorActorEvent>) => void;
+                };
+            };
+            on: {
+                '*': {
+                    actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, never, never, never, "350ms" | "waitBeforeSync", never>;
+                };
+            };
+        };
+    };
+    readonly on: {
+        readonly cancel: {
+            readonly target: "#idle";
+            readonly actions: readonly [ CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>, ActionFunction<EditorActorContext, {
+                type: "cancel";
+            }, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>];
+        };
+        readonly synced: {
+            readonly actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>;
+        };
+        readonly undo: {
+            readonly target: "#idle";
+            readonly guard: "can undo";
+            readonly actions: ActionFunction<EditorActorContext, EditorActorEvent, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, Values<{
+                "has pending": {
+                    type: "has pending";
+                    params: unknown;
+                };
+                "can undo": {
+                    type: "can undo";
+                    params: unknown;
+                };
+            }>, "350ms" | "waitBeforeSync", EditorActorEmitedEvent>;
+        };
+        readonly change: {
+            readonly target: "#executeChanges";
+        };
+        readonly applyLatestToManual: {
+            readonly target: "#applyLatestToManual";
+        };
+        readonly reset: {
+            readonly target: "#idle";
+            readonly actions: readonly [ CancelAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>, ActionFunction<EditorActorContext, {
+                type: "reset";
+            }, EditorActorEvent, undefined, Values<{
+                hotkey: {
+                    src: "hotkey";
+                    logic: HotkeyActorLogic;
+                    id: "hotkey";
+                };
+                applyLatest: {
+                    src: "applyLatest";
+                    logic: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
+                    id: string | undefined;
+                };
+                executeChange: {
+                    src: "executeChange";
+                    logic: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
+                    id: string | undefined;
+                };
+            }>, never, never, never, never>, StopAction<EditorActorContext, EditorActorEvent, undefined, EditorActorEvent>];
+        };
+    };
+}>;

package/dist/editor/useEditorActorLogic.js

@@ -0,0 +1,54 @@
+import { fromPromise } from 'xstate';
+import { applyChangesToManualLayout } from './applyChangesToManualLayout.js';
+import { editorActorLogic } from './editorActor.js';
+import { useOptionalLikeC4EditorPort } from './LikeC4EditorProvider.js';
+import { useCallbackRef } from '../hooks/useCallbackRef.js';
+
+function useEditorActorLogic(viewId) {
+  const port = useOptionalLikeC4EditorPort();
+  const applyLatest = useCallbackRef(
+    async ({ input: { viewId: viewId2, current } }) => {
+      if (!port) {
+        console.error("No editor port available for applying latest to manual layout");
+        return Promise.reject(new Error("No editor port"));
+      }
+      const [manual, latest] = await Promise.all([
+        current ?? Promise.resolve().then(() => port.fetchView(viewId2, "manual")),
+        Promise.resolve().then(() => port.fetchView(viewId2, "auto"))
+      ]).catch((err) => {
+        console.error("Failed to fetch views for applying latest to manual layout", err);
+        return Promise.reject(err);
+      });
+      const updated = applyChangesToManualLayout(manual, latest);
+      return {
+        updated
+      };
+    }
+  );
+  const executeChange = useCallbackRef(
+    async ({ input }) => {
+      if (!port) {
+        console.error("No editor port available for executing change");
+        return Promise.reject(new Error("No editor port"));
+      }
+      for (const change of input.changes) {
+        await Promise.resolve().then(() => port.handleChange(viewId, change)).catch((err) => {
+          console.error("Failed to execute change", {
+            change,
+            err
+          });
+          return Promise.reject(err);
+        });
+      }
+      return {};
+    }
+  );
+  return editorActorLogic.provide({
+    actors: {
+      applyLatest: fromPromise(applyLatest),
+      executeChange: fromPromise(executeChange)
+    }
+  });
+}
+
+export { useEditorActorLogic };

package/dist/hooks/index.d.ts

@@ -1,6 +1,7 @@
 export { useCallbackRef } from './useCallbackRef';
 export { useId } from './useId';
 export { useMantinePortalProps } from './useMantinePortalProps';
+export { useMediaPrint } from './useMediaPrint';
 export { useSetState } from './useSetState';
 export { useUpdateEffect } from './useUpdateEffect';
 export { useCurrentZoom, useIsZoomTooSmall, useXYFlow, useXYInternalNode, useXYStore, useXYStoreApi } from './useXYFlow';
@@ -8,6 +9,6 @@ export type { XYFlowInstance, XYStoreApi, XYStoreState } from './useXYFlow';
 export { useCurrentView, useCurrentViewId } from './useCurrentView';
 export { useCurrentViewModel } from './useCurrentViewModel';
 export { useLikeC4Model, useLikeC4Specification, useLikeC4ViewModel } from './useLikeC4Model';
-export { useHasProjects, useLikeC4ProjectId, useLikeC4Projects, useLikeC4ProjectsContext, } from './useLikeC4Project';
+export { useHasProjects, useLikeC4Project, useLikeC4ProjectId, useLikeC4Projects, useLikeC4ProjectsContext, } from './useLikeC4Project';
 export { useLikeC4Styles } from './useLikeC4Styles';
 export * from './useDiagram';

package/dist/hooks/safeContext.d.ts

@@ -1,7 +1,8 @@
+import { DiagramActorRef } from '../custom';
 import { DiagramApi } from '../likec4diagram/state/diagram-api';
 import { Provider } from 'react';
 import { UnknownLayouted } from '@likec4/core';
-import { DiagramActorRef } from '../custom';
-export declare const DiagramActorContextProvider: Provider<DiagramApi< UnknownLayouted>>;
+export declare const DiagramActorContextProvider: Provider<DiagramActorRef>;
+export declare const DiagramApiContextProvider: Provider<DiagramApi< UnknownLayouted>>;
 export declare function useDiagramActorRef(): DiagramActorRef;
 export declare function useDiagram(): DiagramApi< UnknownLayouted>;

package/dist/hooks/safeContext.js

@@ -2,20 +2,23 @@ import { useContext, createContext } from 'react';
 
 const DiagramActorSafeContext = createContext(null);
 DiagramActorSafeContext.displayName = "DiagramActorSafeContext";
+const DiagramApiSafeContext = createContext(null);
+DiagramApiSafeContext.displayName = "DiagramApiSafeContext";
 const DiagramActorContextProvider = DiagramActorSafeContext.Provider;
+const DiagramApiContextProvider = DiagramApiSafeContext.Provider;
 function useDiagramActorRef() {
   const ctx = useContext(DiagramActorSafeContext);
   if (ctx === null) {
     throw new Error("DiagramActorRef is not provided");
   }
-  return ctx.actor;
+  return ctx;
 }
 function useDiagram() {
-  const ctx = useContext(DiagramActorSafeContext);
+  const ctx = useContext(DiagramApiSafeContext);
   if (ctx === null) {
-    throw new Error("DiagramActorRef is not provided");
+    throw new Error("DiagramApi is not provided");
   }
   return ctx;
 }
 
-export { DiagramActorContextProvider, useDiagram, useDiagramActorRef };
+export { DiagramActorContextProvider, DiagramApiContextProvider, useDiagram, useDiagramActorRef };