@likec4/diagram 1.45.0 → 1.46.2

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/state/syncManualLayoutActor.d.ts

@@ -1,46 +0,0 @@
-import { LayoutedView, ViewChange, ViewId } from '@likec4/core/types';
-import { ActorRef, MachineSnapshot, StateMachine } from 'xstate';
-import { Types } from '../types';
-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';
-};
-type Tags = 'pending' | 'ready';
-/**
- * Here is a trick to reduce inference types
- */
-export interface SyncLayoutActorLogic extends StateMachine<Context, Events, {}, any, any, any, any, any, Tags, Input, any, any, any, any> {
-}
-export type SyncLayoutActorSnapshot = MachineSnapshot<Context, Events, {}, never, Tags, never, {}, {}>;
-export interface SyncLayoutActorRef extends ActorRef<SyncLayoutActorSnapshot, Events> {
-}
-export declare const syncManualLayoutActorLogic: SyncLayoutActorLogic;
-export {};

package/dist/likec4diagram/state/syncManualLayoutActor.js

@@ -1,309 +0,0 @@
-import { getHotkeyHandler } from '@mantine/hooks';
-import { last, omit } from 'remeda';
-import { setup, assign, stopChild, fromCallback, assertEvent } from 'xstate';
-import { createViewChange } from './createViewChange.js';
-
-const undoHotKeyActorLogic = fromCallback(({ sendBack }) => {
-  const ctrlZHandler = getHotkeyHandler([
-    ["mod + z", (event) => {
-      event.stopPropagation();
-      sendBack({ type: "undo" });
-    }, {
-      preventDefault: true
-    }]
-  ]);
-  document.body.addEventListener("keydown", ctrlZHandler, { capture: true });
-  return () => {
-    document.body.removeEventListener("keydown", ctrlZHandler, { capture: true });
-  };
-});
-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 raiseSync = syncManualLayout.raise({ type: "sync" }, { delay: 300, id: "sync" });
-const cancelSync = syncManualLayout.cancel("sync");
-const startEditing = syncManualLayout.enqueueActions(({ check, enqueue, system, event, self, context }) => {
-  assertEvent(event, "editing.start");
-  const parentContext = diagramActorRef(system).getSnapshot().context;
-  enqueue.assign({
-    editing: event.subject,
-    beforeEditing: {
-      xynodes: parentContext.xynodes.map(
-        ({ measured, style, ...n }) => ({
-          ...omit(n, ["selected", "dragging", "resizing"]),
-          data: omit(n.data, ["dimmed", "hovered"]),
-          initialWidth: measured?.width ?? n.width ?? n.initialWidth,
-          initialHeight: measured?.height ?? n.height ?? n.initialHeight
-        })
-      ),
-      xyedges: parentContext.xyedges.map(
-        (e) => ({
-          ...omit(e, ["selected"]),
-          data: omit(e.data, ["active", "dimmed", "hovered"])
-        })
-      ),
-      change: createViewChange(parentContext),
-      view: parentContext.view,
-      synched: false
-    }
-  });
-});
-const ensureHotKey = syncManualLayout.enqueueActions(({ check, context, enqueue, self }) => {
-  const hasUndo = context.history.length > 0;
-  const undoHotKey = self.getSnapshot().children["undoHotKey"];
-  if (undoHotKey && !hasUndo) {
-    enqueue.stopChild(undoHotKey);
-    return;
-  }
-  if (!undoHotKey && hasUndo) {
-    enqueue.spawnChild("undoHotKeyActorLogic", {
-      id: "undoHotKey"
-    });
-  }
-});
-const pushHistory = syncManualLayout.assign(({ context }) => {
-  const snapshot = context.beforeEditing;
-  if (!snapshot) {
-    return {
-      editing: null
-    };
-  }
-  return {
-    beforeEditing: null,
-    editing: null,
-    history: [
-      ...context.history,
-      snapshot
-    ]
-  };
-});
-const stopEditing = syncManualLayout.enqueueActions(({ event, enqueue }) => {
-  assertEvent(event, ["editing.stop", "cancel", "undo"]);
-  if (event.type === "editing.stop" && event.wasChanged) {
-    enqueue(pushHistory);
-    enqueue(ensureHotKey);
-    enqueue(raiseSync);
-    return;
-  }
-  enqueue.assign({
-    beforeEditing: null,
-    editing: null
-  });
-});
-const markHistoryAsSynched = syncManualLayout.assign(({ context, event }) => {
-  assertEvent(event, "synced");
-  return {
-    history: context.history.map((i) => ({
-      ...i,
-      synched: true
-    }))
-  };
-});
-const popHistory = syncManualLayout.assign(({ context }) => {
-  if (context.history.length === 0 || context.history.length === 1) {
-    return {
-      history: []
-    };
-  }
-  return {
-    history: context.history.slice(0, context.history.length - 1)
-  };
-});
-const undo = syncManualLayout.enqueueActions(({ context, enqueue, system }) => {
-  enqueue(cancelSync);
-  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,
-    source: "internal"
-  });
-  if (lastHistoryItem.synched) {
-    enqueue.sendTo(
-      diagramActor,
-      {
-        type: "emit.onChange",
-        change: lastHistoryItem.change
-      }
-    );
-  } else {
-    enqueue(raiseSync);
-  }
-});
-const emitOnChange = syncManualLayout.enqueueActions(({ context, enqueue, system }) => {
-  enqueue(cancelSync);
-  const diagramActor = diagramActorRef(system);
-  const parentContext = diagramActor.getSnapshot().context;
-  const change = createViewChange(parentContext);
-  enqueue.sendTo(diagramActor, {
-    type: "update.view-bounds",
-    bounds: change.layout.bounds
-  });
-  enqueue.sendTo(diagramActor, {
-    type: "emit.onChange",
-    change
-  });
-});
-const idle = syncManualLayout.createStateConfig({
-  tags: "ready",
-  on: {
-    sync: {
-      target: "pending"
-    },
-    "editing.start": {
-      actions: startEditing,
-      target: "editing"
-    }
-  }
-});
-const editing = syncManualLayout.createStateConfig({
-  entry: [
-    cancelSync
-  ],
-  on: {
-    cancel: {
-      actions: stopEditing,
-      target: "idle"
-    },
-    "editing.stop": {
-      actions: stopEditing,
-      target: "idle"
-    },
-    undo: {
-      actions: stopEditing,
-      target: "idle"
-    },
-    synced: {
-      actions: [
-        markHistoryAsSynched
-      ]
-    }
-  }
-});
-const pending = syncManualLayout.createStateConfig({
-  tags: "pending",
-  on: {
-    cancel: {
-      actions: cancelSync,
-      target: "idle"
-    },
-    sync: {
-      target: "pending",
-      reenter: true
-    },
-    "editing.start": {
-      target: "paused",
-      actions: startEditing
-    }
-  },
-  after: {
-    "timeout": {
-      target: "idle",
-      actions: emitOnChange
-    }
-  }
-});
-const paused = syncManualLayout.createStateConfig({
-  tags: "pending",
-  entry: [
-    cancelSync
-  ],
-  on: {
-    cancel: {
-      actions: stopEditing,
-      target: "idle"
-    },
-    "editing.stop": {
-      actions: stopEditing,
-      target: "pending"
-    },
-    undo: {
-      actions: stopEditing,
-      target: "idle"
-    },
-    // When external sync is done while editing, we just mark history as synced
-    // but go to editing state (that does not return to pending)
-    synced: {
-      actions: [
-        markHistoryAsSynched
-      ],
-      target: "editing"
-    }
-  }
-});
-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: []
-        }),
-        stopChild("undoHotKey")
-      ],
-      type: "final"
-    }
-  },
-  on: {
-    cancel: {
-      actions: [
-        cancelSync
-      ],
-      target: ".idle"
-    },
-    synced: {
-      actions: [
-        markHistoryAsSynched,
-        cancelSync
-      ],
-      target: ".idle"
-    },
-    undo: {
-      guard: "can undo",
-      actions: undo,
-      target: ".idle"
-    },
-    stop: {
-      target: ".stopped"
-    }
-  }
-});
-const syncManualLayoutActorLogic = _syncManualLayoutActorLogic;
-
-export { syncManualLayoutActorLogic };

