@likec4/diagram 1.59.4 → 1.61.0

package/dist/likec4diagram/ui/sequence-outline/presentation.js

@@ -1,80 +0,0 @@
-import { css } from "@likec4/styles/css";
-import { IconAlertTriangle, IconArrowFork, IconArrowGuide, IconCornerDownRight, IconPlayerStop, IconRepeat } from "@tabler/icons-react";
-//#region src/likec4diagram/ui/sequence-outline/presentation.ts
-/**
-* PandaCSS `colorPalette` classes for each sub-flow palette.
-* Declared as literals so the static analyzer can extract them.
-*/
-var palette = {
-	loop: css({ colorPalette: "subflow.loop" }),
-	opt: css({ colorPalette: "subflow.opt" }),
-	par: css({ colorPalette: "subflow.par" }),
-	break: css({ colorPalette: "subflow.break" }),
-	alt: css({ colorPalette: "subflow.alt" }),
-	try: css({ colorPalette: "subflow.try" })
-};
-/** How each sub-flow operator is labelled and coloured in the outline. */
-var flowPresentation = {
-	loop: {
-		paletteClass: palette.loop,
-		tag: "loop",
-		Icon: IconRepeat
-	},
-	opt: {
-		paletteClass: palette.opt,
-		tag: "opt",
-		Icon: IconArrowGuide
-	},
-	par: {
-		paletteClass: palette.par,
-		tag: "par",
-		Icon: IconArrowFork
-	},
-	break: {
-		paletteClass: palette.break,
-		tag: "break",
-		Icon: IconPlayerStop
-	},
-	alt: {
-		paletteClass: palette.alt,
-		tag: "alt",
-		Icon: IconArrowFork
-	},
-	"alt-when": {
-		paletteClass: palette.alt,
-		tag: "when",
-		Icon: IconCornerDownRight
-	},
-	"alt-else": {
-		paletteClass: palette.alt,
-		tag: "else",
-		Icon: IconCornerDownRight
-	},
-	"alt-if": {
-		paletteClass: palette.alt,
-		tag: "if",
-		Icon: IconCornerDownRight
-	},
-	try: {
-		paletteClass: palette.try,
-		tag: "try",
-		Icon: IconAlertTriangle
-	},
-	"try-block": {
-		paletteClass: palette.try,
-		tag: "block",
-		Icon: IconCornerDownRight
-	},
-	"try-catch": {
-		paletteClass: palette.break,
-		tag: "catch",
-		Icon: IconCornerDownRight
-	},
-	"try-finally": {
-		paletteClass: palette.break,
-		tag: "finally",
-		Icon: IconCornerDownRight
-	}
-};
-//#endregion
-export { flowPresentation };

package/dist/likec4diagram/ui/sequence-outline/tree.d.ts

@@ -1,9 +0,0 @@
-import { DynamicViewFlow, StepPath } from '@likec4/core/types';
-import { OutlineTreeNodeFlow, OutlineTreeNodes } from './types';
-/** Flattens the walkthrough flow into the nested step/sub-flow tree the outline renders. */
-export declare function buildTree(flow: DynamicViewFlow): OutlineTreeNodes;
-export declare function useTreeData(flow: DynamicViewFlow): OutlineTreeNodes;
-/** The first step inside a fragment — where the breadcrumb jumps to. */
-export declare function firstStepOf(nodes: OutlineTreeNodes): StepPath | null;
-/** The chain of sub-flows the active step is nested inside, outermost first. */
-export declare function collectTrail(nodes: OutlineTreeNodes, ancestors: readonly string[]): OutlineTreeNodeFlow[];

package/dist/likec4diagram/ui/sequence-outline/tree.js

