@likec4/diagram 1.59.4 → 1.61.0

package/dist/utils/defineActors.d.mts

@@ -0,0 +1,8 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { ActorRefFromLogic, AnyActorLogic } from "xstate";
+export type inferChildrenRef<A> = A extends Record<string, AnyActorLogic> ? { [K in keyof A & string]: ActorRefFromLogic<A[K]> | undefined; } : never;
+export type inferProvidedActor<A> = A extends Record<string, AnyActorLogic> ? { [K in keyof A & string]: {
+  id: K;
+  logic: A[K];
+  src: K;
+}; }[keyof A & string] : never;

package/dist/utils/defineActors.mjs

@@ -0,0 +1,14 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+
+// src/utils/defineActors.ts
+/**
+* Helper function to define actors for use to mimize type inference issues
+* with XState ActorSystem
+*
+* @see {@link ../editor/actor/setup.ts}
+*/
+function defineActors(actors) {
+	return actors;
+}
+
+export { defineActors };

package/dist/utils/edge-corners.mjs

@@ -0,0 +1,125 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { inDrawingOrder, orthoPolyline } from "./edge-path.mjs";
+import { bezierControlPoints } from "./xyflow.mjs";
+import { isOrthoSpline, nearlyEqual, projectOnSegment, splineToPolyline } from "@likec4/core/geometry";
+
+// src/utils/edge-corners.ts
+/** Interior corners of an orthogonal Graphviz spline. */
+function orthoCorners(points) {
+	const anchors = splineToPolyline(points).map((p) => ({
+		x: Math.trunc(p.x),
+		y: Math.trunc(p.y)
+	}));
+	const corners = [];
+	for (let i = 1; i < anchors.length - 1; i++) {
+		const a = anchors[i - 1];
+		const b = anchors[i];
+		const c = anchors[i + 1];
+		if (!(nearlyEqual(a.y, b.y) && nearlyEqual(b.y, c.y) || nearlyEqual(a.x, b.x) && nearlyEqual(b.x, c.x))) corners.push(b);
+	}
+	return corners;
+}
+/**
+* Editing handles from the layout points: the corners of an orthogonal route (its midpoint when
+* straight), otherwise handles derived from the curve.
+*/
+function initialControlPoints(points, routing) {
+	if (routing !== "ortho" || !isOrthoSpline(points)) return bezierControlPoints(points);
+	const corners = orthoCorners(points);
+	if (corners.length > 0) return corners;
+	const [ax, ay] = points[0];
+	const [bx, by] = points[points.length - 1];
+	return [{
+		x: Math.trunc((ax + bx) / 2),
+		y: Math.trunc((ay + by) / 2)
+	}];
+}
+const SNAP_TOLERANCE = 8;
+/**
+* Snaps a dragged corner to the axes of its neighbours, or the node centers at the ends, within
+* `SNAP_TOLERANCE`. Returns the point unchanged for splines.
+*/
+function snapCorner({ index, point, controlPoints, routing, ...edge }) {
+	if (routing !== "ortho") return point;
+	const [from, to] = inDrawingOrder(edge);
+	const prev = controlPoints[index - 1] ?? from;
+	const next = controlPoints[index + 1] ?? to;
+	const snap = (value, candidates) => {
+		let best = value;
+		let bestDistance = 9;
+		for (const raw of candidates) {
+			const candidate = Math.trunc(raw);
+			const distance = Math.abs(candidate - value);
+			if (distance <= SNAP_TOLERANCE && distance < bestDistance) {
+				best = candidate;
+				bestDistance = distance;
+			}
+		}
+		return best;
+	};
+	return {
+		x: snap(point.x, [prev.x, next.x]),
+		y: snap(point.y, [prev.y, next.y])
+	};
+}
+/**
+* Inserts a corner at the clicked point: projected onto the nearest drawn segment for ortho routing,
+* or the rounded point for splines.
+*/
+function insertCorner({ point, controlPoints, routing, ...edge }) {
+	const [from, to] = inDrawingOrder(edge);
+	const result = [...controlPoints];
+	if (routing === "ortho") {
+		const { points, insertAt } = orthoPolyline(controlPoints, from, to);
+		let best = {
+			index: 0,
+			point,
+			distance: Infinity
+		};
+		for (let i = 1; i < points.length; i++) {
+			const candidate = projectOnSegment(point, points[i - 1], points[i]);
+			if (candidate.distance < best.distance) best = {
+				index: insertAt[i],
+				point: candidate.point,
+				distance: candidate.distance
+			};
+		}
+		result.splice(best.index, 0, {
+			x: Math.round(best.point.x),
+			y: Math.round(best.point.y)
+		});
+		return result;
+	}
+	const anchors = [
+		from,
+		...controlPoints,
+		to
+	];
+	const newPoint = {
+		x: Math.round(point.x),
+		y: Math.round(point.y)
+	};
+	let insertionIndex = 0;
+	let minDistance = Infinity;
+	for (let i = 0; i < anchors.length - 1; i++) {
+		const a = anchors[i];
+		const b = anchors[i + 1];
+		const abx = b.x - a.x;
+		const aby = b.y - a.y;
+		const apx = newPoint.x - a.x;
+		const apy = newPoint.y - a.y;
+		const bpx = newPoint.x - b.x;
+		const bpy = newPoint.y - b.y;
+		if ((abx * apx + aby * apy) * (abx * bpx + aby * bpy) < 0) {
+			const distanceToEdge = Math.abs(abx * apy - aby * apx) / Math.hypot(abx, aby);
+			if (distanceToEdge < minDistance) {
+				minDistance = distanceToEdge;
+				insertionIndex = i;
+			}
+		}
+	}
+	result.splice(insertionIndex, 0, newPoint);
+	return result;
+}
+
+export { initialControlPoints, insertCorner, snapCorner };

