@likec4/diagram 1.55.1 → 1.57.0

package/dist/likec4diagram/state/assign.js

@@ -1,121 +1,97 @@
-import { nonNullable } from '@likec4/core';
-import { vector } from '@likec4/core/geometry';
-import { getNodeDimensions } from '@xyflow/system';
-import { deepEqual } from 'fast-equals';
-import { mergeDeep } from 'remeda';
-import { assertEvent } from 'xstate';
-import { getNodeCenter } from '../../utils/xyflow.js';
-import { updateNodes } from '../../base/updateNodes.js';
-import { updateEdges } from '../../base/updateEdges.js';
-import { Base } from '../../base/Base.js';
-
+import "../../_virtual/_rolldown/runtime.js";
+import { getNodeCenter } from "../../utils/xyflow.js";
+import { Base } from "../../base/Base.js";
+import { updateEdges } from "../../base/updateEdges.js";
+import { updateNodes } from "../../base/updateNodes.js";
+import { deepEqual } from "fast-equals";
+import { mergeDeep } from "remeda";
+import { nonNullable } from "@likec4/core";
+import { vector } from "@likec4/core/geometry";
+import { getNodeDimensions } from "@xyflow/system";
+import { assertEvent } from "xstate";
+//#region src/likec4diagram/state/assign.ts
 function mergeXYNodesEdges(context, event) {
-  const nextView = event.view;
-  const currentView = context.view;
-  const isSameView = currentView.id === nextView.id;
-  const isDynamicViewUpdate = nextView._type === "dynamic" && nextView.variant === "sequence";
-  if (isDynamicViewUpdate) {
-    return {
-      xynodes: event.xynodes,
-      xyedges: event.xyedges,
-      view: nextView
-    };
-  }
-  const xynodes = updateNodes(context.xynodes, event.xynodes);
-  const xyedges = isSameView ? updateEdges(context.xyedges, event.xyedges) : event.xyedges;
-  return {
-    xynodes,
-    xyedges,
-    view: nextView
-  };
+	const nextView = event.view;
+	const isSameView = context.view.id === nextView.id;
+	if (nextView._type === "dynamic" && nextView.variant === "sequence") return {
+		xynodes: event.xynodes,
+		xyedges: event.xyedges,
+		view: nextView
+	};
+	return {
+		xynodes: updateNodes(context.xynodes, event.xynodes),
+		xyedges: isSameView ? updateEdges(context.xyedges, event.xyedges) : event.xyedges,
+		view: nextView
+	};
 }
 function focusNodesEdges(context) {
-  const { xynodes: _xynodes, xyedges: _xyedges, focusedNode } = context;
-  if (!focusedNode) {
-    return null;
-  }
-  const focused = /* @__PURE__ */ new Set([focusedNode]);
-  const xyedges = _xyedges.map((edge) => {
-    if (edge.source === focusedNode || edge.target === focusedNode) {
-      focused.add(edge.source);
-      focused.add(edge.target);
-      return Base.setData(edge, {
-        dimmed: false,
-        active: true
-      });
-    }
-    return Base.setData(edge, {
-      dimmed: true,
-      active: false
-    });
-  });
-  return {
-    xynodes: _xynodes.map((n) => Base.setDimmed(n, !focused.has(n.id))),
-    xyedges
-  };
+	const { xynodes: _xynodes, xyedges: _xyedges, focusedNode } = context;
+	if (!focusedNode) return null;
+	const focused = new Set([focusedNode]);
+	const xyedges = _xyedges.map((edge) => {
+		if (edge.source === focusedNode || edge.target === focusedNode) {
+			focused.add(edge.source);
+			focused.add(edge.target);
+			return Base.setData(edge, {
+				dimmed: false,
+				active: true
+			});
+		}
+		return Base.setData(edge, {
+			dimmed: true,
+			active: false
+		});
+	});
+	return {
+		xynodes: _xynodes.map((n) => Base.setDimmed(n, !focused.has(n.id))),
+		xyedges
+	};
 }
 function updateNodeData({ context, event }) {
-  assertEvent(event, "update.nodeData");
-  const xynodes = context.xynodes.map((node) => {
-    if (node.id !== event.nodeId) {
-      return node;
-    }
-    const data = mergeDeep(node.data, event.data);
-    if (deepEqual(data, node.data)) {
-      return node;
-    }
-    return {
-      ...node,
-      data
-    };
-  });
-  return { xynodes };
+	assertEvent(event, "update.nodeData");
+	return { xynodes: context.xynodes.map((node) => {
+		if (node.id !== event.nodeId) return node;
+		const data = mergeDeep(node.data, event.data);
+		if (deepEqual(data, node.data)) return node;
+		return {
+			...node,
+			data
+		};
+	}) };
 }
 function updateEdgeData({ context, event }) {
-  assertEvent(event, "update.edgeData");
-  const xyedges = context.xyedges.map((edge) => {
-    if (edge.id !== event.edgeId) {
-      return edge;
-    }
-    const data = mergeDeep(edge.data, event.data);
-    if (deepEqual(data, edge.data)) {
-      return edge;
-    }
-    return {
-      ...edge,
-      data
-    };
-  });
-  return { xyedges };
+	assertEvent(event, "update.edgeData");
+	return { xyedges: context.xyedges.map((edge) => {
+		if (edge.id !== event.edgeId) return edge;
+		const data = mergeDeep(edge.data, event.data);
+		if (deepEqual(data, edge.data)) return edge;
+		return {
+			...edge,
+			data
+		};
+	}) };
 }
 function getBorderPointOnVector(node, nodeCenter, v) {
-  const dimensions = getNodeDimensions(node);
-  const xScale = dimensions.width / 2 / v.x;
-  const yScale = dimensions.height / 2 / v.y;
-  const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
-  return vector(v).multiply(scale).add(nodeCenter);
+	const dimensions = getNodeDimensions(node);
+	const xScale = dimensions.width / 2 / v.x;
+	const yScale = dimensions.height / 2 / v.y;
+	const scale = Math.min(Math.abs(xScale), Math.abs(yScale));
+	return vector(v).multiply(scale).add(nodeCenter);
 }
 function resetEdgeControlPoints(nodeLookup, edge) {
-  const source = nonNullable(nodeLookup.get(edge.source), `Source node ${edge.source} not found`);
-  const target = nonNullable(nodeLookup.get(edge.target), `Target node ${edge.target} not found`);
-  const sourceCenter = vector(getNodeCenter(source));
-  const targetCenter = vector(getNodeCenter(target));
-  if (source === target) {
-    const loopSize = 80;
-    const centerOfTopBoundary = vector(0, source.height || 0).multiply(-0.5).add(sourceCenter);
-    return [
-      centerOfTopBoundary.add(vector(-loopSize / 2.5, -loopSize)).round().toObject(),
-      centerOfTopBoundary.add(vector(loopSize / 2.5, -loopSize)).round().toObject()
-    ];
-  }
-  const sourceToTargetVector = targetCenter.subtract(sourceCenter);
-  const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
-  const targetBorderPoint = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1));
-  const sourceToTarget = targetBorderPoint.subtract(sourceBorderPoint);
-  return [
-    sourceBorderPoint.add(sourceToTarget.multiply(0.4)).round().toObject(),
-    sourceBorderPoint.add(sourceToTarget.multiply(0.6)).round().toObject()
-  ];
+	const source = nonNullable(nodeLookup.get(edge.source), `Source node ${edge.source} not found`);
+	const target = nonNullable(nodeLookup.get(edge.target), `Target node ${edge.target} not found`);
+	const sourceCenter = vector(getNodeCenter(source));
+	const targetCenter = vector(getNodeCenter(target));
+	if (source === target) {
+		const loopSize = 80;
+		const centerOfTopBoundary = vector(0, source.height || 0).multiply(-.5).add(sourceCenter);
+		return [centerOfTopBoundary.add(vector(-80 / 2.5, -80)).round().toObject(), centerOfTopBoundary.add(vector(loopSize / 2.5, -80)).round().toObject()];
+	}
+	const sourceToTargetVector = targetCenter.subtract(sourceCenter);
+	const sourceBorderPoint = getBorderPointOnVector(source, sourceCenter, sourceToTargetVector);
+	const sourceToTarget = getBorderPointOnVector(target, targetCenter, sourceToTargetVector.multiply(-1)).subtract(sourceBorderPoint);
+	return [sourceBorderPoint.add(sourceToTarget.multiply(.4)).round().toObject(), sourceBorderPoint.add(sourceToTarget.multiply(.6)).round().toObject()];
 }