@@ -1,67 +0,0 @@
-import "../../../_virtual/_rolldown/runtime.js";
-import { isOutlineFlowNode } from "./types.js";
-import "react";
-//#region src/likec4diagram/ui/sequence-outline/tree.ts
-/** Flattens the walkthrough flow into the nested step/sub-flow tree the outline renders. */
-function buildTree(flow) {
-	const tree = [];
-	let currentFlow = tree;
-	flow.walk({
-		step: ({ step, stepnum, source, target, edge }) => {
-			currentFlow.push({
-				label: edge.label ?? `${source.title} → ${target.title}`,
-				value: step,
-				nodeProps: {
-					type: "step",
-					stepnum: stepnum.global,
-					source: source.title,
-					target: target.title,
-					label: edge.label,
-					notes: edge.notes ?? null,
-					edge
-				}
-			});
-		},
-		subflow: ({ subflow }) => {
-			const node = {
-				label: subflow.title ?? subflow._type,
-				value: subflow.id,
-				nodeProps: {
-					type: subflow._type,
-					title: subflow.title
-				},
-				children: []
-			};
-			const parent = currentFlow;
-			parent.push(node);
-			currentFlow = node.children;
-			return () => {
-				currentFlow = parent;
-			};
-		}
-	});
-	return tree;
-}
-/** The first step inside a fragment — where the breadcrumb jumps to. */
-function firstStepOf(nodes) {
-	for (const node of nodes) if (isOutlineFlowNode(node)) {
-		const found = firstStepOf(node.children);
-		if (found) return found;
-	} else return node.value;
-	return null;
-}
-/** The chain of sub-flows the active step is nested inside, outermost first. */
-function collectTrail(nodes, ancestors) {
-	const trail = [];
-	const walk = (list) => {
-		for (const node of list) if (isOutlineFlowNode(node) && ancestors.includes(node.value)) {
-			trail.push(node);
-			walk(node.children);
-			return;
-		}
-	};
-	walk(nodes);
-	return trail;
-}
-//#endregion
-export { buildTree, collectTrail, firstStepOf };

package/dist/likec4diagram/ui/sequence-outline/types.d.ts

@@ -1,38 +0,0 @@
-import { DiagramEdge, DynamicViewFlow, scalar, StepPath } from '@likec4/core/types';
-import { TreeNodeData } from '@mantine/core';
-import { DiagramContext } from '../../state/types';
-/** Sub-flows the user has folded away, keyed by {@link StepPath}. */
-export type CollapsedFlows = DiagramContext['collapsedSequenceFlows'];
-export interface OutlineTreeNodeStep extends TreeNodeData {
-    readonly value: StepPath;
-    readonly nodeProps: Readonly<{
-        readonly type: 'step';
-        /** Global step number (1-based) across all flows */
-        readonly stepnum: number;
-        /** Title of the source actor */
-        readonly source: string;
-        /** Title of the target actor */
-        readonly target: string;
-        /** Relationship label, if any */
-        readonly label: string | null;
-        readonly notes: scalar.MarkdownOrString | null;
-        readonly edge: DiagramEdge;
-    }>;
-}
-export interface OutlineTreeNodeFlow extends TreeNodeData {
-    readonly value: StepPath;
-    readonly nodeProps: Readonly<{
-        readonly type: DynamicViewFlow.SubFlowType;
-        /** Friendly title of the sub-flow, if defined */
-        readonly title: string | undefined;
-    }>;
-    children: OutlineTreeNodeData[];
-}
-export type OutlineTreeNodeData = OutlineTreeNodeStep | OutlineTreeNodeFlow;
-export type OutlineTreeNodes = OutlineTreeNodeData[];
-/**
- * Type guard narrowing a tree node to a sub-flow node.
- * (The discriminant lives on the nested `nodeProps.type`, so an explicit guard
- * is needed for reliable narrowing.)
- */
-export declare function isOutlineFlowNode(node: OutlineTreeNodeData): node is OutlineTreeNodeFlow;

package/dist/likec4diagram/ui/sequence-outline/types.js

@@ -1,12 +0,0 @@
-import "../../../_virtual/_rolldown/runtime.js";
-//#region src/likec4diagram/ui/sequence-outline/types.ts
-/**
-* Type guard narrowing a tree node to a sub-flow node.
-* (The discriminant lives on the nested `nodeProps.type`, so an explicit guard
-* is needed for reliable narrowing.)
-*/
-function isOutlineFlowNode(node) {
-	return node.nodeProps.type !== "step";
-}
-//#endregion
-export { isOutlineFlowNode };

