@likec4/diagram 1.47.0 → 1.49.0

package/dist/editor/useEditorActorLogic.d.ts

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

package/dist/editor/useEditorActorLogic.js

@@ -1,24 +1,23 @@
+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 promisify = (fn) => {
+  return Promise.resolve().then(() => fn());
+};
+function useEditorActorLogic() {
+  const port = useOptionalLikeC4Editor();
   const applyLatest = useCallbackRef(
-    async ({ input: { viewId: viewId2, current } }) => {
+    async ({ input: { viewId, 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 promisify(() => current ?? port.fetchView(viewId, "manual"));
+      const latest = await promisify(() => port.fetchView(viewId, "auto"));
       const updated = applyChangesToManualLayout(manual, latest);
       return {
         updated
@@ -32,23 +31,17 @@ function useEditorActorLogic(viewId) {
         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);
-        });
+        await promisify(() => port.handleChange(input.viewId, change));
       }
       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,11 +4,11 @@ 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';
-export { useLikeC4Model, useLikeC4Specification, useLikeC4ViewModel } from './useLikeC4Model';
-export { useHasProjects, useLikeC4Project, useLikeC4ProjectId, useLikeC4Projects, useLikeC4ProjectsContext, } from './useLikeC4Project';
+export { useLikeC4Model, useLikeC4Specification, useLikeC4ViewModel, useOptionalLikeC4Model, } from './useLikeC4Model';
+export { useChangeLikeC4Project, useHasProjects, useLikeC4Project, useLikeC4ProjectId, useLikeC4Projects, useLikeC4ProjectsContext, } from './useLikeC4Project';
 export { useLikeC4Styles } from './useLikeC4Styles';
 export * from './useDiagram';

package/dist/hooks/safeContext.d.ts

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

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;