-
+//#endregion
 export { focusNodesEdges, mergeXYNodesEdges, resetEdgeControlPoints, updateEdgeData, updateNodeData };

package/dist/likec4diagram/state/createViewChange.js

@@ -1,95 +1,75 @@
-import { getNodeDimensions } from '@xyflow/system';
-import { map, hasAtLeast } from 'remeda';
-import { calcViewBounds } from '../../utils/view-bounds.js';
-import { isSamePoint, bezierControlPoints } from '../../utils/xyflow.js';
-
+import "../../_virtual/_rolldown/runtime.js";
+import { bezierControlPoints, isSamePoint } from "../../utils/xyflow.js";
+import { calcViewBounds } from "../../utils/view-bounds.js";
+import { hasAtLeast, map } from "remeda";
+import { getNodeDimensions } from "@xyflow/system";
+//#region src/likec4diagram/state/createViewChange.ts
 function createViewChange(parentContext) {
-  const {
-    view: {
-      drifts: _1,
-      // Ignore drifts from view
-      _layout: _2,
-      // Ignore layout type from view
-      ...view
-    },
-    xynodes,
-    xystore
-  } = parentContext;
-  const { nodeLookup, edgeLookup } = xystore.getState();
-  const movedNodes = /* @__PURE__ */ new Set();
-  const nodes = map(view.nodes, (node) => {
-    const internal = nodeLookup.get(node.id);
-    if (!internal) {
-      console.error(`Internal node not found for ${node.id}`);
-      return node;
-    }
-    const xynodedata = xynodes.find((n) => n.id === node.id)?.data ?? internal.data;
-    const position = internal.internals.positionAbsolute;
-    const { width, height } = getNodeDimensions(internal);
-    const isChanged = !isSamePoint(position, node) || node.width !== width || node.height !== height;
-    if (isChanged) {
-      movedNodes.add(node.id);
-    }
-    return {
-      ...node,
-      shape: xynodedata.shape,
-      color: xynodedata.color,
-      style: {
-        ...xynodedata.style
-      },
-      x: Math.floor(position.x),
-      y: Math.floor(position.y),
-      width: Math.ceil(width),
-      height: Math.ceil(height)
-    };
-  });
-  const edges = map(view.edges, (edge) => {
-    const xyedge = edgeLookup.get(edge.id);
-    if (!xyedge) {
-      console.error(`Internal edge not found for ${edge.id}`);
-      return edge;
-    }
-    const data = xyedge.data;
-    let controlPoints = data.controlPoints ?? [];
-    const sourceOrTargetMoved = movedNodes.has(xyedge.source) || movedNodes.has(xyedge.target);
-    if (controlPoints.length === 0 && sourceOrTargetMoved) {
-      controlPoints = bezierControlPoints(data.points);
-    }
-    const _updated = {
-      ...edge,
-      points: data.points
-    };
-    if (data.labelBBox) {
-      _updated.labelBBox = {
-        x: Math.round(data.labelBBox.x),
-        y: Math.round(data.labelBBox.y),
-        width: Math.round(data.labelBBox.width),
-        height: Math.round(data.labelBBox.height)
-      };
-    } else {
-      _updated.labelBBox = null;
-    }
-    if (hasAtLeast(controlPoints, 1)) {
-      _updated.controlPoints = map(controlPoints, (v) => ({
-        x: Math.round(v.x),
-        y: Math.round(v.y)
-      }));
-    } else {
-      _updated.controlPoints = null;
-    }
-    return _updated;
-  });
-  const snapshot = {
-    ...view,
-    _layout: "manual",
-    bounds: calcViewBounds({ nodes, edges }),
-    nodes,
-    edges
-  };
-  return {
-    op: "save-view-snapshot",
-    layout: snapshot
-  };
+	const { view: { drifts: _1, _layout: _2, ...view }, xynodes, xystore } = parentContext;
+	const { nodeLookup, edgeLookup } = xystore.getState();
+	const movedNodes = /* @__PURE__ */ new Set();
+	const nodes = map(view.nodes, (node) => {
+		const internal = nodeLookup.get(node.id);
+		if (!internal) {
+			console.error(`Internal node not found for ${node.id}`);
+			return node;
+		}
+		const xynodedata = xynodes.find((n) => n.id === node.id)?.data ?? internal.data;
+		const position = internal.internals.positionAbsolute;
+		const { width, height } = getNodeDimensions(internal);
+		if (!isSamePoint(position, node) || node.width !== width || node.height !== height) movedNodes.add(node.id);
+		return {
+			...node,
+			shape: xynodedata.shape,
+			color: xynodedata.color,
+			style: { ...xynodedata.style },
+			x: Math.floor(position.x),
+			y: Math.floor(position.y),
+			width: Math.ceil(width),
+			height: Math.ceil(height)
+		};
+	});
+	const edges = map(view.edges, (edge) => {
+		const xyedge = edgeLookup.get(edge.id);
+		if (!xyedge) {
+			console.error(`Internal edge not found for ${edge.id}`);
+			return edge;
+		}
+		const data = xyedge.data;
+		let controlPoints = data.controlPoints ?? [];
+		const sourceOrTargetMoved = movedNodes.has(xyedge.source) || movedNodes.has(xyedge.target);
+		if (controlPoints.length === 0 && sourceOrTargetMoved) controlPoints = bezierControlPoints(data.points);
+		const _updated = {
+			...edge,
+			points: data.points
+		};
+		if (data.labelBBox) _updated.labelBBox = {
+			x: Math.round(data.labelBBox.x),
+			y: Math.round(data.labelBBox.y),
+			width: Math.round(data.labelBBox.width),
+			height: Math.round(data.labelBBox.height)
+		};
+		else _updated.labelBBox = null;
+		if (hasAtLeast(controlPoints, 1)) _updated.controlPoints = map(controlPoints, (v) => ({
+			x: Math.round(v.x),
+			y: Math.round(v.y)
+		}));
+		else _updated.controlPoints = null;
+		return _updated;
+	});
+	return {
+		op: "save-view-snapshot",
+		layout: {
+			...view,
+			_layout: "manual",
+			bounds: calcViewBounds({
+				nodes,
+				edges
+			}),
+			nodes,
+			edges
+		}
+	};
 }
