@likec4/diagram 1.46.4 → 1.48.0

package/dist/editor/useEditorActorLogic.d.ts

@@ -1,565 +1,3 @@
-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 { EditorActorLogic } from './editorActor.states';
 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>];
-        };
-    };
-}>;
+export declare function useEditorActorLogic(viewId: t.ViewId): EditorActorLogic;

package/dist/editor/useEditorActorLogic.js

@@ -1,24 +1,20 @@
+import { useMemo } from 'react';
 import { fromPromise } from 'xstate';
 import { applyChangesToManualLayout } from './applyChangesToManualLayout.js';
-import { editorActorLogic } from './editorActor.js';
-import { useOptionalLikeC4EditorPort } from './LikeC4EditorProvider.js';
+import { editorActorLogic } from './editorActor.states.js';
+import { useOptionalLikeC4Editor } from './LikeC4EditorProvider.js';
 import { useCallbackRef } from '../hooks/useCallbackRef.js';
 
 function useEditorActorLogic(viewId) {
-  const port = useOptionalLikeC4EditorPort();
+  const port = useOptionalLikeC4Editor();
   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 manual = await Promise.resolve().then(() => current ?? port.fetchView(viewId2, "manual"));
+      const latest = await Promise.resolve().then(() => port.fetchView(viewId2, "auto"));
       const updated = applyChangesToManualLayout(manual, latest);
       return {
         updated
@@ -43,12 +39,12 @@ function useEditorActorLogic(viewId) {
       return {};
     }
   );
-  return editorActorLogic.provide({
+  return useMemo(() => editorActorLogic.provide({
     actors: {
       applyLatest: fromPromise(applyLatest),
       executeChange: fromPromise(executeChange)
     }
-  });
+  }), [applyLatest, executeChange]);
 }
 
 export { useEditorActorLogic };

package/dist/hooks/index.d.ts

@@ -4,7 +4,7 @@ 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';
+export { useCurrentZoom, useCurrentZoomAtLeast, useIsZoomTooSmall, useXYFlow, useXYInternalNode, useXYStore, useXYStoreApi, } from './useXYFlow';
 export type { XYFlowInstance, XYStoreApi, XYStoreState } from './useXYFlow';
 export { useCurrentView, useCurrentViewId } from './useCurrentView';
 export { useCurrentViewModel } from './useCurrentViewModel';

package/dist/hooks/useCallbackRef.d.ts

@@ -1 +1,7 @@
+/**
+ * Memoizes a callback function so that it will not be recreated on every render.
+ * The returned function is guaranteed to be the same reference across renders.
+ * @param callback the callback function to memoize
+ * @returns the memoized callback function
+ */
 export declare function useCallbackRef<T extends (...args: any[]) => any>(callback: T | null | undefined): T;

package/dist/hooks/useCurrentViewModel.d.ts

@@ -1,4 +1,14 @@
 import { CurrentViewModel } from '../context/LikeC4ModelContext';
 export type { CurrentViewModel };
+/**
+ * Returns the current view model from the context, or null if no view model is found.
+ * @see useCurrentViewModel
+ */
 export declare function useOptionalCurrentViewModel(): CurrentViewModel | null;
+/**
+ * Hook to get the current view model from the context.
+ * Throws an error if no view model is found in the context.
+ *
+ * @see useOptionalCurrentViewModel
+ */
 export declare function useCurrentViewModel(): CurrentViewModel;

package/dist/hooks/useDiagram.js

@@ -9,10 +9,10 @@ function useDiagramActorSnapshot(selector, compare = shallowEqual) {
   const actorRef = useDiagramActorRef();
   return useSelector(actorRef, selector, compare);
 }
-function useDiagramContext(selector, compare = shallowEqual, deps) {
+function useDiagramContext(selector, compare = shallowEqual, deps = []) {
   const actorRef = useDiagramActorRef();
   const selectorRef = useCallbackRef(selector);
-  const select = useCallback((s) => selectorRef(s.context), deps ?? []);
+  const select = useCallback((s) => selectorRef(s.context), deps);
   return useSelector(actorRef, select, compare);
 }
 function useOnDiagramEvent(event, callback, options) {

package/dist/hooks/useDiagramCompareLayout.d.ts

@@ -5,7 +5,7 @@ declare const selectCompareLayoutState: ({ context }: DiagramActorSnapshot) => {
     isEnabled: false;
     isEditable: false;
     isActive: false;
-    drifts: never[];
+    drifts: never;
     canApplyLatest: boolean;
     layout: t.LayoutType;
 } | {