package/dist/utils/vector.d.ts

@@ -1,86 +0,0 @@
-export interface VectorValue {
-    readonly x: number;
-    readonly y: number;
-}
-export declare class Vector implements VectorValue {
-    readonly x: number;
-    readonly y: number;
-    constructor(x: number, y: number);
-    static create(position: VectorValue): Vector;
-    static create(x: number, y: number): Vector;
-    /**
-     * Adds two vectors.
-     * @param a The first vector.
-     * @param b The second vector.
-     * @returns The sum of the two vectors.
-     */
-    static add(a: VectorValue, b: VectorValue): VectorValue;
-    /**
-     * Subtracts two vectors.
-     * @param a The first vector.
-     * @param b The second vector.
-     * @returns The difference of the two vectors.
-     */
-    static subtract(a: VectorValue, b: VectorValue): VectorValue;
-    /**
-     * Multiplies a vector by a scalar.
-     * @param a The vector.
-     * @param b The scalar.
-     * @returns The scaled vector.
-     */
-    static multiply(a: VectorValue, b: number): VectorValue;
-    /**
-     * Calculates the dot product of the vectors.
-     * @param a The first vector.
-     * @param b The second vector.
-     * @returns The dot product.
-     */
-    static dot(a: VectorValue, b: VectorValue): number;
-    /**
-     * Adds the given vector to this vector.
-     * @param b The vector to add.
-     * @returns A new vector that is the sum of this vector and the given vector.
-     */
-    add(b: VectorValue): Vector;
-    /**
-     * Subtracts the given vector from this vector.
-     * @param b The vector to subtract.
-     * @returns A new vector that is the difference of this vector and the given vector.
-     */
-    subtract(b: VectorValue): Vector;
-    /**
-     * Multiplies this vector by a scalar.
-     * @param b The scalar to multiply by.
-     * @returns A new vector that is the product of this vector and the given scalar.
-     */
-    multiply(b: number): Vector;
-    /**
-     * Calculates the dot product of this vector and another vector.
-     * @param b The other vector.
-     * @returns The dot product.
-     */
-    dot(b: VectorValue): number;
-    /**
-     * Calculates the cross product of this vector and another vector.
-     * @param b The other vector.
-     * @returns The cross product as a new vector.
-     */
-    cross(b: VectorValue): Vector;
-    /**
-     * Calculates the length (magnitude) of this vector.
-     * @returns The length of the vector.
-     */
-    length(): number;
-    /**
-     * Normalizes the vector (makes it unit length, i.e., has a length of 1).
-     * @returns A new vector that is the normalized version of this vector.
-     */
-    normalize(): Vector;
-    /**
-     * Rounds the components of the vector to the nearest integers.
-     * @returns A new vector with rounded components.
-     */
-    round(): Vector;
-}
-export declare function vector(source: VectorValue | Vector): Vector;
-export declare function vector(x: number, y: number): Vector;