package/dist/utils/edge-endpoints.mjs

@@ -0,0 +1,41 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { nodeToRect } from "./xyflow.mjs";
+
+// src/utils/edge-endpoints.ts
+/**
+* Returns an edge endpoint from the node's actual bounds and handle center.
+* Falls back to the node center when handle bounds are unavailable.
+*/
+function edgeEndFromNode(node, handle) {
+	if (!node) return null;
+	const rect = nodeToRect(node);
+	const bounds = node.internals.handleBounds?.[handle]?.[0];
+	return {
+		center: bounds ? {
+			x: Math.trunc(rect.x + bounds.x + bounds.width / 2),
+			y: Math.trunc(rect.y + bounds.y + bounds.height / 2)
+		} : {
+			x: Math.trunc(rect.x + rect.width / 2),
+			y: Math.trunc(rect.y + rect.height / 2)
+		},
+		node: rect
+	};
+}
+/**
+* Handle centers of both edge nodes, which is where the route is drawn from.
+* Falls back to the positions XYFlow passes to the edge when a node is missing.
+*/
+function edgeEndCenters(nodeLookup, edge) {
+	return {
+		source: edgeEndFromNode(nodeLookup.get(edge.source), "source")?.center ?? {
+			x: edge.sourceX,
+			y: edge.sourceY
+		},
+		target: edgeEndFromNode(nodeLookup.get(edge.target), "target")?.center ?? {
+			x: edge.targetX,
+			y: edge.targetY
+		}
+	};
+}
+
+export { edgeEndCenters, edgeEndFromNode };

package/dist/utils/edge-label.mjs