package/dist/likec4diagram/useLayoutConstraints.d.ts

@@ -1,54 +0,0 @@
-import { NonEmptyArray } from '@likec4/core';
-import { Dimensions, XYPoint, BBox } from '@likec4/core/geometry';
-import { InternalNode as RFInternalNode, OnNodeDrag } from '@xyflow/react';
-import { XYStoreApi } from '../hooks';
-import { Types } from './types';
-type InternalNode = RFInternalNode<Types.AnyNode>;
-declare abstract class Rect {
-    static readonly LeftPadding = 42;
-    static readonly RightPadding = 42;
-    static readonly TopPadding = 60;
-    static readonly BottomPadding = 42;
-    id: string;
-    minX: number;
-    minY: number;
-    maxX: number;
-    maxY: number;
-    readonly initial: BBox;
-    get positionAbsolute(): XYPoint;
-    set positionAbsolute(pos: XYPoint);
-    get dimensions(): Dimensions;
-    get diff(): XYPoint;
-    get isMoved(): boolean;
-    get isResized(): boolean;
-    get position(): XYPoint;
-    protected abstract parent: CompoundRect | null;
-    constructor(xynode: InternalNode, parent?: CompoundRect | null);
-}
-declare class CompoundRect extends Rect {
-    readonly parent: CompoundRect | null;
-    readonly children: Rect[];
-    constructor(xynode: InternalNode, parent?: CompoundRect | null);
-}
-declare class Leaf extends Rect {
-    readonly parent: CompoundRect | null;
-    constructor(xynode: InternalNode, parent?: CompoundRect | null);
-}
-export declare function createLayoutConstraints(xyflowApi: XYStoreApi, editingNodeIds: NonEmptyArray<string>): {
-    rects: ReadonlyMap<string, Leaf | CompoundRect>;
-    onMove: () => void;
-    updateXYFlow: () => void;
-    hasChanges: () => boolean;
-    cancelPending: () => void;
-    flushPending: () => void;
-};
-type LayoutConstraints = {
-    onNodeDragStart: OnNodeDrag<Types.Node>;
-    onNodeDrag: OnNodeDrag<Types.Node>;
-    onNodeDragStop: OnNodeDrag<Types.Node>;
-};
-/**
- * Keeps the layout constraints (parent nodes and children) when dragging a node
- */
-export declare function useLayoutConstraints(): LayoutConstraints;
-export {};

package/dist/likec4diagram/useLayoutConstraints.js

