@likec4/diagram 1.44.0 → 1.46.0

package/dist/base-primitives/edge/edge.css.d.ts

@@ -1,4 +0,0 @@
-export declare const edgeContainer: string;
-export declare const edgePathBg: string;
-export declare const markerContext: string;
-export declare const cssEdgePath: string;

package/dist/base-primitives/edge/edge.css.js

@@ -1,71 +0,0 @@
-import { css } from '@likec4/styles/css';
-
-const isSelected = ".react-flow__edge.selected";
-const edgeContainer = css({
-  _reduceGraphics: {
-    transition: "none"
-  }
-});
-const edgePathBg = css({
-  pointerEvents: "none",
-  fill: "none",
-  strokeWidth: "calc(var(--xy-edge-stroke-width) + 2)",
-  strokeOpacity: 0.08,
-  _noReduceGraphics: {
-    transitionProperty: "stroke-width, stroke-opacity",
-    transitionDuration: "fast",
-    transitionTimingFunction: "inOut"
-  },
-  _whenHovered: {
-    transitionTimingFunction: "out",
-    strokeWidth: "calc(var(--xy-edge-stroke-width) + 4)",
-    strokeOpacity: 0.2
-  },
-  _whenSelected: {
-    strokeWidth: "calc(var(--xy-edge-stroke-width) + 6)",
-    strokeOpacity: 0.25,
-    _whenHovered: {
-      strokeOpacity: 0.4
-    }
-  }
-});
-const markerContext = css({
-  fill: "[var(--xy-edge-stroke)]",
-  stroke: "[var(--xy-edge-stroke)]"
-});
-const cssEdgePath = css({
-  fill: "none",
-  strokeDashoffset: 0,
-  _noReduceGraphics: {
-    animationStyle: "xyedgeAnimated",
-    animationPlayState: "paused",
-    transition: "stroke 130ms ease-out,stroke-width 130ms ease-out"
-  },
-  [`:where([data-edge-dir='back']) &`]: {
-    animationDirection: "reverse"
-  },
-  _whenHovered: {
-    _noReduceGraphics: {
-      animationPlayState: "running",
-      animationDelay: "450ms"
-    }
-  },
-  [`:where(${isSelected}, [data-edge-active='true'], [data-edge-animated='true']) &`]: {
-    _noReduceGraphics: {
-      animationPlayState: "running",
-      animationDelay: "0ms"
-    }
-  },
-  _whenDimmed: {
-    animationPlayState: "paused"
-  },
-  _smallZoom: {
-    animationName: "none"
-  },
-  _whenPanning: {
-    strokeDasharray: "none !important",
-    animationPlayState: "paused"
-  }
-});
-
-export { cssEdgePath, edgeContainer, edgePathBg, markerContext };

package/dist/editor/LikeC4EditorContext.d.ts