@@ -0,0 +1,40 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { firstBy } from "remeda";
+import { distanceBetween, placeLabelAlongSegments } from "@likec4/core/geometry";
+
+// src/utils/edge-label.ts
+/**
+* Top-left position of the label of an edge being edited: centered at half the path length for
+* splines; beside a straight run for ortho routing, avoiding obstacles unless the label is customized,
+* in which case the caller adds the saved offset to the returned base position.
+*/
+function edgeLabelPosition({ path, segments, routing, size, obstacles, routes = [], customized = false }) {
+	if (routing === "ortho" && segments.length > 0) {
+		if (!customized) {
+			const { x, y } = placeLabelAlongSegments({
+				segments,
+				size,
+				obstacles,
+				routes
+			});
+			return {
+				x,
+				y
+			};
+		}
+		const [a, b] = firstBy(segments, [(s) => distanceBetween(s[0], s[1]), "desc"]);
+		return centredAt({
+			x: (a.x + b.x) / 2,
+			y: (a.y + b.y) / 2
+		}, size);
+	}
+	return centredAt(path.getPointAtLength(path.getTotalLength() * .5), size);
+}
+function centredAt(point, size) {
+	return {
+		x: Math.round(point.x - size.width / 2),
+		y: Math.round(point.y - size.height / 2)
+	};
+}
+
+export { edgeLabelPosition };

package/dist/utils/edge-path-through-label.mjs

@@ -0,0 +1,51 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { Position, getBezierPath } from "@xyflow/system";
+
+// src/utils/edge-path-through-label.ts
+/**
+* Returns the bezier edge path through the label placed by the layout (left to right):
+* a curve to the left side of the label and a curve from its right side to the target,
+* with a gap under the label, so the line does not show through the label background.
+*
+* Without label box, it is a single bezier curve with the label in the middle.
+*/
+function edgePathThroughLabel(params, labelBBox) {
+	if (!labelBBox) {
+		const [path, x, y] = getBezierPath({
+			sourceX: params.sourceX,
+			sourceY: params.sourceY,
+			sourcePosition: params.sourcePosition,
+			targetX: params.targetX,
+			targetY: params.targetY,
+			targetPosition: params.targetPosition
+		});
+		return [path, {
+			x,
+			y,
+			translate: "translate(-50%, 0)"
+		}];
+	}
+	const y = labelBBox.y + labelBBox.height / 2;
+	const [toLabel] = getBezierPath({
+		sourceX: params.sourceX,
+		sourceY: params.sourceY,
+		sourcePosition: params.sourcePosition,
+		targetX: labelBBox.x,
+		targetY: y,
+		targetPosition: Position.Left
+	});
+	const [fromLabel] = getBezierPath({
+		sourceX: labelBBox.x + labelBBox.width,
+		sourceY: y,
+		sourcePosition: Position.Right,
+		targetX: params.targetX,
+		targetY: params.targetY,
+		targetPosition: params.targetPosition
+	});
+	return [`${toLabel} ${fromLabel}`, {
+		x: labelBBox.x,
+		y: labelBBox.y
+	}];
+}
+
+export { edgePathThroughLabel };

package/dist/utils/edge-path.mjs

