@likec4/diagram 1.47.0 → 1.48.0

package/dist/editor/editorActor.d.ts

@@ -1,653 +0,0 @@
-import { ActorRef, NonReducibleUnknown, SnapshotFrom, SetupReturn, PromiseActorLogic, EventObject, MetaObject, StateMachine, ActorRefFromLogic, Values, ConditionalRequired, InputFrom, RequiredActorOptions, IsNotNever, GetConcreteByKey, AnyActorLogic, RequiredLogicInput, MachineSnapshot, AnyActorRef, StateValue, AnyEventObject, CancelAction, ActionFunction, LogAction, DoneActorEvent, ErrorActorEvent, ActionArgs, StopAction } from 'xstate';
-import { Types } from '../likec4diagram/types';
-import { HotKeyEvent, HotkeyActorLogic } from './hotkeyActor';
-import type * as t from '@likec4/core/types';
-export declare namespace EditorCalls {
-    type ApplyLatestToManual = (params: {
-        input: ApplyLatestToManual.Input;
-    }) => Promise<ApplyLatestToManual.Output>;
-    namespace ApplyLatestToManual {
-        type Input = {
-            viewId: t.ViewId;
-            current: t.LayoutedView | undefined;
-        };
-        type Output = {
-            updated: t.LayoutedView;
-        };
-    }
-    type ExecuteChange = (params: {
-        input: ExecuteChange.Input;
-    }) => Promise<ExecuteChange.Output>;
-    namespace ExecuteChange {
-        type Input = {
-            viewId: t.ViewId;
-            changes: t.ViewChange[];
-        };
-        type Output = NonReducibleUnknown;
-    }
-}
-export type EditorActorEvent = {
-    type: 'sync';
-} | {
-    type: 'change';
-    change: t.ViewChange;
-} | {
-    type: 'edit.start';
-    subject: 'node' | 'edge';
-} | {
-    type: 'edit.finish';
-    wasChanged?: boolean;
-} | {
-    type: 'applyLatestToManual';
-} | {
-    type: 'synced';
-} | {
-    type: 'cancel';
-} | {
-    type: 'reset';
-} | HotKeyEvent;
-type HistorySnapshot = {
-    view: t.LayoutedView;
-    change: t.ViewChange.SaveViewSnapshot;
-    xynodes: Types.Node[];
-    xyedges: Types.Edge[];
-    synched: boolean;
-};
-export interface EditorActorInput {
-    viewId: t.ViewId;
-}
-export interface EditorActorContext {
-    viewId: t.ViewId;
-    pendingChanges: t.ViewChange[];
-    history: ReadonlyArray<HistorySnapshot>;
-    /**
-     * The state before editing started
-     */
-    beforeEditing: HistorySnapshot | null;
-    /**
-     * The subject of the edit
-     */
-    editing: 'node' | 'edge' | null;
-}
-export type EditorActorEmitedEvent = {
-    type: 'idle';
-};
-export declare const machine: SetupReturn<EditorActorContext, EditorActorEvent, {
-    applyLatest: PromiseActorLogic<EditorCalls.ApplyLatestToManual.Output, EditorCalls.ApplyLatestToManual.Input, EventObject>;
-    executeChange: PromiseActorLogic<NonReducibleUnknown, EditorCalls.ExecuteChange.Input, EventObject>;
-    hotkey: HotkeyActorLogic;
-}, {
-    hotkey: "hotkey";
-}, {}, {
-    'has pending': unknown;
-    'can undo': unknown;
-}, "350ms" | "waitBeforeSync", "pending", EditorActorInput, NonReducibleUnknown, EditorActorEmitedEvent, MetaObject>;
-declare const _editorActorLogic: 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>];
-        };
-    };
-}>;
-type InferredMachine = typeof _editorActorLogic;
-export interface EditorActorLogic extends InferredMachine {
-}
-export declare const editorActorLogic: EditorActorLogic;
-export type EditorActorSnapshot = SnapshotFrom<EditorActorLogic>;
-export interface EditorActorRef extends ActorRef<EditorActorSnapshot, EditorActorEvent, EditorActorEmitedEvent> {
-}
-export {};

package/dist/likec4diagram/relationship-popover/styles.css.d.ts

@@ -1,2 +0,0 @@
-export declare const endpoint: string;
-export declare const title: string;

package/dist/likec4diagram/relationship-popover/styles.css.js

@@ -1,28 +0,0 @@
-import { css } from '@likec4/styles/css';
-
-const endpoint = css({
-  display: "block",
-  fontSize: "xxs",
-  fontWeight: 500,
-  whiteSpace: "nowrap",
-  paddingX: "1",
-  paddingY: "0.5",
-  borderRadius: "[2px]",
-  background: {
-    _light: "var(--likec4-palette-fill)/90",
-    _dark: "var(--likec4-palette-fill)/60"
-  },
-  lineHeight: "1",
-  color: {
-    _light: "var(--likec4-palette-hiContrast)",
-    _dark: "var(--likec4-palette-loContrast)"
-  }
-});
-const title = css({
-  whiteSpaceCollapse: "preserve-breaks",
-  fontSize: "sm",
-  lineHeight: "sm",
-  userSelect: "all"
-});
-
-export { endpoint, title };

package/dist/overlays/relationships-browser/custom/styles.css.d.ts

@@ -1 +0,0 @@
-export declare const emptyNode: string;