@@ -1,21 +0,0 @@
-import { PropsWithChildren } from 'react';
-import { OnChange } from '../LikeC4Diagram.props';
-import type * as t from '@likec4/core/types';
-export type LikeC4EditorContextType = {
-    /**
-     * Fetch a view by its ID and layout type.
-     *
-     * @param viewId - The ID of the view to fetch.
-     * @param layout - The layout type to use when fetching the view.
-     */
-    fetchView(viewId: t.ViewId, layout?: t.LayoutType): Promise<t.LayoutedView>;
-    syncManualLayout(viewId: t.ViewId): Promise<void>;
-    /**
-     * Callback invoked when the view changes.
-     */
-    onChange: OnChange;
-};
-export declare function LikeC4EditorContext({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element;
-export declare function EnsureEditorContext({ children }: PropsWithChildren): import("react/jsx-runtime").JSX.Element | null;
-export declare function useOptionalLikeC4Editor(): LikeC4EditorContextType | null;
-export declare function useLikeC4Editor(): LikeC4EditorContextType;

package/dist/likec4diagram/custom/nodes/ElementNodeDrifts.d.ts

@@ -1,4 +0,0 @@
-import { Types } from '../../types';
-type ElementNodeDrifts = Types.NodeProps<'element' | 'deployment'>;
-export declare function ElementNodeDrifts({ data }: ElementNodeDrifts): import("react/jsx-runtime").JSX.Element | null;
-export {};

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

@@ -1,280 +0,0 @@
-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 = {
-    viewId: ViewId;
-};
-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 & {
-    history: ReadonlyArray<HistorySnapshot>;
-    beforeEditing: HistorySnapshot | null;
-    editing: "node" | "edge" | null;
-}>, Events, {
-    undoHotKey?: ActorRefFromLogic< UndoHotKeyActorLogic>;
-}, {
-    src: "undoHotKeyActorLogic";
-    logic: UndoHotKeyActorLogic;
-    id: "undoHotKey";
-}, never, {
-    type: "can undo";
-    params: unknown;
-}, "timeout", "stopped" | "editing" | "pending" | "idle" | "paused", "pending" | "ready", Input, NonReducibleUnknown, EventObject, MetaObject, {
-    readonly initial: "idle";
-    readonly context: ({ input }: {
-        spawn: {
-            <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;
-                input?: InputFrom<TLogic>;
-                syncSnapshot?: boolean;
-            } & { [K in RequiredLogicInput<TLogic>]: unknown; }], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
-        };
-        input: Input;
-        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>;
-    }) => {
-        history: never[];
-        beforeEditing: null;
-        editing: null;
-        viewId: ViewId;
-    };
-    readonly states: {
-        readonly idle: {
-            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 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: {
-            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>;
-                };
-                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;
-                };
-            };
-            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 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: 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 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";
-        };
-    };
-}>;
-/**
- * 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 {};

package/dist/likec4diagram/state/syncManualLayoutActor.js

@@ -1,248 +0,0 @@
-import { deepEqual } from 'fast-equals';
-import { last, map } from 'remeda';
-import { setup, assign, assertEvent } from 'xstate';
-import { createViewChange } from './createViewChange.js';
-import { undoHotKeyActorLogic } from './hotkeyActor.js';
-
-const diagramActorRef = function(system) {
-  return system.get("diagram");
-};
-const syncManualLayout = setup({
-  types: {
-    context: {},
-    input: {},
-    events: {},
-    tags: "",
-    children: {}
-  },
-  delays: {
-    "timeout": 2e3
-  },
-  guards: {
-    "can undo": ({ context }) => context.history.length > 0
-  },
-  actors: {
-    undoHotKeyActorLogic
-  }
-});
-const pushHistory = syncManualLayout.assign(({ context }) => {
-  const snapshot = context.beforeEditing;
-  if (!snapshot) {
-    return {};
-  }
-  const prevHistoryItem = last(context.history);
-  if (deepEqual(prevHistoryItem?.xyedges, snapshot.xyedges) && deepEqual(prevHistoryItem?.xynodes, snapshot.xynodes)) {
-    return {
-      beforeEditing: null
-    };
-  }
-  return {
-    beforeEditing: null,
-    history: [
-      ...context.history,
-      snapshot
-    ]
-  };
-});
-const popHistory = syncManualLayout.assign(({ context }) => {
-  if (context.history.length === 0) {
-    return {};
-  }
-  return {
-    history: context.history.slice(0, -1)
-  };
-});
-const startEditing = syncManualLayout.assign(({ system, event }) => {
-  assertEvent(event, "editing.start");
-  const parentContext = diagramActorRef(system).getSnapshot().context;
-  return {
-    editing: event.subject,
-    beforeEditing: {
-      xynodes: map(parentContext.xynodes, (n) => ({ ...n })),
-      xyedges: map(parentContext.xyedges, (e) => ({ ...e })),
-      change: createViewChange(parentContext),
-      view: parentContext.view,
-      synched: false
-    }
-  };
-});
-const ensureHotKey = syncManualLayout.enqueueActions(({ check, enqueue, self }) => {
-  const hasUndo = check("can undo");
-  const undoHotKey = self.getSnapshot().children["undoHotKey"];
-  if (undoHotKey && !hasUndo) {
-    enqueue.stopChild(undoHotKey);
-    return;
-  }
-  if (!undoHotKey && hasUndo) {
-    enqueue.spawnChild("undoHotKeyActorLogic", {
-      id: "undoHotKey"
-    });
-  }
-});
-const stopEditing = syncManualLayout.enqueueActions(({ event, enqueue }) => {
-  assertEvent(event, "editing.stop");
-  if (event.wasChanged) {
-    enqueue.cancel("sync");
-    enqueue(pushHistory);
-    enqueue.raise({ type: "sync" }, { id: "sync", delay: 50 });
-  }
-  enqueue.assign({
-    beforeEditing: null,
-    editing: null
-  });
-});
-const emitOnChange = syncManualLayout.sendTo(
-  ({ system }) => diagramActorRef(system),
-  ({ system }) => {
-    const parentContext = diagramActorRef(system).getSnapshot().context;
-    return {
-      type: "emit.onChange",
-      change: createViewChange(parentContext)
-    };
-  }
-);
-const markHistoryAsSynched = syncManualLayout.assign(({ context, event }) => {
-  assertEvent(event, "synced");
-  return {
-    history: context.history.map((i) => ({
-      ...i,
-      synched: true
-    })),
-    beforeEditing: context.beforeEditing ? {
-      ...context.beforeEditing,
-      synched: true
-    } : null
-  };
-});
-const undo = syncManualLayout.enqueueActions(({ context, enqueue, system }) => {
-  const lastHistoryItem = last(context.history);
-  if (!lastHistoryItem) {
-    return;
-  }
-  enqueue(popHistory);
-  enqueue(ensureHotKey);
-  const diagramActor = diagramActorRef(system);
-  enqueue.sendTo(diagramActor, {
-    type: "update.view",
-    view: lastHistoryItem.view,
-    xyedges: lastHistoryItem.xyedges,
-    xynodes: lastHistoryItem.xynodes
-  });
-  if (lastHistoryItem.synched) {
-    enqueue.sendTo(diagramActor, {
-      type: "emit.onChange",
-      change: lastHistoryItem.change
-    });
-  }
-});
-const idle = syncManualLayout.createStateConfig({
-  tags: "ready",
-  entry: [
-    assign({
-      beforeEditing: null,
-      editing: null
-    })
-  ],
-  on: {
-    sync: {
-      target: "pending"
-    },
-    "editing.start": {
-      actions: startEditing,
-      target: "editing"
-    },
-    undo: {
-      guard: "can undo",
-      actions: undo
-    }
-  }
-});
-const editing = syncManualLayout.createStateConfig({
-  on: {
-    "editing.stop": {
-      actions: [
-        stopEditing,
-        ensureHotKey
-      ],
-      target: "idle"
-    },
-    undo: {}
-  }
-});
-const pending = syncManualLayout.createStateConfig({
-  tags: "pending",
-  on: {
-    sync: {
-      target: "pending",
-      reenter: true
-    },
-    "editing.start": {
-      target: "paused",
-      actions: startEditing
-    },
-    undo: {
-      guard: "can undo",
-      actions: undo,
-      target: "idle"
-    }
-  },
-  after: {
-    "timeout": {
-      target: "idle",
-      actions: emitOnChange
-    }
-  }
-});
-const paused = syncManualLayout.createStateConfig({
-  tags: "pending",
-  on: {
-    "editing.stop": {
-      actions: [
-        stopEditing,
-        ensureHotKey
-      ],
-      target: "pending"
-    },
-    undo: {}
-  }
-});
-const _syncManualLayoutActorLogic = syncManualLayout.createMachine({
-  initial: "idle",
-  context: ({ input }) => ({
-    ...input,
-    history: [],
-    beforeEditing: null,
-    editing: null
-  }),
-  states: {
-    idle,
-    editing,
-    pending,
-    paused,
-    stopped: {
-      entry: [
-        assign({
-          beforeEditing: null,
-          history: []
-        }),
-        ensureHotKey
-      ],
-      type: "final"
-    }
-  },
-  on: {
-    cancel: {
-      target: ".idle"
-    },
-    synced: {
-      actions: markHistoryAsSynched,
-      target: ".idle"
-    },
-    stop: {
-      target: ".stopped"
-    }
-  }
-});
-const syncManualLayoutActorLogic = _syncManualLayoutActorLogic;
-
-export { syncManualLayoutActorLogic };