@@ -0,0 +1,245 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { bezierControlPoints, bezierPath, getNodeIntersectionFromCenterToPoint, isEqualRects } from "./xyflow.mjs";
+import { first, last } from "remeda";
+import { continuesRun, distanceBetween, isOrthoSpline, nearlyEqual, polylineToSegments, splineToPolyline } from "@likec4/core/geometry";
+import { nonNullable } from "@likec4/core/utils";
+import { curveCatmullRomOpen, line } from "d3-shape";
+
+// src/utils/edge-path.ts
+/** Endpoints in drawing order, reversed for `dir: 'back'`. */
+function inDrawingOrder({ source, target, dir }) {
+	return dir === "back" ? [target, source] : [source, target];
+}
+const NODE_MARGIN = 6;
+const catmullRom = line().curve(curveCatmullRomOpen.alpha(.7)).x((d) => Math.trunc(d.x)).y((d) => Math.trunc(d.y));
+const ORTHO_NODE_MARGIN = 2;
+const ORTHO_CORNER_RADIUS = 8;
+const MIN_ROUNDED_RADIUS = 1;
+/**
+* Collects straight segments, merging collinear pieces only when they share the same endpoint object,
+* so a rounded corner, which starts the next piece at a new point, splits them.
+*/
+function segmentCollector() {
+	const segments = [];
+	return {
+		segments,
+		add(from, to) {
+			const previous = segments.at(-1);
+			if (previous && previous[1] === from && continuesRun(previous, from, to)) previous[1] = to;
+			else segments.push([from, to]);
+		}
+	};
+}
+function inside(p, r, margin) {
+	return p.x >= r.x - margin && p.x <= r.x + r.width + margin && p.y >= r.y - margin && p.y <= r.y + r.height + margin;
+}
+/** Drops leading points inside the node and moves the first point onto its border. */
+function clipStart(points, node, margin) {
+	while (points.length > 2 && inside(points[1], node, margin)) points.shift();
+	const p0 = points[0];
+	const p1 = points[1];
+	if (!p1 || !inside(p0, node, margin)) return;
+	switch (true) {
+		case nearlyEqual(p0.y, p1.y):
+			points[0] = {
+				x: p1.x > p0.x ? node.x + node.width + margin : node.x - margin,
+				y: p0.y
+			};
+			break;
+		case nearlyEqual(p0.x, p1.x): points[0] = {
+			x: p0.x,
+			y: p1.y > p0.y ? node.y + node.height + margin : node.y - margin
+		};
+	}
+}
+/**
+* Draws the polyline with rounded corners; a corner stays sharp when the radius would be below
+* `MIN_ROUNDED_RADIUS` or the path reverses.
+*/
+function roundedPath(points, radius) {
+	if (points.length < 2) return {
+		d: "",
+		segments: []
+	};
+	const { add, segments } = segmentCollector();
+	let start = points[0];
+	let d = `M ${start.x},${start.y}`;
+	for (let i = 1; i < points.length - 1; i++) {
+		const prev = points[i - 1];
+		const corner = points[i];
+		const next = points[i + 1];
+		const din = distanceBetween(prev, corner);
+		const dout = distanceBetween(corner, next);
+		const r = Math.min(radius, din / 2, dout / 2);
+		const reverses = (prev.x - corner.x) * (next.x - corner.x) + (prev.y - corner.y) * (next.y - corner.y) > 0;
+		if (r < MIN_ROUNDED_RADIUS || reverses) {
+			d += ` L ${corner.x},${corner.y}`;
+			add(start, corner);
+			start = corner;
+			continue;
+		}
+		const a = {
+			x: Math.round(corner.x + (prev.x - corner.x) / din * r),
+			y: Math.round(corner.y + (prev.y - corner.y) / din * r)
+		};
+		const b = {
+			x: Math.round(corner.x + (next.x - corner.x) / dout * r),
+			y: Math.round(corner.y + (next.y - corner.y) / dout * r)
+		};
+		d += ` L ${a.x},${a.y} Q ${corner.x},${corner.y} ${b.x},${b.y}`;
+		add(start, a);
+		start = b;
+	}
+	const end = points.at(-1);
+	add(start, end);
+	return {
+		d: d + ` L ${end.x},${end.y}`,
+		segments
+	};
+}
+/**
+* Orthogonal polyline through the anchors, before clipping at the nodes. Between anchors that don't
+* share an axis it inserts a bend, continuing the incoming axis unless that would double back.
+* `insertAt[i]` is the control point index to insert at for the segment ending at `points[i]`.
+*/
+function orthoPolyline(anchors, from, to) {
+	const points = [{
+		x: Math.trunc(from.x),
+		y: Math.trunc(from.y)
+	}];
+	const insertAt = [0];
+	let direction = null;
+	const push = (q, index) => {
+		const p = points.at(-1);
+		if (nearlyEqual(p.x, q.x) && nearlyEqual(p.y, q.y)) return;
+		if (nearlyEqual(p.x, q.x) || nearlyEqual(p.y, q.y)) {
+			direction = nearlyEqual(p.y, q.y) ? "h" : "v";
+			points.push(q);
+			insertAt.push(index);
+			return;
+		}
+		const prev = points.at(-2);
+		let horizontalFirst;
+		if (!direction || !prev) horizontalFirst = Math.abs(q.x - p.x) >= Math.abs(q.y - p.y);
+		else horizontalFirst = (direction === "h" ? Math.sign(q.x - p.x) !== Math.sign(p.x - prev.x) : Math.sign(q.y - p.y) !== Math.sign(p.y - prev.y)) ? direction !== "h" : direction === "h";
+		points.push(horizontalFirst ? {
+			x: q.x,
+			y: p.y
+		} : {
+			x: p.x,
+			y: q.y
+		});
+		insertAt.push(index);
+		direction = horizontalFirst ? "v" : "h";
+		points.push(q);
+		insertAt.push(index);
+	};
+	anchors.forEach((a, index) => push({
+		x: Math.trunc(a.x),
+		y: Math.trunc(a.y)
+	}, index));
+	push({
+		x: Math.trunc(to.x),
+		y: Math.trunc(to.y)
+	}, anchors.length);
+	return {
+		points,
+		insertAt
+	};
+}
+function orthoRoute(anchors, from, to) {
+	const { points } = orthoPolyline(anchors, from.center, to.center);
+	clipStart(points, from.node, ORTHO_NODE_MARGIN);
+	points.reverse();
+	clipStart(points, to.node, ORTHO_NODE_MARGIN);
+	points.reverse();
+	return points;
+}
+function drawnFromRoute(points) {
+	return roundedPath(points, ORTHO_CORNER_RADIUS);
+}
+function orthoPath(anchors, from, to) {
+	return drawnFromRoute(orthoRoute(anchors, from, to));
+}
+function borderPointToward(node, p) {
+	return {
+		x: Math.trunc(Math.max(node.x, Math.min(node.x + node.width, p.x))),
+		y: Math.trunc(Math.max(node.y, Math.min(node.y + node.height, p.y)))
+	};
+}
+const SELF_LOOP_SIZE = 80;
+/**
+* Self-loop through the corners, or a default loop above the node; the endpoints are the node
+* border points nearest the first and last corner.
+*/
+function orthoSelfLoopPath(controlPoints, node) {
+	const corners = controlPoints.length > 0 ? controlPoints : [{
+		x: node.x + node.width / 2 - SELF_LOOP_SIZE / 2.5,
+		y: node.y - SELF_LOOP_SIZE
+	}, {
+		x: node.x + node.width / 2 + SELF_LOOP_SIZE / 2.5,
+		y: node.y - SELF_LOOP_SIZE
+	}];
+	const { points } = orthoPolyline(corners, borderPointToward(node, first(corners)), borderPointToward(node, last(corners)));
+	return roundedPath(points, ORTHO_CORNER_RADIUS);
+}
+/** Route of an edited edge with its endpoint bounds in drawing order, or `null` for a self-loop. */
+function editedEdgeRoute({ controlPoints, ...edge }) {
+	const [from, to] = inDrawingOrder(edge);
+	if (isEqualRects(from.node, to.node)) return null;
+	return {
+		points: orthoRoute(controlPoints, from, to),
+		bounds: {
+			from: from.node,
+			to: to.node
+		}
+	};
+}
+/**
+* Polyline of an unedited edge: the Graphviz corners, or a route through the spline handles when
+* the saved geometry is curved.
+*/
+function layoutedEdgeRoute({ points, ...edge }) {
+	if (isOrthoSpline(points)) return splineToPolyline(points);
+	const [from, to] = inDrawingOrder(edge);
+	return orthoRoute(bezierControlPoints(points), from, to);
+}
+/**
+* Path through the editing handles, clipped at the node borders: orthogonal with straight segments,
+* or a curve without segments.
+*/
+function editedEdgePath({ controlPoints, routing, ...edge }) {
+	const [from, to] = inDrawingOrder(edge);
+	if (routing === "ortho") return isEqualRects(from.node, to.node) ? orthoSelfLoopPath(controlPoints, from.node) : orthoPath(controlPoints, from, to);
+	const points = [
+		from.center,
+		getNodeIntersectionFromCenterToPoint(from.node, first(controlPoints) ?? to.center, NODE_MARGIN),
+		...controlPoints,
+		getNodeIntersectionFromCenterToPoint(to.node, last(controlPoints) ?? from.center, NODE_MARGIN),
+		to.center
+	];
+	return {
+		d: nonNullable(catmullRom(points)),
+		segments: []
+	};
+}
+/**
+* Path of an unedited edge: the Graphviz spline as is, or re-routed orthogonally when a curved
+* layout is shown with ortho routing.
+*/
+function layoutedEdgePath({ points, routing, ...edge }) {
+	if (routing !== "ortho") return {
+		d: bezierPath(points),
+		segments: []
+	};
+	if (!isOrthoSpline(points)) {
+		const [from, to] = inDrawingOrder(edge);
+		return orthoPath(bezierControlPoints(points), from, to);
+	}
+	return {
+		d: bezierPath(points),
+		segments: polylineToSegments(splineToPolyline(points))
+	};
+}
+
+export { drawnFromRoute, editedEdgePath, editedEdgeRoute, inDrawingOrder, layoutedEdgePath, layoutedEdgeRoute, orthoPolyline };

