@likec4/diagram 1.59.3 → 1.60.0

package/dist/likec4diagram/useLayoutConstraints.js

@@ -1,412 +0,0 @@
-import "../_virtual/_rolldown/runtime.js";
-import { useXYStoreApi } from "../hooks/useXYFlow.js";
-import { 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;
-	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) => {
-				if (controlPoints) draft.data.controlPoints = controlPoints.map(relativePoint);
-				else {
-					draft.data.points = map(edge.data.points, ([x, y]) => {
-						const point = relativePoint({
-							x,
-							y
-						});
-						return [point.x, point.y];
-					});
-					draft.data.controlPoints = controlPoints;
-				}
-				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[];
-};

package/dist/likec4diagram/xyflow-diagram/diagram-view.js

@@ -1,273 +0,0 @@
-import "../../_virtual/_rolldown/runtime.js";
-import { ZIndexes } from "../../base/const.js";
-import { readableText } from "../../utils/readableText.js";
-import { hasAtLeast, pick } from "remeda";
-import { GroupElementKind, Queue, invariant, isStepPath, nonNullable, whereOperatorAsPredicate } from "@likec4/core";
-//#region src/likec4diagram/xyflow-diagram/diagram-view.ts
-function sentence(parts) {
-	return parts.filter((part) => !!part).map((part) => part.endsWith(".") ? part : `${part}.`).join(" ");
-}
-function nodeAriaLabel(node) {
-	const title = readableText(node.title) ?? node.id;
-	const description = readableText(node.description);
-	const notes = readableText(node.notes);
-	if (node.kind === GroupElementKind) {
-		const childCount = node.children.length;
-		return sentence([
-			title,
-			"Group",
-			`Contains ${childCount} ${childCount === 1 ? "node" : "nodes"}`,
-			notes && `Notes: ${notes}`
-		]);
-	}
-	return sentence([
-		title,
-		`Node kind: ${node.kind}`,
-		node.technology && `Technology: ${node.technology}`,
-		description && `Description: ${description}`,
-		notes && `Notes: ${notes}`,
-		node.navigateTo && `Opens view ${node.navigateTo}`
-	]);
-}
-function edgeAriaLabel(edge, source, target) {
-	const sourceTitle = readableText(source.title) ?? source.id;
-	const targetTitle = readableText(target.title) ?? target.id;
-	const label = readableText(edge.label);
-	const description = readableText(edge.description);
-	const notes = readableText(edge.notes);
-	return sentence([
-		`Relationship from ${sourceTitle} to ${targetTitle}`,
-		label && `Label: ${label}`,
-		edge.technology && `Technology: ${edge.technology}`,
-		description && `Description: ${description}`,
-		notes && `Notes: ${notes}`,
-		edge.navigateTo && `Opens view ${edge.navigateTo}`
-	]);
-}
-/**
-* 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.
-*/
-function diagramToXY(opts) {
-	const { view } = opts;
-	const xynodes = [];
-	const xyedges = [];
-	const nodeLookup = /* @__PURE__ */ new Map();
-	const viewLayoutDir = view.autoLayout?.direction ?? "TB";
-	const isDynamic = view._type === "dynamic";
-	const deletable = view._type !== "dynamic";
-	const queue = Queue.from(view.nodes.reduce((acc, node) => {
-		nodeLookup.set(node.id, node);
-		if (!node.parent) acc.push({
-			node,
-			parent: null
-		});
-		return acc;
-	}, []));
-	let visiblePredicate = (_nodeOrEdge) => true;
-	if (opts.where) try {
-		const filterablePredicate = whereOperatorAsPredicate(opts.where);
-		visiblePredicate = (i) => filterablePredicate({
-			...pick(i, ["tags", "kind"]),
-			..."source" in i ? { source: nodeById(i.source) } : i,
-			..."target" in i ? { target: nodeById(i.target) } : i
-		});
-	} catch (e) {
-		console.error("Error in where filter:", e);
-	}
-	const ns = "";
-	const nodeById = (id) => nonNullable(nodeLookup.get(id), `Node not found: ${id}`);
-	let next;
-	while (next = queue.dequeue()) {
-		const { node, parent } = next;
-		const isCompound = hasAtLeast(node.children, 1) || node.kind == GroupElementKind;
-		if (isCompound) for (const child of node.children) queue.enqueue({
-			node: nodeById(child),
-			parent: node
-		});
-		const position = {
-			x: node.x,
-			y: node.y
-		};
-		if (parent) {
-			position.x -= parent.x;
-			position.y -= parent.y;
-		}
-		const base = {
-			id: ns + node.id,
-			deletable,
-			position,
-			zIndex: isCompound ? ZIndexes.Compound : ZIndexes.Element,
-			style: {
-				width: node.width,
-				height: node.height
-			},
-			ariaLabel: nodeAriaLabel(node),
-			initialWidth: node.width,
-			initialHeight: node.height,
-			hidden: node.kind !== GroupElementKind && !visiblePredicate(node),
-			...parent && { parentId: ns + parent.id }
-		};
-		const modelFqn = node.modelRef ?? null;
-		const deploymentFqn = node.deploymentRef ?? null;
-		const navigateTo = { navigateTo: node.navigateTo ?? null };
-		/**
-		* Compound nodes
-		*/
-		if (isCompound) {
-			const compoundData = {
-				viewId: view.id,
-				id: node.id,
-				title: node.title,
-				color: node.color,
-				shape: node.shape,
-				style: node.style,
-				depth: node.depth ?? 0,
-				icon: node.icon ?? "none",
-				tags: node.tags ?? null,
-				x: node.x,
-				y: node.y,
-				drifts: node.drifts ?? null,
-				notes: node.notes,
-				viewLayoutDir
-			};
-			switch (true) {
-				case node.kind === GroupElementKind:
-					xynodes.push({
-						...base,
-						type: "view-group",
-						data: {
-							isViewGroup: true,
-							...compoundData
-						}
-					});
-					break;
-				case !!deploymentFqn:
-					xynodes.push({
-						...base,
-						type: "compound-deployment",
-						data: {
-							...compoundData,
-							...navigateTo,
-							deploymentFqn,
-							modelFqn
-						}
-					});
-					break;
-				default:
-					invariant(!!modelFqn, "ModelRef expected");
-					xynodes.push({
-						...base,
-						type: "compound-element",
-						data: {
-							...compoundData,
-							...navigateTo,
-							modelFqn
-						}
-					});
-			}
-			continue;
-		}
-		if (!modelFqn && !deploymentFqn) {
-			console.error("Invalid node", node);
-			throw new Error("Element should have either modelRef or deploymentRef");
-		}
-		const leafNodeData = {
-			viewId: view.id,
-			id: node.id,
-			title: node.title,
-			technology: node.technology ?? null,
-			description: node.description ?? null,
-			height: node.height,
-			width: node.width,
-			level: node.level,
-			color: node.color,
-			shape: node.shape,
-			style: node.style,
-			icon: node.icon ?? null,
-			tags: node.tags,
-			notes: node.notes,
-			x: node.x,
-			y: node.y,
-			isMultiple: node.style?.multiple ?? false,
-			drifts: node.drifts ?? null,
-			viewLayoutDir
-		};
-		switch (true) {
-			case !!deploymentFqn:
-				xynodes.push({
-					...base,
-					type: "deployment",
-					data: {
-						...leafNodeData,
-						...navigateTo,
-						deploymentFqn,
-						modelFqn
-					}
-				});
-				break;
-			default:
-				invariant(!!modelFqn, "ModelRef expected");
-				xynodes.push({
-					...base,
-					type: "element",
-					data: {
-						...leafNodeData,
-						...navigateTo,
-						modelFqn
-					}
-				});
-		}
-	}
-	let stepnum = 1;
-	for (const edge of view.edges) {
-		const source = edge.source;
-		const target = edge.target;
-		const id = ns + edge.id;
-		if (!hasAtLeast(edge.points, 2)) {
-			console.error("edge should have at least 2 points", edge);
-			continue;
-		}
-		xyedges.push({
-			id,
-			type: "relationship",
-			source: ns + source,
-			target: ns + target,
-			ariaLabel: edgeAriaLabel(edge, nodeById(source), nodeById(target)),
-			zIndex: ZIndexes.Edge,
-			hidden: !visiblePredicate(edge),
-			deletable,
-			data: {
-				id: edge.id,
-				label: edge.label,
-				technology: edge.technology,
-				notes: edge.notes ?? null,
-				navigateTo: edge.navigateTo,
-				controlPoints: edge.controlPoints ?? null,
-				labelBBox: edge.labelBBox ?? null,
-				isLabelCustomized: edge.isLabelCustomized ?? false,
-				labelXY: null,
-				points: edge.points,
-				color: edge.color ?? "gray",
-				line: edge.line ?? "dashed",
-				dir: edge.dir ?? "forward",
-				head: edge.head ?? "normal",
-				tail: edge.tail ?? "none",
-				astPath: edge.astPath,
-				drifts: edge.drifts ?? null,
-				...isDynamic && isStepPath(edge.id) && { stepnum: stepnum++ }
-			},
-			interactionWidth: 20
-		});
-	}
-	return {
-		xynodes,
-		xyedges
-	};
-}
-//#endregion
-export { diagramToXY };