-
+//#endregion
 export { createViewChange };

package/dist/likec4diagram/state/diagram-api.d.ts

@@ -2,8 +2,10 @@ import { DynamicViewDisplayVariant, NodeNotation as ElementNotation, ViewChange
 import { RefObject } from 'react';
 import { PartialDeep } from 'type-fest';
 import { FeatureName } from '../../context/DiagramFeatures';
+import { EditorActorRef } from '../../editor/actor/machine';
 import { OpenSourceParams } from '../../LikeC4Diagram.props';
 import { OverlaysActorRef } from '../../overlays/overlaysActor';
+import { SearchActorRef } from '../../search/searchActor';
 import { Types } from '../types';
 import { AlignmentMode } from './aligners';
 import { DiagramActorRef, DiagramContext, DiagramEvents } from './types';
@@ -27,7 +29,21 @@ export interface DiagramApi<A extends Any = Unknown> {
      * @warning Do not use in render phase
      */
     readonly currentView: t.DiagramView<A>;
+    /**
+     * Editor actor reference
+     * @warning Do not use in render phase
+     */
+    editorActor(): EditorActorRef;
+    /**
+     * Overlays actor reference
+     * @warning Do not use in render phase
+     */
     overlays(): OverlaysActorRef;
+    /**
+     * Search actor reference
+     * @warning Do not use in render phase
+     */
+    searchActor(): SearchActorRef;
     /**
      * Send event to diagram actor
      */