@kekonic/diagrams-routing 1.0.0-rc.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kekonic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,24 @@
+# @kekonic/diagrams-routing
+
+Post-ELK edge finishing for KDiagram: crossing treatment, endpoint trim, and label placement types.
+
+## Scope
+
+- Crossing modes: `none` / `gaps` / `jumps` / `smart`
+- Arrowhead / crow's-foot endpoint insets
+- Shared `RoutedEdge` / `TreatedEdge` / `EdgeLabelPlacement` types
+
+Orthogonal corridors normally come from ELK (or region-arrange stubs). This package does **not** search routes.
+
+## Install
+
+```bash
+pnpm add @kekonic/diagrams-routing
+```
+
+Prefer the meta package `@kekonic/diagrams` for the full pipeline.
+
+## Related
+
+- Layout: `@kekonic/diagrams-layout`
+- Pipeline boundaries: [`docs/architecture/pipeline.md`](../../docs/architecture/pipeline.md)

package/dist/index.d.mts

@@ -0,0 +1,75 @@
+import { PerimeterAttachInput, attachPointOnPerimeter } from "@kekonic/diagrams-geometry";
+import { CrossingMode, Diagnostic, Point, Rect } from "@kekonic/diagrams-core";
+
+//#region src/routing/types.d.ts
+type RoutedEdge = {
+  edgeId: string;
+  points: Point[];
+  segments: Array<{
+    from: Point;
+    to: Point;
+  }>;
+};
+/** Post-ELK edge geometry after label placement and endpoint trim. */
+type RoutingResult = {
+  edges: RoutedEdge[];
+  algorithmVersion: string;
+  routeMs: number;
+  diagnostics: Diagnostic[];
+};
+//#endregion
+//#region src/crossings/treat.d.ts
+/** Target trim: tip lands just shy of the node stroke; dash/solid stop at the arrow base. */
+declare const ARROW_ENDPOINT_INSET: number;
+/**
+ * Crow's-foot tip sits on the path endpoint (marker refX), unlike arrows whose tip
+ * overhangs past refX. Keep only a hairline gap so the tip kisses the table stroke.
+ */
+declare const CARDINALITY_ENDPOINT_INSET = 1.5;
+/** Small inset for edges without arrowheads — clears node stroke at connection. */
+declare const EDGE_ENDPOINT_INSET = 1;
+type RenderedEdgeSegment = {
+  type: "line";
+  from: Point;
+  to: Point;
+} | {
+  type: "gap";
+  from: Point;
+  to: Point;
+} | {
+  type: "jump";
+  from: Point;
+  to: Point;
+  radius: number;
+};
+type TreatedEdge = {
+  edgeId: string;
+  segments: RenderedEdgeSegment[];
+};
+declare function applyCrossingTreatment(edges: RoutedEdge[], mode: CrossingMode): TreatedEdge[];
+/** Crossing points between distinct edge segments (for label scoring). */
+declare function detectCrossingPoints(edges: RoutedEdge[]): Point[];
+type TrimEdgeEndpointsOptions = {
+  /** Uniform source inset, or per-edge via callback. */sourceInset?: number | ((edgeId: string) => number); /** Uniform target inset, or per-edge via callback. */
+  targetInset?: number | ((edgeId: string) => number);
+};
+/** Shorten first/last line segments so strokes and arrowheads stop before node fills. */
+declare function trimEdgeEndpoints(edges: TreatedEdge[], options?: TrimEdgeEndpointsOptions): TreatedEdge[];
+//#endregion
+//#region src/labels/types.d.ts
+/** Edge label bounds produced by ELK and painted by the SVG renderer. */
+type EdgeLabelPlacement = {
+  edgeId: string;
+  text: string;
+  bounds: Rect;
+  anchor: Point;
+};
+/** Icon size inside an edge-label pill (logical units). Keep in sync with SVG paint. */
+declare const EDGE_LABEL_ICON = 12;
+/** Gap between edge-label icon and text. */
+declare const EDGE_LABEL_ICON_GAP = 4;
+/** Horizontal padding inside the edge-label pill. */
+declare const EDGE_LABEL_PAD_X = 8;
+//#endregion
+export { ARROW_ENDPOINT_INSET, CARDINALITY_ENDPOINT_INSET, EDGE_ENDPOINT_INSET, EDGE_LABEL_ICON, EDGE_LABEL_ICON_GAP, EDGE_LABEL_PAD_X, type EdgeLabelPlacement, type PerimeterAttachInput, type RenderedEdgeSegment, type RoutedEdge, type RoutingResult, type TreatedEdge, applyCrossingTreatment, attachPointOnPerimeter, detectCrossingPoints, trimEdgeEndpoints };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,288 @@
+import { attachPointOnPerimeter } from "@kekonic/diagrams-geometry";
+/**
+* How far to pull the path endpoint back from the node border.
+* Path end = arrow base; tip overhangs to (approximately) the attach point.
+*/
+const ARROW_NODE_GAP = 1.5;
+/** Target trim: tip lands just shy of the node stroke; dash/solid stop at the arrow base. */
+const ARROW_ENDPOINT_INSET = 9;
+/**
+* Crow's-foot tip sits on the path endpoint (marker refX), unlike arrows whose tip
+* overhangs past refX. Keep only a hairline gap so the tip kisses the table stroke.
+*/
+const CARDINALITY_ENDPOINT_INSET = ARROW_NODE_GAP;
+/** Small inset for edges without arrowheads — clears node stroke at connection. */
+const EDGE_ENDPOINT_INSET = 1;
+/** Ignore crossings this close to a segment end — gaps there orphan markers on stubs. */
+const CROSSING_ENDPOINT_CLEARANCE = 28;
+/** Crossings within this distance form a dense cluster (prefer gaps in smart mode). */
+const SMART_CLUSTER_PX = 48;
+/** Prefer gaps when a crossing sits this close to a polyline bend. */
+const SMART_CORNER_CLEARANCE = 24;
+function dist(a, b) {
+	return Math.hypot(a.x - b.x, a.y - b.y);
+}
+/** Mark crossings that sit in a dense local cluster (≥2 within SMART_CLUSTER_PX). */
+function denseCrossingIndexes(crossings) {
+	const dense = /* @__PURE__ */ new Set();
+	for (let i = 0; i < crossings.length; i++) {
+		let neighbors = 0;
+		for (let j = 0; j < crossings.length; j++) {
+			if (i === j) continue;
+			if (dist(crossings[i].point, crossings[j].point) <= SMART_CLUSTER_PX) neighbors++;
+		}
+		if (neighbors >= 1) dense.add(i);
+	}
+	return dense;
+}
+function nearPolylineCorner(edges, edgeId, point) {
+	const edge = edges.find((e) => e.edgeId === edgeId);
+	if (!edge || edge.points.length < 3) return false;
+	for (let i = 1; i < edge.points.length - 1; i++) if (dist(edge.points[i], point) <= SMART_CORNER_CLEARANCE) return true;
+	return false;
+}
+/**
+* Decide gap vs jump for smart mode (§14.3):
+* - isolated orthogonal crossings → jumps
+* - dense clusters → gaps
+* - crossings near corners → gaps (jumps look noisy on bends)
+*/
+function smartUsesJump(crossing, index, dense, edges) {
+	if (dense.has(index)) return false;
+	if (nearPolylineCorner(edges, crossing.hop.edgeId, crossing.point)) return false;
+	if (nearPolylineCorner(edges, crossing.under.edgeId, crossing.point)) return false;
+	return true;
+}
+function applyCrossingTreatment(edges, mode) {
+	if (mode === "none") return edges.map((e) => ({
+		edgeId: e.edgeId,
+		segments: e.segments.map((s) => ({
+			type: "line",
+			from: s.from,
+			to: s.to
+		}))
+	}));
+	const allSegments = [];
+	for (const edge of edges) edge.segments.forEach((s, idx) => allSegments.push({
+		edgeId: edge.edgeId,
+		idx,
+		from: s.from,
+		to: s.to
+	}));
+	const crossings = [];
+	for (let i = 0; i < allSegments.length; i++) for (let j = i + 1; j < allSegments.length; j++) {
+		const a = allSegments[i];
+		const b = allSegments[j];
+		if (a.edgeId === b.edgeId) continue;
+		const pt = segmentIntersection(a.from, a.to, b.from, b.to);
+		if (!pt) continue;
+		const hop = Math.abs(a.from.y - a.to.y) <= Math.abs(a.from.x - a.to.x) ? a : b;
+		const under = hop === a ? b : a;
+		crossings.push({
+			hop,
+			under,
+			point: pt
+		});
+	}
+	const dense = mode === "smart" ? denseCrossingIndexes(crossings) : /* @__PURE__ */ new Set();
+	/** Per hop-segment key → list of {point, useJump} */
+	const treatmentsAt = /* @__PURE__ */ new Map();
+	crossings.forEach((c, index) => {
+		const key = `${c.hop.edgeId}:${c.hop.idx}`;
+		if (!treatmentsAt.has(key)) treatmentsAt.set(key, []);
+		const useJump = mode === "jumps" ? true : mode === "gaps" ? false : smartUsesJump(c, index, dense, edges);
+		treatmentsAt.get(key).push({
+			point: c.point,
+			useJump
+		});
+	});
+	const jumpRadius = 10;
+	return edges.map((edge) => {
+		const segments = [];
+		edge.segments.forEach((s, idx) => {
+			const key = `${edge.edgeId}:${idx}`;
+			const points = treatmentsAt.get(key) ?? [];
+			if (!points.length) {
+				segments.push({
+					type: "line",
+					from: s.from,
+					to: s.to
+				});
+				return;
+			}
+			const segLen = Math.hypot(s.to.x - s.from.x, s.to.y - s.from.y) || 1;
+			const sorted = points.map((p) => ({
+				...p,
+				t: paramOnSegment(s.from, s.to, p.point)
+			})).filter((x) => {
+				const fromStart = x.t * segLen;
+				const fromEnd = (1 - x.t) * segLen;
+				return fromStart > CROSSING_ENDPOINT_CLEARANCE && fromEnd > CROSSING_ENDPOINT_CLEARANCE;
+			}).sort((a, b) => a.t - b.t);
+			let prev = s.from;
+			for (const { point: p, useJump } of sorted) {
+				const t = paramOnSegment(s.from, s.to, p);
+				const half = Math.min(.04, Math.max(.015, 8 / (Math.hypot(s.to.x - s.from.x, s.to.y - s.from.y) || 1)));
+				const gapStart = lerp(s.from, s.to, Math.max(0, t - half));
+				const gapEnd = lerp(s.from, s.to, Math.min(1, t + half));
+				segments.push({
+					type: "line",
+					from: prev,
+					to: gapStart
+				});
+				if (useJump) segments.push({
+					type: "jump",
+					from: gapStart,
+					to: gapEnd,
+					radius: jumpRadius
+				});
+				else segments.push({
+					type: "gap",
+					from: gapStart,
+					to: gapEnd
+				});
+				prev = gapEnd;
+			}
+			segments.push({
+				type: "line",
+				from: prev,
+				to: s.to
+			});
+		});
+		return {
+			edgeId: edge.edgeId,
+			segments
+		};
+	});
+}
+function segmentIntersection(a1, a2, b1, b2) {
+	const eps = .75;
+	const aH = Math.abs(a1.y - a2.y) < eps;
+	const aV = Math.abs(a1.x - a2.x) < eps;
+	const bH = Math.abs(b1.y - b2.y) < eps;
+	const bV = Math.abs(b1.x - b2.x) < eps;
+	if (aH && bV) {
+		const y = (a1.y + a2.y) / 2;
+		const x = (b1.x + b2.x) / 2;
+		if (between(x, a1.x, a2.x) && between(y, b1.y, b2.y)) return {
+			x,
+			y
+		};
+		return null;
+	}
+	if (aV && bH) {
+		const x = (a1.x + a2.x) / 2;
+		const y = (b1.y + b2.y) / 2;
+		if (between(y, a1.y, a2.y) && between(x, b1.x, b2.x)) return {
+			x,
+			y
+		};
+		return null;
+	}
+	const d = (a2.x - a1.x) * (b2.y - b1.y) - (a2.y - a1.y) * (b2.x - b1.x);
+	if (Math.abs(d) < 1e-6) return null;
+	const t = ((b1.x - a1.x) * (b2.y - b1.y) - (b1.y - a1.y) * (b2.x - b1.x)) / d;
+	const u = ((b1.x - a1.x) * (a2.y - a1.y) - (b1.y - a1.y) * (a2.x - a1.x)) / d;
+	if (t > .02 && t < .98 && u > .02 && u < .98) return {
+		x: a1.x + t * (a2.x - a1.x),
+		y: a1.y + t * (a2.y - a1.y)
+	};
+	return null;
+}
+/** Crossing points between distinct edge segments (for label scoring). */
+function detectCrossingPoints(edges) {
+	const allSegments = [];
+	for (const edge of edges) for (const s of edge.segments) allSegments.push({
+		edgeId: edge.edgeId,
+		from: s.from,
+		to: s.to
+	});
+	const points = [];
+	for (let i = 0; i < allSegments.length; i++) for (let j = i + 1; j < allSegments.length; j++) {
+		const a = allSegments[i];
+		const b = allSegments[j];
+		if (a.edgeId === b.edgeId) continue;
+		const pt = segmentIntersection(a.from, a.to, b.from, b.to);
+		if (pt) points.push(pt);
+	}
+	return points;
+}
+function between(v, a, b, pad = 1) {
+	const lo = Math.min(a, b) + pad;
+	const hi = Math.max(a, b) - pad;
+	return v > lo && v < hi;
+}
+function paramOnSegment(a, b, p) {
+	const dx = b.x - a.x;
+	const dy = b.y - a.y;
+	const len2 = dx * dx + dy * dy;
+	if (len2 < 1e-6) return 0;
+	return ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+}
+function lerp(a, b, t) {
+	return {
+		x: a.x + (b.x - a.x) * t,
+		y: a.y + (b.y - a.y) * t
+	};
+}
+/** Shorten first/last line segments so strokes and arrowheads stop before node fills. */
+function trimEdgeEndpoints(edges, options = {}) {
+	const sourceInsetOpt = options.sourceInset ?? 1;
+	const targetInsetOpt = options.targetInset ?? 1;
+	return edges.map((edge) => {
+		const sourceInset = typeof sourceInsetOpt === "function" ? sourceInsetOpt(edge.edgeId) : sourceInsetOpt;
+		const targetInset = typeof targetInsetOpt === "function" ? targetInsetOpt(edge.edgeId) : targetInsetOpt;
+		if (sourceInset <= 0 && targetInset <= 0) return edge;
+		const segments = edge.segments.map((s) => s.type === "line" ? {
+			...s,
+			from: { ...s.from },
+			to: { ...s.to }
+		} : s);
+		const firstLine = segments.findIndex((s) => s.type === "line");
+		let lastLine = -1;
+		for (let i = segments.length - 1; i >= 0; i--) if (segments[i].type === "line") {
+			lastLine = i;
+			break;
+		}
+		if (firstLine < 0) return {
+			edgeId: edge.edgeId,
+			segments
+		};
+		if (sourceInset > 0) {
+			const seg = segments[firstLine];
+			if (seg.type === "line") seg.from = insetFromEnd(seg.to, seg.from, sourceInset);
+		}
+		if (targetInset > 0 && lastLine >= 0) {
+			const seg = segments[lastLine];
+			if (seg.type === "line") seg.to = insetFromEnd(seg.from, seg.to, targetInset);
+		}
+		return {
+			edgeId: edge.edgeId,
+			segments
+		};
+	});
+}
+/** Move `end` toward `start` by up to `inset` px, capped to keep a visible stub. */
+function insetFromEnd(start, end, inset) {
+	const dx = end.x - start.x;
+	const dy = end.y - start.y;
+	const len = Math.hypot(dx, dy);
+	if (len < 1e-6) return end;
+	const effectiveInset = Math.min(inset, len * .45);
+	return {
+		x: end.x - dx / len * effectiveInset,
+		y: end.y - dy / len * effectiveInset
+	};
+}
+//#endregion
+//#region src/labels/types.ts
+/** Icon size inside an edge-label pill (logical units). Keep in sync with SVG paint. */
+const EDGE_LABEL_ICON = 12;
+/** Gap between edge-label icon and text. */
+const EDGE_LABEL_ICON_GAP = 4;
+/** Horizontal padding inside the edge-label pill. */
+const EDGE_LABEL_PAD_X = 8;
+//#endregion
+export { ARROW_ENDPOINT_INSET, CARDINALITY_ENDPOINT_INSET, EDGE_ENDPOINT_INSET, EDGE_LABEL_ICON, EDGE_LABEL_ICON_GAP, EDGE_LABEL_PAD_X, applyCrossingTreatment, attachPointOnPerimeter, detectCrossingPoints, trimEdgeEndpoints };
+
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/crossings/treat.ts","../src/labels/types.ts"],"sourcesContent":["import type { Point } from \"@kekonic/diagrams-core\";\nimport type { CrossingMode } from \"@kekonic/diagrams-core\";\nimport type { RoutedEdge } from \"../routing/types.ts\";\n\n/** Arrow triangle in marker space: base at x=1.5, tip at x=9. */\nexport const ARROW_MARKER_BASE_X = 1.5;\nexport const ARROW_MARKER_TIP_X = 9;\n/** SVG marker refX — path end sits on the arrow *base* so the stroke does not run under the fill. */\nexport const ARROW_MARKER_REF_X = ARROW_MARKER_BASE_X;\n/** Tip extends past the path end (toward the node) by this much. */\nexport const ARROW_MARKER_TIP_OVERHANG = ARROW_MARKER_TIP_X - ARROW_MARKER_BASE_X;\n/**\n * How far to pull the path endpoint back from the node border.\n * Path end = arrow base; tip overhangs to (approximately) the attach point.\n */\nexport const ARROW_NODE_GAP = 1.5;\n/** Target trim: tip lands just shy of the node stroke; dash/solid stop at the arrow base. */\nexport const ARROW_ENDPOINT_INSET = ARROW_MARKER_TIP_OVERHANG + ARROW_NODE_GAP;\n/**\n * Crow's-foot tip sits on the path endpoint (marker refX), unlike arrows whose tip\n * overhangs past refX. Keep only a hairline gap so the tip kisses the table stroke.\n */\nexport const CARDINALITY_ENDPOINT_INSET = ARROW_NODE_GAP;\n/** Small inset for edges without arrowheads — clears node stroke at connection. */\nexport const EDGE_ENDPOINT_INSET = 1;\n/** Ignore crossings this close to a segment end — gaps there orphan markers on stubs. */\nconst CROSSING_ENDPOINT_CLEARANCE = 28;\n/** Crossings within this distance form a dense cluster (prefer gaps in smart mode). */\nconst SMART_CLUSTER_PX = 48;\n/** Prefer gaps when a crossing sits this close to a polyline bend. */\nconst SMART_CORNER_CLEARANCE = 24;\n\nexport type RenderedEdgeSegment =\n  | { type: \"line\"; from: Point; to: Point }\n  | { type: \"gap\"; from: Point; to: Point }\n  | { type: \"jump\"; from: Point; to: Point; radius: number };\n\nexport type TreatedEdge = {\n  edgeId: string;\n  segments: RenderedEdgeSegment[];\n};\n\ntype CrossingHit = {\n  hop: { edgeId: string; idx: number; from: Point; to: Point };\n  under: { edgeId: string; idx: number; from: Point; to: Point };\n  point: Point;\n};\n\nfunction dist(a: Point, b: Point): number {\n  return Math.hypot(a.x - b.x, a.y - b.y);\n}\n\n/** Mark crossings that sit in a dense local cluster (≥2 within SMART_CLUSTER_PX). */\nfunction denseCrossingIndexes(crossings: CrossingHit[]): Set<number> {\n  const dense = new Set<number>();\n  for (let i = 0; i < crossings.length; i++) {\n    let neighbors = 0;\n    for (let j = 0; j < crossings.length; j++) {\n      if (i === j) continue;\n      if (dist(crossings[i]!.point, crossings[j]!.point) <= SMART_CLUSTER_PX) neighbors++;\n    }\n    if (neighbors >= 1) dense.add(i);\n  }\n  return dense;\n}\n\nfunction nearPolylineCorner(edges: RoutedEdge[], edgeId: string, point: Point): boolean {\n  const edge = edges.find((e) => e.edgeId === edgeId);\n  if (!edge || edge.points.length < 3) return false;\n  // Intermediate points are bends; endpoints are already cleared separately.\n  for (let i = 1; i < edge.points.length - 1; i++) {\n    if (dist(edge.points[i]!, point) <= SMART_CORNER_CLEARANCE) return true;\n  }\n  return false;\n}\n\n/**\n * Decide gap vs jump for smart mode (§14.3):\n * - isolated orthogonal crossings → jumps\n * - dense clusters → gaps\n * - crossings near corners → gaps (jumps look noisy on bends)\n */\nfunction smartUsesJump(\n  crossing: CrossingHit,\n  index: number,\n  dense: Set<number>,\n  edges: RoutedEdge[],\n): boolean {\n  if (dense.has(index)) return false;\n  if (nearPolylineCorner(edges, crossing.hop.edgeId, crossing.point)) return false;\n  if (nearPolylineCorner(edges, crossing.under.edgeId, crossing.point)) return false;\n  return true;\n}\n\nexport function applyCrossingTreatment(edges: RoutedEdge[], mode: CrossingMode): TreatedEdge[] {\n  if (mode === \"none\") {\n    return edges.map((e) => ({\n      edgeId: e.edgeId,\n      segments: e.segments.map((s) => ({ type: \"line\" as const, from: s.from, to: s.to })),\n    }));\n  }\n\n  const allSegments: Array<{ edgeId: string; idx: number; from: Point; to: Point }> = [];\n  for (const edge of edges) {\n    edge.segments.forEach((s, idx) =>\n      allSegments.push({ edgeId: edge.edgeId, idx, from: s.from, to: s.to }),\n    );\n  }\n\n  const crossings: CrossingHit[] = [];\n  for (let i = 0; i < allSegments.length; i++) {\n    for (let j = i + 1; j < allSegments.length; j++) {\n      const a = allSegments[i]!;\n      const b = allSegments[j]!;\n      if (a.edgeId === b.edgeId) continue;\n      const pt = segmentIntersection(a.from, a.to, b.from, b.to);\n      if (!pt) continue;\n      // Hop the more horizontal segment (classic metro/schematic bridge look).\n      const aHoriz = Math.abs(a.from.y - a.to.y) <= Math.abs(a.from.x - a.to.x);\n      const hop = aHoriz ? a : b;\n      const under = hop === a ? b : a;\n      crossings.push({ hop, under, point: pt });\n    }\n  }\n\n  const dense = mode === \"smart\" ? denseCrossingIndexes(crossings) : new Set<number>();\n\n  /** Per hop-segment key → list of {point, useJump} */\n  const treatmentsAt = new Map<string, Array<{ point: Point; useJump: boolean }>>();\n  crossings.forEach((c, index) => {\n    const key = `${c.hop.edgeId}:${c.hop.idx}`;\n    if (!treatmentsAt.has(key)) treatmentsAt.set(key, []);\n    const useJump =\n      mode === \"jumps\" ? true : mode === \"gaps\" ? false : smartUsesJump(c, index, dense, edges);\n    treatmentsAt.get(key)!.push({ point: c.point, useJump });\n  });\n\n  const jumpRadius = 10;\n\n  return edges.map((edge) => {\n    const segments: RenderedEdgeSegment[] = [];\n    edge.segments.forEach((s, idx) => {\n      const key = `${edge.edgeId}:${idx}`;\n      const points = treatmentsAt.get(key) ?? [];\n      if (!points.length) {\n        segments.push({ type: \"line\", from: s.from, to: s.to });\n        return;\n      }\n      const segLen = Math.hypot(s.to.x - s.from.x, s.to.y - s.from.y) || 1;\n      const sorted = points\n        .map((p) => ({ ...p, t: paramOnSegment(s.from, s.to, p.point) }))\n        .filter((x) => {\n          const fromStart = x.t * segLen;\n          const fromEnd = (1 - x.t) * segLen;\n          return fromStart > CROSSING_ENDPOINT_CLEARANCE && fromEnd > CROSSING_ENDPOINT_CLEARANCE;\n        })\n        .sort((a, b) => a.t - b.t);\n\n      let prev = s.from;\n      for (const { point: p, useJump } of sorted) {\n        const t = paramOnSegment(s.from, s.to, p);\n        const half = Math.min(\n          0.04,\n          Math.max(0.015, 8 / (Math.hypot(s.to.x - s.from.x, s.to.y - s.from.y) || 1)),\n        );\n        const gapStart = lerp(s.from, s.to, Math.max(0, t - half));\n        const gapEnd = lerp(s.from, s.to, Math.min(1, t + half));\n        segments.push({ type: \"line\", from: prev, to: gapStart });\n        if (useJump) {\n          segments.push({ type: \"jump\", from: gapStart, to: gapEnd, radius: jumpRadius });\n        } else {\n          segments.push({ type: \"gap\", from: gapStart, to: gapEnd });\n        }\n        prev = gapEnd;\n      }\n      segments.push({ type: \"line\", from: prev, to: s.to });\n    });\n    return { edgeId: edge.edgeId, segments };\n  });\n}\n\nfunction segmentIntersection(a1: Point, a2: Point, b1: Point, b2: Point): Point | null {\n  // Prefer orthogonal H∩V detection — common for ELK routes and tolerant of float noise.\n  const eps = 0.75;\n  const aH = Math.abs(a1.y - a2.y) < eps;\n  const aV = Math.abs(a1.x - a2.x) < eps;\n  const bH = Math.abs(b1.y - b2.y) < eps;\n  const bV = Math.abs(b1.x - b2.x) < eps;\n\n  if (aH && bV) {\n    const y = (a1.y + a2.y) / 2;\n    const x = (b1.x + b2.x) / 2;\n    if (between(x, a1.x, a2.x) && between(y, b1.y, b2.y)) return { x, y };\n    return null;\n  }\n  if (aV && bH) {\n    const x = (a1.x + a2.x) / 2;\n    const y = (b1.y + b2.y) / 2;\n    if (between(y, a1.y, a2.y) && between(x, b1.x, b2.x)) return { x, y };\n    return null;\n  }\n\n  const d = (a2.x - a1.x) * (b2.y - b1.y) - (a2.y - a1.y) * (b2.x - b1.x);\n  if (Math.abs(d) < 1e-6) return null;\n  const t = ((b1.x - a1.x) * (b2.y - b1.y) - (b1.y - a1.y) * (b2.x - b1.x)) / d;\n  const u = ((b1.x - a1.x) * (a2.y - a1.y) - (b1.y - a1.y) * (a2.x - a1.x)) / d;\n  if (t > 0.02 && t < 0.98 && u > 0.02 && u < 0.98) {\n    return { x: a1.x + t * (a2.x - a1.x), y: a1.y + t * (a2.y - a1.y) };\n  }\n  return null;\n}\n\n/** Crossing points between distinct edge segments (for label scoring). */\nexport function detectCrossingPoints(edges: RoutedEdge[]): Point[] {\n  const allSegments: Array<{ edgeId: string; from: Point; to: Point }> = [];\n  for (const edge of edges) {\n    for (const s of edge.segments) {\n      allSegments.push({ edgeId: edge.edgeId, from: s.from, to: s.to });\n    }\n  }\n  const points: Point[] = [];\n  for (let i = 0; i < allSegments.length; i++) {\n    for (let j = i + 1; j < allSegments.length; j++) {\n      const a = allSegments[i]!;\n      const b = allSegments[j]!;\n      if (a.edgeId === b.edgeId) continue;\n      const pt = segmentIntersection(a.from, a.to, b.from, b.to);\n      if (pt) points.push(pt);\n    }\n  }\n  return points;\n}\n\nfunction between(v: number, a: number, b: number, pad = 1): boolean {\n  const lo = Math.min(a, b) + pad;\n  const hi = Math.max(a, b) - pad;\n  return v > lo && v < hi;\n}\n\nfunction paramOnSegment(a: Point, b: Point, p: Point): number {\n  const dx = b.x - a.x;\n  const dy = b.y - a.y;\n  const len2 = dx * dx + dy * dy;\n  if (len2 < 1e-6) return 0;\n  return ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;\n}\n\nfunction lerp(a: Point, b: Point, t: number): Point {\n  return { x: a.x + (b.x - a.x) * t, y: a.y + (b.y - a.y) * t };\n}\n\nexport type TrimEdgeEndpointsOptions = {\n  /** Uniform source inset, or per-edge via callback. */\n  sourceInset?: number | ((edgeId: string) => number);\n  /** Uniform target inset, or per-edge via callback. */\n  targetInset?: number | ((edgeId: string) => number);\n};\n\n/** Shorten first/last line segments so strokes and arrowheads stop before node fills. */\nexport function trimEdgeEndpoints(\n  edges: TreatedEdge[],\n  options: TrimEdgeEndpointsOptions = {},\n): TreatedEdge[] {\n  const sourceInsetOpt = options.sourceInset ?? EDGE_ENDPOINT_INSET;\n  const targetInsetOpt = options.targetInset ?? EDGE_ENDPOINT_INSET;\n\n  return edges.map((edge) => {\n    const sourceInset =\n      typeof sourceInsetOpt === \"function\" ? sourceInsetOpt(edge.edgeId) : sourceInsetOpt;\n    const targetInset =\n      typeof targetInsetOpt === \"function\" ? targetInsetOpt(edge.edgeId) : targetInsetOpt;\n    if (sourceInset <= 0 && targetInset <= 0) return edge;\n\n    const segments = edge.segments.map((s) =>\n      s.type === \"line\" ? { ...s, from: { ...s.from }, to: { ...s.to } } : s,\n    );\n\n    const firstLine = segments.findIndex((s) => s.type === \"line\");\n    let lastLine = -1;\n    for (let i = segments.length - 1; i >= 0; i--) {\n      if (segments[i]!.type === \"line\") {\n        lastLine = i;\n        break;\n      }\n    }\n    if (firstLine < 0) return { edgeId: edge.edgeId, segments };\n\n    if (sourceInset > 0) {\n      const seg = segments[firstLine]!;\n      if (seg.type === \"line\") {\n        seg.from = insetFromEnd(seg.to, seg.from, sourceInset);\n      }\n    }\n\n    if (targetInset > 0 && lastLine >= 0) {\n      const seg = segments[lastLine]!;\n      if (seg.type === \"line\") {\n        seg.to = insetFromEnd(seg.from, seg.to, targetInset);\n      }\n    }\n\n    return { edgeId: edge.edgeId, segments };\n  });\n}\n\n/** Move `end` toward `start` by up to `inset` px, capped to keep a visible stub. */\nfunction insetFromEnd(start: Point, end: Point, inset: number): Point {\n  const dx = end.x - start.x;\n  const dy = end.y - start.y;\n  const len = Math.hypot(dx, dy);\n  if (len < 1e-6) return end;\n  const effectiveInset = Math.min(inset, len * 0.45);\n  return {\n    x: end.x - (dx / len) * effectiveInset,\n    y: end.y - (dy / len) * effectiveInset,\n  };\n}\n","import type { Point, Rect } from \"@kekonic/diagrams-core\";\n\n/** Edge label bounds produced by ELK and painted by the SVG renderer. */\nexport type EdgeLabelPlacement = {\n  edgeId: string;\n  text: string;\n  bounds: Rect;\n  anchor: Point;\n};\n\n/** Icon size inside an edge-label pill (logical units). Keep in sync with SVG paint. */\nexport const EDGE_LABEL_ICON = 12;\n/** Gap between edge-label icon and text. */\nexport const EDGE_LABEL_ICON_GAP = 4;\n/** Horizontal padding inside the edge-label pill. */\nexport const EDGE_LABEL_PAD_X = 8;\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@kekonic/diagrams-routing",
+  "version": "1.0.0-rc.4",
+  "description": "KDiagram edge finalization, crossing treatment, and perimeter attachment.",
+  "homepage": "https://github.com/kekonic/diagrams#readme",
+  "bugs": {
+    "url": "https://github.com/kekonic/diagrams/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kekonic/diagrams.git",
+    "directory": "packages/diagrams-routing"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@kekonic/diagrams-core": "1.0.0-rc.4",
+    "@kekonic/diagrams-geometry": "1.0.0-rc.4",
+    "@kekonic/diagrams-layout": "1.0.0-rc.4"
+  },
+  "devDependencies": {
+    "@types/node": "^26",
+    "typescript": "^5",
+    "vitest": "^4"
+  },
+  "engines": {
+    "node": ">=22.18.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "test": "vp test"
+  }
+}