@likec4/diagram 1.42.1 → 1.44.0

package/dist/likec4diagram/state/syncManualLayoutActor.d.ts

@@ -1,37 +1,76 @@
-import { ViewChange, ViewId } from '@likec4/core/types';
-import { ActorLogicFrom, ActorRef, MachineSnapshot, StateMachine, NonReducibleUnknown, EventObject, MetaObject, ActorRefFromLogic, AnyActorLogic, ConditionalRequired, InputFrom, RequiredLogicInput, IsNotNever, AnyActorRef, StateValue, AnyEventObject, ActionFunction } from 'xstate';
-import { Context as DiagramContext, Events as DiagramEvents } from './diagram-machine';
+import { LayoutedView, ViewChange, ViewId } from '@likec4/core/types';
+import { ActorLogicFrom, ActorRef, ActorRefFromLogic, MachineSnapshot, SnapshotFrom, StateMachine, NonReducibleUnknown, EventObject, MetaObject, ConditionalRequired, InputFrom, RequiredActorOptions, IsNotNever, GetConcreteByKey, AnyActorLogic, RequiredLogicInput, AnyActorRef, StateValue, AnyEventObject, ActionFunction } from 'xstate';
+import { Types } from '../types';
+import { UndoHotKeyActorLogic } from './hotkeyActor';
 export type Input = {
-    /**
-     * Actually this is DiagramActorRef
-     * But we can't use it here due to circular type inference
-     */
-    parent: ActorRef<MachineSnapshot<DiagramContext, DiagramEvents, any, any, any, any, any, any>, DiagramEvents, any>;
     viewId: ViewId;
 };
-export type Context = Readonly<Input & {}>;
+type HistorySnapshot = {
+    view: LayoutedView;
+    change: ViewChange.SaveViewSnapshot;
+    xynodes: Types.Node[];
+    xyedges: Types.Edge[];
+    synched: boolean;
+};
+export type Context = Readonly<Input & {
+    history: ReadonlyArray<HistorySnapshot>;
+    beforeEditing: HistorySnapshot | null;
+    editing: 'node' | 'edge' | null;
+}>;
 export type Events = {
     type: 'sync';
 } | {
     type: 'synced';
+} | {
+    type: 'editing.start';
+    subject: 'node' | 'edge';
+} | {
+    type: 'editing.stop';
+    wasChanged?: boolean;
 } | {
     type: 'cancel';
+} | {
+    type: 'undo';
 } | {
     type: 'stop';
 };