package/dist/utils/vector.js

@@ -1,127 +0,0 @@
-class Vector {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-  }
-  static create(...args) {
-    if (args.length === 2) {
-      return new Vector(args[0], args[1]);
-    }
-    return new Vector(args[0].x, args[0].y);
-  }
-  /**
-   * Adds two vectors.
-   * @param a The first vector.
-   * @param b The second vector.
-   * @returns The sum of the two vectors.
-   */
-  static add(a, b) {
-    return { x: a.x + b.x, y: a.y + b.y };
-  }
-  /**
-   * Subtracts two vectors.
-   * @param a The first vector.
-   * @param b The second vector.
-   * @returns The difference of the two vectors.
-   */
-  static subtract(a, b) {
-    return { x: a.x - b.x, y: a.y - b.y };
-  }
-  /**
-   * Multiplies a vector by a scalar.
-   * @param a The vector.
-   * @param b The scalar.
-   * @returns The scaled vector.
-   */
-  static multiply(a, b) {
-    return { x: a.x * b, y: a.y * b };
-  }
-  /**
-   * Calculates the dot product of the vectors.
-   * @param a The first vector.
-   * @param b The second vector.
-   * @returns The dot product.
-   */
-  static dot(a, b) {
-    return a.x * b.x + a.y * b.y;
-  }
-  /**
-   * Adds the given vector to this vector.
-   * @param b The vector to add.
-   * @returns A new vector that is the sum of this vector and the given vector.
-   */
-  add(b) {
-    return new Vector(this.x + b.x, this.y + b.y);
-  }
-  /**
-   * Subtracts the given vector from this vector.
-   * @param b The vector to subtract.
-   * @returns A new vector that is the difference of this vector and the given vector.
-   */
-  subtract(b) {
-    return new Vector(this.x - b.x, this.y - b.y);
-  }
-  /**
-   * Multiplies this vector by a scalar.
-   * @param b The scalar to multiply by.
-   * @returns A new vector that is the product of this vector and the given scalar.
-   */
-  multiply(b) {
-    return new Vector(this.x * b, this.y * b);
-  }
-  /**
-   * Calculates the dot product of this vector and another vector.
-   * @param b The other vector.
-   * @returns The dot product.
-   */
-  dot(b) {
-    return this.x * b.x + this.y * b.y;
-  }
-  /**
-   * Calculates the cross product of this vector and another vector.
-   * @param b The other vector.
-   * @returns The cross product as a new vector.
-   */
-  cross(b) {
-    return new Vector(this.y * b.x - this.x * b.y, this.x * b.y - this.y * b.x);
-  }
-  /**
-   * Calculates the length (magnitude) of this vector.
-   * @returns The length of the vector.
-   */
-  length() {
-    if (this.x === 0 && this.y === 0) {
-      return 0;
-    }
-    return Math.sqrt(this.x ** 2 + this.y ** 2);
-  }
-  /**
-   * Normalizes the vector (makes it unit length, i.e., has a length of 1).
-   * @returns A new vector that is the normalized version of this vector.
-   */
-  normalize() {
-    const len = this.length();
-    if (len === 0) {
-      return new Vector(0, 0);
-    }
-    return new Vector(this.x / len, this.y / len);
-  }
-  /**
-   * Rounds the components of the vector to the nearest integers.
-   * @returns A new vector with rounded components.
-   */
-  round() {
-    return new Vector(Math.round(this.x), Math.round(this.y));
-  }
-}
-function vector(...args) {
-  if (args.length === 1 && args[0] instanceof Vector) {
-    return args[0];
-  }
-  if (args.length === 2) {
-    return new Vector(args[0], args[1]);
-  }
-  return new Vector(args[0].x, args[0].y);
-}
-
-export { Vector, vector };