package/dist/utils/edge-tracks.mjs

@@ -0,0 +1,140 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { drawnFromRoute, editedEdgePath, editedEdgeRoute } from "./edge-path.mjs";
+import { nearlyEqual } from "@likec4/core/geometry";
+
+// src/utils/edge-tracks.ts
+const TRACK_SPACING = 12;
+const END_INSET = 8;
+const SAME_TRACK = 4;
+/** Straight runs, merging collinear pieces so each run shifts as a whole. */
+function runsOf(points) {
+	const runs = [];
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		let axis;
+		switch (true) {
+			case nearlyEqual(a.y, b.y) && !nearlyEqual(a.x, b.x):
+				axis = "h";
+				break;
+			case nearlyEqual(a.x, b.x) && !nearlyEqual(a.y, b.y):
+				axis = "v";
+				break;
+			default: continue;
+		}
+		const at = axis === "h" ? a.y : a.x;
+		const [lo, hi] = axis === "h" ? [Math.min(a.x, b.x), Math.max(a.x, b.x)] : [Math.min(a.y, b.y), Math.max(a.y, b.y)];
+		const previous = runs.at(-1);
+		if (previous?.axis === axis && previous.indices.at(-1) === i - 1 && nearlyEqual(previous.at, at)) {
+			previous.lo = Math.min(previous.lo, lo);
+			previous.hi = Math.max(previous.hi, hi);
+			previous.indices.push(i);
+		} else runs.push({
+			axis,
+			at,
+			lo,
+			hi,
+			indices: [i - 1, i]
+		});
+	}
+	return runs;
+}
+function shareTrack(a, b) {
+	return a.axis === b.axis && Math.abs(a.at - b.at) <= SAME_TRACK && Math.min(a.hi, b.hi) - Math.max(a.lo, b.lo) > 1;
+}
+/** Track offsets for the movable routes of a group, in stable id order. */
+function offsetsOf(members) {
+	const offsets = /* @__PURE__ */ new Map();
+	const movable = members.filter((m) => m.movable).map((m) => m.id).sort();
+	const fixed = members.some((m) => !m.movable);
+	movable.forEach((id, k) => {
+		offsets.set(id, trackSlot(k, movable.length, fixed) * TRACK_SPACING);
+	});
+	return offsets;
+}
+/** Slot of the k-th movable route: alternating around a fixed route, otherwise centered on the original track. */
+function trackSlot(k, count, aroundFixed) {
+	if (!aroundFixed) return k - (count - 1) / 2;
+	return k % 2 === 0 ? k / 2 + 1 : -(k + 1) / 2;
+}
+/** Routes sharing a track with this run, following transitive overlaps so every route computes the same group. */
+function trackMembers(own, others) {
+	const members = /* @__PURE__ */ new Map([[own.id, true]]);
+	const queue = [own.run];
+	const seen = /* @__PURE__ */ new Set([own.run]);
+	while (queue.length > 0) {
+		const run = queue.shift();
+		for (const other of others) for (const candidate of other.runs) if (!seen.has(candidate) && shareTrack(run, candidate)) {
+			seen.add(candidate);
+			queue.push(candidate);
+			members.set(other.id, other.movable);
+		}
+	}
+	return [...members].map(([id, movable]) => ({
+		id,
+		movable
+	}));
+}
+function clampToSide(offset, run, end, box) {
+	const [value, lo, hi] = run.axis === "h" ? [
+		end.y,
+		box.y + END_INSET,
+		box.y + box.height - END_INSET
+	] : [
+		end.x,
+		box.x + END_INSET,
+		box.x + box.width - END_INSET
+	];
+	return Math.max(lo - value, Math.min(hi - value, offset));
+}
+/**
+* Shifts the route's runs that share a track with other edges, each run as a whole and perpendicular
+* to its axis. The first and last run are limited to the node side, so endpoints can end up closer
+* than `TRACK_SPACING`. Unedited routes never move.
+*/
+function keepOwnTrack(route, others) {
+	if (!route.movable || route.points.length < 2) return [...route.points];
+	const runs = runsOf(route.points);
+	const otherRuns = others.filter((o) => o.id !== route.id).map((o) => ({
+		id: o.id,
+		movable: o.movable,
+		runs: runsOf(o.points)
+	}));
+	const dx = [];
+	const dy = [];
+	for (const run of runs) {
+		const members = trackMembers({
+			id: route.id,
+			run
+		}, otherRuns);
+		if (members.length < 2) continue;
+		let offset = offsetsOf(members).get(route.id) ?? 0;
+		if (run === runs[0]) offset = clampToSide(offset, run, route.points[0], route.bounds.from);
+		if (run === runs.at(-1)) offset = clampToSide(offset, run, route.points.at(-1), route.bounds.to);
+		for (const i of run.indices) if (run.axis === "h") dy[i] = offset;
+		else dx[i] = offset;
+	}
+	return route.points.map((p, i) => ({
+		x: p.x + (dx[i] ?? 0),
+		y: p.y + (dy[i] ?? 0)
+	}));
+}
+/** Path of an edited edge with track separation applied; self-loops and splines use the plain path. */
+function trackedEdgePath({ id, controlPoints, routing, others, ...endpoints }) {
+	const route = routing === "ortho" ? editedEdgeRoute({
+		...endpoints,
+		controlPoints
+	}) : null;
+	if (!route) return editedEdgePath({
+		...endpoints,
+		controlPoints,
+		routing
+	});
+	return drawnFromRoute(keepOwnTrack({
+		id,
+		movable: true,
+		...route
+	}, [...others]));
+}
+
+export { keepOwnTrack, trackedEdgePath };

package/dist/utils/filterProjects.d.mts

@@ -0,0 +1,10 @@
+import { __name } from "../_virtual/_rolldown/runtime.mjs";
+import { LikeC4ProjectData } from "../LikeC4ProjectsProvider.mjs";
+/**
+ * Keeps the projects whose id, title or path match every term of the query.
+ */
+export declare function filterProjects<P extends Pick<LikeC4ProjectData, 'id' | 'title' | 'path'>>(projects: ReadonlyArray<P>, query: string): ReadonlyArray<P>;
+/**
+ * Literal fragments of the query, to highlight in the matching projects.
+ */
+export declare function projectSearchHighlights(query: string): string[];