@@ -1,409 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { useXYStoreApi } from "../hooks/useXYFlow.js";
-import { bezierControlPoints, nodeToRect as nodeToRect$1 } from "../utils/xyflow.js";
-import { useDiagram } from "../hooks/safeContext.js";
-import { vector as vector$1 } from "../utils/index.js";
-import { useMemo, useRef } from "react";
-import { clamp, difference, filter, flatMap, hasAtLeast, map, pipe, unique } from "remeda";
-import { DefaultMap, nonNullable } from "@likec4/core";
-import { BBox as BBox$1 } from "@likec4/core/geometry";
-import { invariant as invariant$1, isome } from "@likec4/core/utils";
-import { getNodeDimensions } from "@xyflow/system";
-import { produce } from "immer";
-//#region src/likec4diagram/useLayoutConstraints.ts
-var Rect = class {
-	static LeftPadding = 42;
-	static RightPadding = 42;
-	static TopPadding = 60;
-	static BottomPadding = 42;
-	id;
-	minX = Infinity;
-	minY = Infinity;
-	maxX = -Infinity;
-	maxY = -Infinity;
-	initial;
-	get positionAbsolute() {
-		return {
-			x: this.minX,
-			y: this.minY
-		};
-	}
-	set positionAbsolute(pos) {
-		const x = Math.trunc(pos.x);
-		const y = Math.trunc(pos.y);
-		this.maxX += x - this.minX;
-		this.maxY += y - this.minY;
-		this.minX = x;
-		this.minY = y;
-	}
-	get dimensions() {
-		return {
-			width: Math.ceil(this.maxX - this.minX),
-			height: Math.ceil(this.maxY - this.minY)
-		};
-	}
-	get diff() {
-		const { x, y } = this.positionAbsolute;
-		return {
-			x: Math.trunc(x - this.initial.x),
-			y: Math.trunc(y - this.initial.y)
-		};
-	}
-	get isMoved() {
-		const diff = this.diff;
-		return diff.x !== 0 || diff.y !== 0;
-	}
-	get isResized() {
-		const dim = this.dimensions;
-		return dim.width !== this.initial.width || dim.height !== this.initial.height;
-	}
-	get position() {
-		const positionAbsolute = this.positionAbsolute;
-		if (!this.parent) return positionAbsolute;
-		const parentPosition = this.parent.positionAbsolute;
-		return {
-			x: positionAbsolute.x - parentPosition.x,
-			y: positionAbsolute.y - parentPosition.y
-		};
-	}
-	constructor(xynode, parent = null) {
-		this.id = xynode.id;
-		this.positionAbsolute = !parent ? xynode.position : {
-			x: xynode.position.x + parent.minX,
-			y: xynode.position.y + parent.minY
-		};
-		const { width, height } = getNodeDimensions(xynode);
-		this.maxX = this.minX + Math.ceil(width);
-		this.maxY = this.minY + Math.ceil(height);
-		this.initial = {
-			x: this.minX,
-			y: this.minY,
-			width: Math.ceil(width),
-			height: Math.ceil(height)
-		};
-		if (parent) parent.children.push(this);
-	}
-};
-var CompoundRect = class extends Rect {
-	parent;
-	children = [];
-	constructor(xynode, parent = null) {
-		super(xynode, parent);
-		this.parent = parent;
-	}
-};
-var Leaf = class extends Rect {
-	parent;
-	constructor(xynode, parent = null) {
-		super(xynode, parent);
-		this.parent = parent;
-	}
-};
-/**
-* Creates a modifier function that moves edge points according to the given rectangle's diff.
-*/
-function makeEdgeModifier(edge, anchor) {
-	const controlPoints = edge.data.controlPoints ?? null;
-	return (edgeLookup) => {
-		const current = nonNullable(edgeLookup.get(edge.id), `Edge ${edge.id} not found`);
-		const { x: dx, y: dy } = anchor.diff;
-		if (dx === 0 && dy === 0) return {
-			id: edge.id,
-			type: "replace",
-			item: produce(current, (draft) => {
-				draft.data.points = edge.data.points;
-				draft.data.controlPoints = controlPoints;
-				draft.data.labelBBox = edge.data.labelBBox;
-			})
-		};
-		return {
-			id: edge.id,
-			type: "replace",
-			item: produce(current, (draft) => {
-				draft.data.points = map(edge.data.points, (pt) => [pt[0] + dx, pt[1] + dy]);
-				if (controlPoints) draft.data.controlPoints = controlPoints.map((pt) => ({
-					x: pt.x + dx,
-					y: pt.y + dy
-				}));
-				else draft.data.controlPoints = null;
-				if (edge.data.labelBBox) {
-					draft.data.labelBBox ??= edge.data.labelBBox;
-					draft.data.labelBBox.x = edge.data.labelBBox.x + dx;
-					draft.data.labelBBox.y = edge.data.labelBBox.y + dy;
-				}
-			})
-		};
-	};
-}
-/**
-* Creates a modifier function that moves edge points when one of its nodes is moved.
-*/
-function makeRelativeEdgeModifier(edge, movingRect, anchorNode, staticNode) {
-	const controlPoints = edge.data.controlPoints ?? bezierControlPoints(edge.data.points);
-	const anchorV = vector$1(BBox$1.center(anchorNode));
-	const staticV = vector$1(BBox$1.center(staticNode));
-	const staticToAnchor = anchorV.subtract(staticV);
-	const staticToAnchorLength = staticToAnchor.length();
-	return (edgeLookup) => {
-		const current = nonNullable(edgeLookup.get(edge.id), `Edge ${edge.id} not found`);
-		const { x: dx, y: dy } = movingRect.diff;
-		if (dx === 0 && dy === 0) return {
-			id: edge.id,
-			type: "replace",
-			item: produce(current, (draft) => {
-				draft.data.points = edge.data.points;
-				draft.data.controlPoints = edge.data.controlPoints;
-				draft.data.labelBBox = edge.data.labelBBox;
-			})
-		};
-		const d = vector$1(dx, dy);
-		const relativePoint = (pt) => {
-			if (staticToAnchorLength === 0) return {
-				x: pt.x,
-				y: pt.y
-			};
-			const point = vector$1(pt);
-			const projLength = point.subtract(staticV).dot(staticToAnchor);
-			const coeff = clamp(projLength / staticToAnchorLength ** 2, {
-				min: -1,
-				max: 1
-			});
-			const newPoint = point.add(d.multiply(coeff)).trunc();
-			return {
-				x: newPoint.x,
-				y: newPoint.y
-			};
-		};
-		return {
-			id: edge.id,
-			type: "replace",
-			item: produce(current, (draft) => {
-				draft.data.controlPoints = controlPoints.map(relativePoint);
-				draft.data.points = map(edge.data.points, ([x, y]) => {
-					const point = relativePoint({
-						x,
-						y
-					});
-					return [point.x, point.y];
-				});
-				if (edge.data.labelBBox) {
-					draft.data.labelBBox ??= edge.data.labelBBox;
-					const { x, y } = relativePoint(edge.data.labelBBox);
-					draft.data.labelBBox.x = x;
-					draft.data.labelBBox.y = y;
-				}
-			})
-		};
-	};
-}
-function createLayoutConstraints(xyflowApi, editingNodeIds) {
-	const { parentLookup, nodeLookup, edges } = xyflowApi.getState();
-	const rects = /* @__PURE__ */ new Map();
-	/** Maps node id to all its ancestors */
-	const ancestorsOf = new DefaultMap((nodeId) => {
-		let parent = nodeLookup.get(nodeId)?.parentId;
-		if (!parent) return [];
-		return [parent, ...ancestorsOf.get(parent)];
-	});
-	/** Maps node id to all its nested descendants */
-	const nestedOf = new DefaultMap((nodeId) => {
-		const children = parentLookup.get(nodeId);
-		if (!children || children.size === 0) return /* @__PURE__ */ new Set();
-		const nested = /* @__PURE__ */ new Set();
-		for (const child of children.values()) {
-			nested.add(child.id);
-			for (const desc of nestedOf.get(child.id)) nested.add(desc);
-		}
-		return nested;
-	});
-	if (hasAtLeast(editingNodeIds, 2)) {
-		const leafsOnly = pipe(editingNodeIds, flatMap((id) => [...nestedOf.get(id)]), unique(), (exclude) => difference(editingNodeIds, exclude));
-		invariant$1(hasAtLeast(leafsOnly, 1), "All editing nodes are nested within each other");
-		editingNodeIds = leafsOnly;
-	}
-	const ancestorsOfDraggingNodes = new Set(editingNodeIds.flatMap((i) => ancestorsOf.get(i)));
-	const traverse = [...nodeLookup.values()].flatMap((x) => !x.parentId ? {
-		xynode: x,
-		parent: null
-	} : []);
-	while (traverse.length > 0) {
-		const { xynode, parent } = traverse.shift();
-		if (!editingNodeIds.includes(xynode.id) && ancestorsOfDraggingNodes.has(xynode.id)) {
-			const rect = new CompoundRect(xynode, parent);
-			rects.set(xynode.id, rect);
-			parentLookup.get(xynode.id)?.forEach((child) => {
-				traverse.push({
-					xynode: child,
-					parent: rect
-				});
-			});
-			continue;
-		}
-		rects.set(xynode.id, new Leaf(xynode, parent));
-	}
-	const rectsToUpdate = [...rects.values()];
-	/**
-	* Edges that need to be updated because both source and target are moved
-	* - source and target are inside a compound node that is moved
-	* - source and target are selected and moved
-	*/
-	const edgeModifiers = /* @__PURE__ */ new Map();
-	const findMovingAncestor = (nodeId) => {
-		const r = rects.get(nodeId);
-		if (r) return r;
-		for (const parent of ancestorsOf.get(nodeId)) {
-			const rect = rects.get(parent);
-			if (rect) return rect;
-		}
-		return null;
-	};
-	const movingNodes = new Set(editingNodeIds.flatMap((id) => [id, ...nestedOf.get(id)]));
-	for (const edge of edges) {
-		const isSourceMoving = movingNodes.has(edge.source);
-		const isTargetMoving = movingNodes.has(edge.target);
-		if (!isSourceMoving && !isTargetMoving) continue;
-		if (isSourceMoving && isTargetMoving) {
-			let r = rects.get(edge.source) ?? rects.get(edge.target) ?? findMovingAncestor(edge.source) ?? findMovingAncestor(edge.target);
-			invariant$1(!!r, "At least one of the edge nodes should have a moving ancestor");
-			edgeModifiers.set(edge, makeEdgeModifier(edge, r));
-			continue;
-		}
-		invariant$1(isSourceMoving !== isTargetMoving, "Logic error");
-		const movingRect = isSourceMoving ? findMovingAncestor(edge.source) : findMovingAncestor(edge.target);
-		invariant$1(!!movingRect, "Moving endpoint should be found");
-		const [sourceNode, targetNode] = pipe([edge.source, edge.target], map((id) => nonNullable(nodeLookup.get(id), `Node ${id} not found`)), map(nodeToRect$1));
-		const [anchorNode, staticNode] = isSourceMoving ? [sourceNode, targetNode] : [targetNode, sourceNode];
-		edgeModifiers.set(edge, makeRelativeEdgeModifier(edge, movingRect, anchorNode, staticNode));
-	}
-	function applyConstraints(targets) {
-		for (const r of targets) {
-			if (!(r instanceof CompoundRect)) continue;
-			applyConstraints(r.children);
-			const childrenBB = {
-				minX: Infinity,
-				minY: Infinity,
-				maxX: -Infinity,
-				maxY: -Infinity
-			};
-			for (const child of r.children) {
-				childrenBB.minX = Math.min(childrenBB.minX, child.minX);
-				childrenBB.minY = Math.min(childrenBB.minY, child.minY);
-				childrenBB.maxX = Math.max(childrenBB.maxX, child.maxX);
-				childrenBB.maxY = Math.max(childrenBB.maxY, child.maxY);
-			}
-			r.minX = childrenBB.minX - Rect.LeftPadding;
-			r.minY = childrenBB.minY - Rect.TopPadding;
-			r.maxX = childrenBB.maxX + Rect.RightPadding;
-			r.maxY = childrenBB.maxY + Rect.BottomPadding;
-		}
-	}
-	const _edgeModifiers = [...edgeModifiers.values()];
-	/**
-	* Read current node positions from XYFlow internal state into rects.
-	* Only needed for drag operations where XYFlow already has the updated positions.
-	*/
-	function syncFromXYFlow() {
-		const { nodeLookup } = xyflowApi.getState();
-		for (const id of editingNodeIds) {
-			const rect = rects.get(id);
-			if (!rect) {
-				console.warn(`Rect not found for id ${id}`);
-				continue;
-			}
-			const node = nodeLookup.get(id);
-			if (!node) {
-				console.warn(`Node not found for id ${id}`);
-				continue;
-			}
-			rect.positionAbsolute = node.internals.positionAbsolute;
-		}
-	}
-	function updateXYFlow() {
-		const { edgeLookup, triggerNodeChanges, triggerEdgeChanges } = xyflowApi.getState();
-		applyConstraints(rectsToUpdate);
-		const nodeUpdates = [];
-		const edgeUpdates = [];
-		for (const r of rectsToUpdate) {
-			nodeUpdates.push({
-				id: r.id,
-				type: "position",
-				dragging: false,
-				position: r.position,
-				positionAbsolute: r.positionAbsolute
-			});
-			if (r instanceof CompoundRect) nodeUpdates.push({
-				id: r.id,
-				type: "dimensions",
-				setAttributes: true,
-				resizing: false,
-				dimensions: r.dimensions
-			});
-		}
-		if (nodeUpdates.length > 0) triggerNodeChanges(nodeUpdates);
-		for (const fm of _edgeModifiers) edgeUpdates.push(fm(edgeLookup));
-		if (edgeUpdates.length > 0) triggerEdgeChanges(edgeUpdates);
-	}
-	let animationFrameId = null;
-	function cancelPending() {
-		if (animationFrameId !== null) {
-			cancelAnimationFrame(animationFrameId);
-			animationFrameId = null;
-		}
-	}
-	function flushPending() {
-		cancelPending();
-		syncFromXYFlow();
-		updateXYFlow();
-	}
-	function onMove() {
-		animationFrameId ??= requestAnimationFrame(() => {
-			animationFrameId = null;
-			syncFromXYFlow();
-			updateXYFlow();
-		});
-	}
-	function hasChanges() {
-		return isome(rectsToUpdate, (r) => r.isMoved || r.isResized);
-	}
-	return {
-		rects,
-		onMove,
-		updateXYFlow,
-		hasChanges,
-		cancelPending,
-		flushPending
-	};
-}
-/**
-* Keeps the layout constraints (parent nodes and children) when dragging a node
-*/
-function useLayoutConstraints() {
-	const xystore = useXYStoreApi();
-	const diagram = useDiagram();
-	const solverRef = useRef(void 0);
-	return useMemo(() => {
-		return {
-			onNodeDragStart: (_event, xynode) => {
-				const { nodeLookup } = xystore.getState();
-				const draggingNodes = pipe(Array.from(nodeLookup.values()), filter((n) => n.dragging === true || n.id === xynode.id || n.selected === true), map((n) => n.id));
-				if (hasAtLeast(draggingNodes, 1)) {
-					diagram.startEditing("node");
-					solverRef.current = createLayoutConstraints(xystore, draggingNodes);
-				}
-			},
-			onNodeDrag: (_event) => {
-				solverRef.current?.onMove();
-			},
-			onNodeDragStop: (_event) => {
-				if (!solverRef.current) return;
-				const hasChanges = solverRef.current.hasChanges();
-				if (hasChanges) solverRef.current.flushPending();
-				else solverRef.current.cancelPending();
-				diagram.stopEditing(hasChanges);
-				solverRef.current = void 0;
-			}
-		};
-	}, [xystore, diagram]);
-}
-//#endregion
-export { createLayoutConstraints, useLayoutConstraints };

package/dist/likec4diagram/xyflow-diagram/diagram-view.d.ts

@@ -1,18 +0,0 @@
-import { DiagramView, ViewId, WhereOperator } from '@likec4/core';
-import { Types } from '../types';
-/**
- * Convert a diagram view to XY flow nodes and edges.
- * @param opts
- * @param opts.view - The diagram view to convert.
- * @param opts.currentViewId - The ID of the current view.
- * @param opts.where - Optional filter for nodes and edges.
- * @returns An object containing an array of XY flow nodes and an array of XY flow edges.
- */
-export declare function diagramToXY(opts: {
-    view: Pick<DiagramView, 'id' | 'nodes' | 'bounds' | 'edges' | '_type' | 'autoLayout'>;
-    currentViewId: ViewId | undefined;
-    where: WhereOperator | null;
-}): {
-    xynodes: Types.Node[];
-    xyedges: Types.Edge[];
-};