-declare const _syncManualLayoutActorLogic: StateMachine<Readonly<Input>, Events, {}, never, {
-    type: "trigger:OnChange";
-    params: {
-        change: ViewChange;
-    };
+declare const _syncManualLayoutActorLogic: StateMachine<Readonly<Input & {
+    history: ReadonlyArray<HistorySnapshot>;
+    beforeEditing: HistorySnapshot | null;
+    editing: "node" | "edge" | null;
+}>, Events, {
+    undoHotKey?: ActorRefFromLogic< UndoHotKeyActorLogic>;
 }, {
-    type: "same view";
+    src: "undoHotKeyActorLogic";
+    logic: UndoHotKeyActorLogic;
+    id: "undoHotKey";
+}, never, {
+    type: "can undo";
     params: unknown;
-}, "timeout", "stopped" | "synced" | "pending" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
+}, "timeout", "stopped" | "editing" | "pending" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
     readonly initial: "idle";
     readonly context: ({ input }: {
         spawn: {
-            <TSrc extends never>(logic: TSrc, ...[options]: never): ActorRefFromLogic<never>;
+            <TSrc extends "undoHotKeyActorLogic">(logic: TSrc, ...[options]: {
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            } extends infer T ? T extends {
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            } ? 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): ActorRefFromLogic< GetConcreteByKey<{
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            }, "src", TSrc>["logic"]>;
             <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: {
                 id?: never;
                 systemId?: string;
@@ -40,84 +79,202 @@ declare const _syncManualLayoutActorLogic: StateMachine<Readonly<Input>, Events,
             } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
         };
         input: Input;
-        self: ActorRef<MachineSnapshot<Readonly<Input>, Events, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
+        self: ActorRef<MachineSnapshot<Readonly<Input & {
+            history: ReadonlyArray<HistorySnapshot>;
+            beforeEditing: HistorySnapshot | null;
+            editing: "node" | "edge" | null;
+        }>, Events, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, Events, AnyEventObject>;
     }) => {
-        /**
-         * Actually this is DiagramActorRef
-         * But we can't use it here due to circular type inference
-         */
-        parent: ActorRef<MachineSnapshot<DiagramContext, DiagramEvents, any, any, any, any, any, any>, DiagramEvents, any>;
+        history: never[];
+        beforeEditing: null;
+        editing: null;
         viewId: ViewId;
     };
     readonly states: {
         readonly idle: {
-            readonly tags: "ready";
-            readonly on: {
-                readonly sync: {
-                    readonly target: "pending";
+            tags: "ready";
+            entry: ActionFunction<Readonly<Input & {
+                history: ReadonlyArray<HistorySnapshot>;
+                beforeEditing: HistorySnapshot | null;
+                editing: "node" | "edge" | null;
+            }>, Events, Events, undefined, {
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            }, never, never, never, never>[];
+            on: {
+                sync: {
+                    target: string;
+                };
+                'editing.start': {
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, {
+                        src: "undoHotKeyActorLogic";
+                        logic: UndoHotKeyActorLogic;
+                        id: "undoHotKey";
+                    }, never, never, never, never>;
+                    target: string;
+                };
+                undo: {
+                    guard: "can undo";
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, {
+                        src: "undoHotKeyActorLogic";
+                        logic: UndoHotKeyActorLogic;
+                        id: "undoHotKey";
+                    }, never, {
+                        type: "can undo";
+                        params: unknown;
+                    }, "timeout", EventObject>;
                 };
             };
         };
-        readonly paused: {
-            readonly tags: "pending";
-            readonly on: {
-                readonly sync: {
-                    readonly target: "pending";
+        readonly editing: {
+            on: {
+                'editing.stop': {
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, {
+                        src: "undoHotKeyActorLogic";
+                        logic: UndoHotKeyActorLogic;
+                        id: "undoHotKey";
+                    }, never, {
+                        type: "can undo";
+                        params: unknown;
+                    }, "timeout", EventObject>[];
+                    target: string;
                 };
+                undo: {};
             };
         };
         readonly pending: {
-            readonly tags: "pending";
-            readonly on: {
-                readonly sync: {
-                    readonly target: "pending";
-                    readonly reenter: true;
+            tags: "pending";
+            on: {
+                sync: {
+                    target: string;
+                    reenter: true;
+                };
+                'editing.start': {
+                    target: string;
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, {
+                        src: "undoHotKeyActorLogic";
+                        logic: UndoHotKeyActorLogic;
+                        id: "undoHotKey";
+                    }, never, never, never, never>;
                 };
-                readonly cancel: {
-                    readonly target: "paused";
+                undo: {
+                    guard: "can undo";
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, {
+                        src: "undoHotKeyActorLogic";
+                        logic: UndoHotKeyActorLogic;
+                        id: "undoHotKey";
+                    }, never, {
+                        type: "can undo";
+                        params: unknown;
+                    }, "timeout", EventObject>;
+                    target: string;
                 };
             };
-            readonly after: {
-                readonly timeout: readonly [{
-                    readonly guard: "same view";
-                    readonly actions: {
-                        readonly type: "trigger:OnChange";
-                        readonly params: ({ context }: {
-                            context: Readonly<Input>;
-                            event: Events;
-                        }) => {
-                            change: ViewChange.SaveManualLayout;
-                        };
-                    };
-                    readonly target: "synced";
-                }, {
-                    readonly target: "stopped";
-                }];
+            after: {
+                timeout: {
+                    target: string;
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, never, never, never, "timeout", never>;
+                };
             };
         };
-        readonly synced: {
-            readonly tags: "ready";
-            readonly on: {
-                readonly sync: {
-                    readonly target: "pending";
+        readonly paused: {
+            tags: "pending";
+            on: {
+                'editing.stop': {
+                    actions: ActionFunction<Readonly<Input & {
+                        history: ReadonlyArray<HistorySnapshot>;
+                        beforeEditing: HistorySnapshot | null;
+                        editing: "node" | "edge" | null;
+                    }>, Events, Events, undefined, {
+                        src: "undoHotKeyActorLogic";
+                        logic: UndoHotKeyActorLogic;
+                        id: "undoHotKey";
+                    }, never, {
+                        type: "can undo";
+                        params: unknown;
+                    }, "timeout", EventObject>[];
+                    target: string;
                 };
+                undo: {};
             };
         };
         readonly stopped: {
-            readonly entry: ActionFunction<Readonly<Input>, Events, Events, undefined, never, never, never, never, never>;
+            readonly entry: readonly [ ActionFunction<Readonly<Input & {
+                history: ReadonlyArray<HistorySnapshot>;
+                beforeEditing: HistorySnapshot | null;
+                editing: "node" | "edge" | null;
+            }>, Events, Events, undefined, {
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            }, never, never, never, never>, ActionFunction<Readonly<Input & {
+                history: ReadonlyArray<HistorySnapshot>;
+                beforeEditing: HistorySnapshot | null;
+                editing: "node" | "edge" | null;
+            }>, Events, Events, undefined, {
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            }, never, {
+                type: "can undo";
+                params: unknown;
+            }, "timeout", EventObject>];
             readonly type: "final";
         };
     };
     readonly on: {
+        readonly cancel: {
+            readonly target: ".idle";
+        };
         readonly synced: {
-            readonly target: ".synced";
+            readonly actions: ActionFunction<Readonly<Input & {
+                history: ReadonlyArray<HistorySnapshot>;
+                beforeEditing: HistorySnapshot | null;
+                editing: "node" | "edge" | null;
+            }>, Events, Events, undefined, {
+                src: "undoHotKeyActorLogic";
+                logic: UndoHotKeyActorLogic;
+                id: "undoHotKey";
+            }, never, never, never, never>;
+            readonly target: ".idle";
         };
         readonly stop: {
             readonly target: ".stopped";
         };
     };
 }>;
-export interface SyncLayoutActorLogic extends ActorLogicFrom<typeof _syncManualLayoutActorLogic> {
+/**
+ * Here is a trick to reduce inference types
+ */
+type InferredMachine = ActorLogicFrom<typeof _syncManualLayoutActorLogic>;
+export interface SyncLayoutActorLogic extends InferredMachine {
 }
+export type SyncLayoutActorRef = ActorRefFromLogic<SyncLayoutActorLogic>;
+export type SyncLayoutActorSnapshot = SnapshotFrom<SyncLayoutActorLogic>;
 export declare const syncManualLayoutActorLogic: SyncLayoutActorLogic;
 export {};