@misoto22/design 0.6.1 → 0.8.0

package/dist/diagrams/lib/route.js

@@ -0,0 +1,178 @@
+import { round } from "./geometry.js";
+const STUB = 18;
+const CORNER = 8;
+function autoSides(from, to) {
+  const gapX = Math.max(to.x - (from.x + from.w), from.x - (to.x + to.w));
+  const gapY = Math.max(to.y - (from.y + from.h), from.y - (to.y + to.h));
+  if (gapX >= gapY) {
+    return to.x >= from.x ? ["right", "left"] : ["left", "right"];
+  }
+  return to.y >= from.y ? ["bottom", "top"] : ["top", "bottom"];
+}
+function port(box, side, offset = 0.5) {
+  const t = Math.min(0.88, Math.max(0.12, offset));
+  switch (side) {
+    case "left":
+      return [box.x, box.y + box.h * t];
+    case "right":
+      return [box.x + box.w, box.y + box.h * t];
+    case "top":
+      return [box.x + box.w * t, box.y];
+    case "bottom":
+    default:
+      return [box.x + box.w * t, box.y + box.h];
+  }
+}
+function stubFrom(anchor, side, length = STUB) {
+  switch (side) {
+    case "left":
+      return [anchor[0] - length, anchor[1]];
+    case "right":
+      return [anchor[0] + length, anchor[1]];
+    case "top":
+      return [anchor[0], anchor[1] - length];
+    case "bottom":
+    default:
+      return [anchor[0], anchor[1] + length];
+  }
+}
+const isHorizontal = (side) => side === "left" || side === "right";
+function connect(a, b, fromSide, toSide, from, to, channelX, channelY) {
+  const fromH = isHorizontal(fromSide);
+  const toH = isHorizontal(toSide);
+  if (fromH && toH) {
+    const forward = fromSide === "right" && b[0] >= a[0] || fromSide === "left" && b[0] <= a[0];
+    const x = channelX ?? (forward ? (a[0] + b[0]) / 2 : (
+      // Behind: run out past the far edge of both boxes and come back.
+      fromSide === "right" ? Math.max(a[0], to.x + to.w + STUB, from.x + from.w + STUB) : Math.min(a[0], to.x - STUB, from.x - STUB)
+    ));
+    if (Math.abs(a[1] - b[1]) < 0.5) return [a, b];
+    return [a, [x, a[1]], [x, b[1]], b];
+  }
+  if (!fromH && !toH) {
+    const forward = fromSide === "bottom" && b[1] >= a[1] || fromSide === "top" && b[1] <= a[1];
+    const y = channelY ?? (forward ? (a[1] + b[1]) / 2 : fromSide === "bottom" ? Math.max(a[1], to.y + to.h + STUB, from.y + from.h + STUB) : Math.min(a[1], to.y - STUB, from.y - STUB));
+    if (Math.abs(a[0] - b[0]) < 0.5) return [a, b];
+    return [a, [a[0], y], [b[0], y], b];
+  }
+  return fromH ? [a, [b[0], a[1]], b] : [a, [a[0], b[1]], b];
+}
+function simplify(points) {
+  const out = [];
+  for (const point of points) {
+    const last = out[out.length - 1];
+    if (last && Math.abs(last[0] - point[0]) < 0.5 && Math.abs(last[1] - point[1]) < 0.5) continue;
+    out.push(point);
+  }
+  for (let index = 1; index < out.length - 1; ) {
+    const [ax, ay] = out[index - 1];
+    const [bx, by] = out[index];
+    const [cx, cy] = out[index + 1];
+    const collinear = Math.abs(ax - bx) < 0.5 && Math.abs(bx - cx) < 0.5 || Math.abs(ay - by) < 0.5 && Math.abs(by - cy) < 0.5;
+    if (collinear) out.splice(index, 1);
+    else index += 1;
+  }
+  return out;
+}
+function roundedPath(points, radius = CORNER) {
+  if (points.length === 0) return "";
+  if (points.length === 1) return `M ${round(points[0][0])} ${round(points[0][1])}`;
+  let d = `M ${round(points[0][0])} ${round(points[0][1])}`;
+  for (let index = 1; index < points.length - 1; index += 1) {
+    const previous = points[index - 1];
+    const corner = points[index];
+    const next = points[index + 1];
+    const inLength = Math.hypot(corner[0] - previous[0], corner[1] - previous[1]);
+    const outLength = Math.hypot(next[0] - corner[0], next[1] - corner[1]);
+    const r = Math.min(radius, inLength / 3, outLength / 3);
+    if (r < 1) {
+      d += ` L ${round(corner[0])} ${round(corner[1])}`;
+      continue;
+    }
+    const enter = [
+      corner[0] + (previous[0] - corner[0]) / inLength * r,
+      corner[1] + (previous[1] - corner[1]) / inLength * r
+    ];
+    const leave = [
+      corner[0] + (next[0] - corner[0]) / outLength * r,
+      corner[1] + (next[1] - corner[1]) / outLength * r
+    ];
+    d += ` L ${round(enter[0])} ${round(enter[1])}`;
+    d += ` Q ${round(corner[0])} ${round(corner[1])} ${round(leave[0])} ${round(leave[1])}`;
+  }
+  const end = points[points.length - 1];
+  return `${d} L ${round(end[0])} ${round(end[1])}`;
+}
+function labelSpot(points) {
+  let best = { x: points[0][0], y: points[0][1], axis: "x", length: -1 };
+  for (let index = 0; index < points.length - 1; index += 1) {
+    const a = points[index];
+    const b = points[index + 1];
+    const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+    if (length > best.length) {
+      best = {
+        x: (a[0] + b[0]) / 2,
+        y: (a[1] + b[1]) / 2,
+        axis: Math.abs(b[0] - a[0]) >= Math.abs(b[1] - a[1]) ? "x" : "y",
+        length
+      };
+    }
+  }
+  return { x: best.x, y: best.y, axis: best.axis };
+}
+function routeEdge(request) {
+  const { from, to, via, channelX, channelY, mode = "auto" } = request;
+  const [autoFrom, autoTo] = autoSides(from, to);
+  const fromSide = request.fromSide ?? autoFrom;
+  const toSide = request.toSide ?? autoTo;
+  const start = port(from, fromSide, request.fromOffset);
+  const end = port(to, toSide, request.toOffset);
+  let points;
+  if (mode === "straight") {
+    points = [start, end];
+  } else {
+    const outward = stubFrom(start, fromSide);
+    const inward = stubFrom(end, toSide);
+    if (via && via.length > 0) {
+      points = [start, outward];
+      let cursor = outward;
+      for (const waypoint of via) {
+        const next = [waypoint[0], waypoint[1]];
+        points.push([next[0], cursor[1]], next);
+        cursor = next;
+      }
+      points.push([inward[0], cursor[1]], inward, end);
+    } else {
+      const forced = mode === "orthogonal-h" ? "h" : mode === "orthogonal-v" ? "v" : null;
+      const middle = forced === "h" ? [outward, [inward[0], outward[1]], inward] : forced === "v" ? [outward, [outward[0], inward[1]], inward] : connect(outward, inward, fromSide, toSide, from, to, channelX, channelY);
+      points = [start, ...middle, end];
+    }
+  }
+  points = simplify(points);
+  const last = points[points.length - 1];
+  const previous = points[points.length - 2] ?? last;
+  const angle = Math.atan2(last[1] - previous[1], last[0] - previous[0]) * 180 / Math.PI;
+  return { d: roundedPath(points), points, label: labelSpot(points), angle };
+}
+function spreadPorts(uses) {
+  const byFace = /* @__PURE__ */ new Map();
+  for (const use of uses) {
+    const list = byFace.get(use.face);
+    if (list) list.push(use.ref);
+    else byFace.set(use.face, [use.ref]);
+  }
+  const offsets = /* @__PURE__ */ new Map();
+  for (const list of byFace.values()) {
+    if (list.length < 2) continue;
+    list.forEach((ref, position) => {
+      offsets.set(ref, (position + 1) / (list.length + 1));
+    });
+  }
+  return offsets;
+}
+export {
+  roundedPath,
+  routeEdge,
+  spreadPorts
+};
+//# sourceMappingURL=route.js.map

package/dist/diagrams/lib/route.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/diagrams/lib/route.ts"],"sourcesContent":["/**\n * Getting a line from one box to another.\n *\n * The routing rule this module keeps, and the reason it is worth having at all:\n * A SIDE IS A DIRECTION CONTRACT. A line that says it leaves a box's right face\n * must leave it going right, and a line that says it arrives at a top face must\n * arrive going down. A router that takes the shortest path between two anchor\n * points breaks that contract constantly — it produces a segment that grazes\n * the box it just left, and a reader cannot tell which of two adjacent boxes an\n * arrow belongs to. Every path below therefore begins and ends with a stub\n * perpendicular to its face, and the interesting geometry happens between the\n * two stubs.\n *\n * The second rule is about crowding. When several lines share one face they are\n * spread across it rather than stacked on its midpoint, because two arrowheads\n * landing on the same coordinate is one arrowhead as far as a reader is\n * concerned. Explicit routing controls opt out of the spread: an author who\n * pinned a channel has already decided where the line goes.\n */\n\nimport type { Point, RouteMode, Side } from '../spec'\nimport { round, type Box } from './geometry'\n\n/** How far a line runs straight out of a face before it is allowed to turn. */\nconst STUB = 18\n\n/** The turn radius on an orthogonal corner. */\nconst CORNER = 8\n\nexport interface RouteRequest {\n  from: Box\n  to: Box\n  fromSide?: Side\n  toSide?: Side\n  mode?: RouteMode | string\n  via?: Point[]\n  channelX?: number\n  channelY?: number\n  /** 0–1 along the face, where this line's port sits. 0.5 is the midpoint. */\n  fromOffset?: number\n  toOffset?: number\n}\n\nexport interface RoutedEdge {\n  /** The `d` attribute, corners already rounded. */\n  d: string\n  /** The polyline before rounding — what the label placer reads. */\n  points: [number, number][]\n  /** Where a label wants to sit, and how the segment under it runs. */\n  label: { x: number; y: number; axis: 'x' | 'y' }\n  /** The last segment's direction, for the arrowhead. */\n  angle: number\n}\n\n/**\n * The face a line should use when the author did not say.\n *\n * Whichever axis separates the two boxes by more wins, and the choice is made\n * on the GAP rather than on centre distance. Two boxes side by side with a\n * small vertical offset separate horizontally, which is what a reader expects;\n * comparing centres would flip that pair to top/bottom as soon as the offset\n * exceeded half a box.\n */\nfunction autoSides(from: Box, to: Box): [Side, Side] {\n  const gapX = Math.max(to.x - (from.x + from.w), from.x - (to.x + to.w))\n  const gapY = Math.max(to.y - (from.y + from.h), from.y - (to.y + to.h))\n\n  if (gapX >= gapY) {\n    return to.x >= from.x ? ['right', 'left'] : ['left', 'right']\n  }\n  return to.y >= from.y ? ['bottom', 'top'] : ['top', 'bottom']\n}\n\n/** The point on a face where a line attaches, given its share of that face. */\nfunction port(box: Box, side: Side, offset = 0.5): [number, number] {\n  const t = Math.min(0.88, Math.max(0.12, offset))\n  switch (side) {\n    case 'left':\n      return [box.x, box.y + box.h * t]\n    case 'right':\n      return [box.x + box.w, box.y + box.h * t]\n    case 'top':\n      return [box.x + box.w * t, box.y]\n    case 'bottom':\n    default:\n      return [box.x + box.w * t, box.y + box.h]\n  }\n}\n\n/** One step out of a face, perpendicular to it. */\nfunction stubFrom(anchor: [number, number], side: Side, length = STUB): [number, number] {\n  switch (side) {\n    case 'left':\n      return [anchor[0] - length, anchor[1]]\n    case 'right':\n      return [anchor[0] + length, anchor[1]]\n    case 'top':\n      return [anchor[0], anchor[1] - length]\n    case 'bottom':\n    default:\n      return [anchor[0], anchor[1] + length]\n  }\n}\n\nconst isHorizontal = (side: Side) => side === 'left' || side === 'right'\n\n/**\n * The polyline between two stub ends, kept orthogonal.\n *\n * Three cases, and they are the only three an axis-aligned router has:\n *\n * - **Facing across the same axis** (right→left, bottom→top). One dogleg\n *   through a channel halfway between them, which is the shape everybody draws\n *   by hand.\n * - **Turning a corner** (right→top). A single elbow, and WHICH elbow is\n *   decided by the outgoing axis: leaving a vertical face means running\n *   vertically first, or the line re-enters the box it just left.\n * - **Same-side or back-tracking** (right→right, or right→left with the target\n *   behind). The channel goes OUTSIDE both boxes rather than between them,\n *   because there is no room between them to go through.\n */\nfunction connect(\n  a: [number, number],\n  b: [number, number],\n  fromSide: Side,\n  toSide: Side,\n  from: Box,\n  to: Box,\n  channelX?: number,\n  channelY?: number,\n): [number, number][] {\n  const fromH = isHorizontal(fromSide)\n  const toH = isHorizontal(toSide)\n\n  if (fromH && toH) {\n    const forward =\n      (fromSide === 'right' && b[0] >= a[0]) || (fromSide === 'left' && b[0] <= a[0])\n    const x =\n      channelX ??\n      (forward\n        ? (a[0] + b[0]) / 2\n        : // Behind: run out past the far edge of both boxes and come back.\n          fromSide === 'right'\n          ? Math.max(a[0], to.x + to.w + STUB, from.x + from.w + STUB)\n          : Math.min(a[0], to.x - STUB, from.x - STUB))\n    if (Math.abs(a[1] - b[1]) < 0.5) return [a, b]\n    return [a, [x, a[1]], [x, b[1]], b]\n  }\n\n  if (!fromH && !toH) {\n    const forward =\n      (fromSide === 'bottom' && b[1] >= a[1]) || (fromSide === 'top' && b[1] <= a[1])\n    const y =\n      channelY ??\n      (forward\n        ? (a[1] + b[1]) / 2\n        : fromSide === 'bottom'\n          ? Math.max(a[1], to.y + to.h + STUB, from.y + from.h + STUB)\n          : Math.min(a[1], to.y - STUB, from.y - STUB))\n    if (Math.abs(a[0] - b[0]) < 0.5) return [a, b]\n    return [a, [a[0], y], [b[0], y], b]\n  }\n\n  // One elbow. The axis of the OUTGOING face decides which corner it is.\n  return fromH ? [a, [b[0], a[1]], b] : [a, [a[0], b[1]], b]\n}\n\n/** Drops points that repeat, and collapses three points on one straight run into two. */\nfunction simplify(points: [number, number][]): [number, number][] {\n  const out: [number, number][] = []\n  for (const point of points) {\n    const last = out[out.length - 1]\n    if (last && Math.abs(last[0] - point[0]) < 0.5 && Math.abs(last[1] - point[1]) < 0.5) continue\n    out.push(point)\n  }\n  for (let index = 1; index < out.length - 1; ) {\n    const [ax, ay] = out[index - 1]!\n    const [bx, by] = out[index]!\n    const [cx, cy] = out[index + 1]!\n    const collinear =\n      (Math.abs(ax - bx) < 0.5 && Math.abs(bx - cx) < 0.5) ||\n      (Math.abs(ay - by) < 0.5 && Math.abs(by - cy) < 0.5)\n    if (collinear) out.splice(index, 1)\n    else index += 1\n  }\n  return out\n}\n\n/**\n * The polyline as a path, with the corners turned rather than mitred.\n *\n * A quadratic through the corner point, pulled back along both legs by the\n * radius. The pull-back is clamped to a third of each leg so a short segment\n * between two turns cannot produce a curve that overshoots its own endpoint —\n * which renders as a hook and is the classic artefact of rounding a polyline\n * without checking the leg lengths.\n */\nexport function roundedPath(points: [number, number][], radius = CORNER): string {\n  if (points.length === 0) return ''\n  if (points.length === 1) return `M ${round(points[0]![0])} ${round(points[0]![1])}`\n\n  let d = `M ${round(points[0]![0])} ${round(points[0]![1])}`\n\n  for (let index = 1; index < points.length - 1; index += 1) {\n    const previous = points[index - 1]!\n    const corner = points[index]!\n    const next = points[index + 1]!\n\n    const inLength = Math.hypot(corner[0] - previous[0], corner[1] - previous[1])\n    const outLength = Math.hypot(next[0] - corner[0], next[1] - corner[1])\n    const r = Math.min(radius, inLength / 3, outLength / 3)\n\n    if (r < 1) {\n      d += ` L ${round(corner[0])} ${round(corner[1])}`\n      continue\n    }\n\n    const enter: [number, number] = [\n      corner[0] + ((previous[0] - corner[0]) / inLength) * r,\n      corner[1] + ((previous[1] - corner[1]) / inLength) * r,\n    ]\n    const leave: [number, number] = [\n      corner[0] + ((next[0] - corner[0]) / outLength) * r,\n      corner[1] + ((next[1] - corner[1]) / outLength) * r,\n    ]\n\n    d += ` L ${round(enter[0])} ${round(enter[1])}`\n    d += ` Q ${round(corner[0])} ${round(corner[1])} ${round(leave[0])} ${round(leave[1])}`\n  }\n\n  const end = points[points.length - 1]!\n  return `${d} L ${round(end[0])} ${round(end[1])}`\n}\n\n/**\n * Where the line's wording goes: the middle of its longest segment.\n *\n * The longest segment is chosen rather than the path's own midpoint because the\n * midpoint of a dogleg often lands on a corner, and a label on a corner sits\n * across both legs and masks the turn — which is the one part of the line that\n * carries information about where it went.\n */\nfunction labelSpot(points: [number, number][]): { x: number; y: number; axis: 'x' | 'y' } {\n  let best = { x: points[0]![0], y: points[0]![1], axis: 'x' as 'x' | 'y', length: -1 }\n\n  for (let index = 0; index < points.length - 1; index += 1) {\n    const a = points[index]!\n    const b = points[index + 1]!\n    const length = Math.hypot(b[0] - a[0], b[1] - a[1])\n    if (length > best.length) {\n      best = {\n        x: (a[0] + b[0]) / 2,\n        y: (a[1] + b[1]) / 2,\n        axis: Math.abs(b[0] - a[0]) >= Math.abs(b[1] - a[1]) ? 'x' : 'y',\n        length,\n      }\n    }\n  }\n\n  return { x: best.x, y: best.y, axis: best.axis }\n}\n\n/** Routes one relationship. */\nexport function routeEdge(request: RouteRequest): RoutedEdge {\n  const { from, to, via, channelX, channelY, mode = 'auto' } = request\n\n  const [autoFrom, autoTo] = autoSides(from, to)\n  const fromSide = request.fromSide ?? autoFrom\n  const toSide = request.toSide ?? autoTo\n\n  const start = port(from, fromSide, request.fromOffset)\n  const end = port(to, toSide, request.toOffset)\n\n  let points: [number, number][]\n\n  if (mode === 'straight') {\n    // Straight means straight: centre to centre, clipped to both faces. No\n    // stubs, because a stub would bend the one route whose whole promise is\n    // that it does not bend.\n    points = [start, end]\n  } else {\n    const outward = stubFrom(start, fromSide)\n    const inward = stubFrom(end, toSide)\n\n    if (via && via.length > 0) {\n      // Waypoints are honoured literally and joined orthogonally. An author who\n      // reached for `via` is overruling the router, and a router that then\n      // \"improved\" the result would make the control useless.\n      points = [start, outward]\n      let cursor: [number, number] = outward\n      for (const waypoint of via) {\n        const next: [number, number] = [waypoint[0], waypoint[1]]\n        points.push([next[0], cursor[1]], next)\n        cursor = next\n      }\n      points.push([inward[0], cursor[1]], inward, end)\n    } else {\n      const forced =\n        mode === 'orthogonal-h' ? ('h' as const) : mode === 'orthogonal-v' ? ('v' as const) : null\n\n      const middle =\n        forced === 'h'\n          ? ([outward, [inward[0], outward[1]], inward] as [number, number][])\n          : forced === 'v'\n            ? ([outward, [outward[0], inward[1]], inward] as [number, number][])\n            : connect(outward, inward, fromSide, toSide, from, to, channelX, channelY)\n\n      points = [start, ...middle, end]\n    }\n  }\n\n  points = simplify(points)\n\n  const last = points[points.length - 1]!\n  const previous = points[points.length - 2] ?? last\n  const angle = (Math.atan2(last[1] - previous[1], last[0] - previous[0]) * 180) / Math.PI\n\n  return { d: roundedPath(points), points, label: labelSpot(points), angle }\n}\n\n/** One line's use of one face: which face, and which end of which line it is. */\nexport interface PortUse {\n  /** The face, as `nodeId:side`. Two lines sharing this string share a face. */\n  face: string\n  /** This endpoint, as `edgeIndex:from` or `edgeIndex:to`. */\n  ref: string\n}\n\n/**\n * Which share of its face each line gets, when several use the same one.\n *\n * A single line keeps the midpoint — spreading one line only moves it off\n * centre for no reason. Lines that carry an explicit routing control are\n * excluded by the caller before they get here, so a pinned channel is never\n * nudged out from under its pin.\n *\n * Endpoints are keyed separately rather than by line, because a line's two ends\n * land on two different faces with two different amounts of company. Keying by\n * line gave both ends the same offset, which on a figure with one crowded face\n * and one empty one visibly skewed every arrow that touched the empty side.\n */\nexport function spreadPorts(uses: PortUse[]): Map<string, number> {\n  const byFace = new Map<string, string[]>()\n  for (const use of uses) {\n    const list = byFace.get(use.face)\n    if (list) list.push(use.ref)\n    else byFace.set(use.face, [use.ref])\n  }\n\n  const offsets = new Map<string, number>()\n  for (const list of byFace.values()) {\n    if (list.length < 2) continue\n    list.forEach((ref, position) => {\n      offsets.set(ref, (position + 1) / (list.length + 1))\n    })\n  }\n  return offsets\n}\n"],"mappings":"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","names":[]}

package/dist/diagrams/lib/wires.d.ts

@@ -0,0 +1,59 @@
+import { ReactNode } from 'react';
+import { EdgeBase, Variant } from '../spec.js';
+import { Box } from './geometry.js';
+
+/** One line to draw, once its two boxes are known. */
+interface Wire {
+    edge: EdgeBase & {
+        variant?: Variant | 'return';
+        classification?: string;
+        note?: string;
+    };
+    from: Box;
+    to: Box;
+    /** Overrides the variant's own stroke weight — a main path drawn heavier. */
+    weight?: number;
+    /** An open arrowhead rather than a filled one. */
+    open?: boolean;
+    /**
+     * Whether this line's `via` / `channelX` / `channelY` mean anything here.
+     *
+     * A waypoint is an ABSOLUTE coordinate in whatever space the author's nodes
+     * were placed in. When a specification pins its nodes with `pos`, that space
+     * is this renderer's space too and the waypoints land exactly where they were
+     * meant to. When the nodes are placed from a lane and a column, this renderer
+     * chose the coordinates — so the author's waypoints refer to a grid that does
+     * not exist here, and following them drags lines across unrelated nodes.
+     *
+     * So the rule is per line and not per figure: honour the waypoints when both
+     * of a line's endpoints were placed absolutely, and route automatically
+     * otherwise. Defaults to false, which is the safe half.
+     */
+    keepWaypoints?: boolean;
+}
+/**
+ * Every line in a figure, routed together.
+ *
+ * Together rather than one at a time, because port spreading is a property of a
+ * FACE and not of a line: how far off centre a given arrow sits depends on how
+ * many others land on the same face, which no single line can know. Routing
+ * them independently is what produces three arrowheads stacked on one point.
+ *
+ * Lines that pin their own geometry — `via`, a channel, an explicit side — opt
+ * out of the spread. An author who placed a line has already answered the
+ * question the spread exists to answer, and moving it afterwards makes the
+ * control useless.
+ *
+ * Returns the paths and the labels separately because ORDER IS THE MASK: a
+ * label's plate has to be painted over every line in the figure, not merely
+ * over its own. Interleaving them puts the third line on top of the first
+ * line's label.
+ */
+declare function renderWires(wires: Wire[], uid: string): {
+    paths: ReactNode;
+    labels: ReactNode;
+};
+/** Resolves an edge's endpoints against a box index, dropping any that dangle. */
+declare function wiresFor<E extends EdgeBase>(edges: E[] | undefined, boxes: Map<string, Box>, decorate?: (edge: E) => Partial<Wire>): Wire[];
+
+export { type Wire, renderWires, wiresFor };

package/dist/diagrams/lib/wires.js

@@ -0,0 +1,90 @@
+import { jsx } from "react/jsx-runtime";
+import { edgeClasses, EdgeLabel, edgeMarker, edgeStroke } from "./marks.js";
+import { routeEdge, spreadPorts } from "./route.js";
+function renderWires(wires, uid) {
+  const uses = [];
+  wires.forEach((wire, index) => {
+    const { edge } = wire;
+    const pinned = wire.keepWaypoints === true && Boolean(edge.via?.length || edge.channelX !== void 0 || edge.channelY !== void 0);
+    if (pinned) return;
+    if (edge.fromSide) uses.push({ face: `${edge.from}:${edge.fromSide}`, ref: `${index}:from` });
+    if (edge.toSide) uses.push({ face: `${edge.to}:${edge.toSide}`, ref: `${index}:to` });
+    if (!edge.fromSide) uses.push({ face: `${edge.from}:auto`, ref: `${index}:from` });
+    if (!edge.toSide) uses.push({ face: `${edge.to}:auto`, ref: `${index}:to` });
+  });
+  const offsets = spreadPorts(uses);
+  const routed = wires.map((wire, index) => {
+    const { edge } = wire;
+    const keep = wire.keepWaypoints === true;
+    return {
+      wire,
+      index,
+      route: routeEdge({
+        from: wire.from,
+        to: wire.to,
+        fromSide: edge.fromSide,
+        toSide: edge.toSide,
+        mode: edge.route,
+        via: keep ? edge.via : void 0,
+        channelX: keep ? edge.channelX : void 0,
+        channelY: keep ? edge.channelY : void 0,
+        fromOffset: offsets.get(`${index}:from`),
+        toOffset: offsets.get(`${index}:to`)
+      })
+    };
+  });
+  return {
+    paths: /* @__PURE__ */ jsx("g", { "data-diagram-wires": "", children: routed.map(({ wire, index, route }) => /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: route.d,
+        fill: "none",
+        "data-edge": wire.edge.id,
+        markerEnd: `url(#${uid}-${wire.open ? "arrow-open" : edgeMarker(wire.edge.variant)})`,
+        className: edgeClasses(wire.edge.variant),
+        ...edgeStroke(wire.edge.variant, wire.weight)
+      },
+      wire.edge.id ?? index
+    )) }),
+    labels: /* @__PURE__ */ jsx("g", { "data-diagram-wire-labels": "", children: routed.map(
+      ({ wire, index, route }) => wire.edge.label ? (
+        /* `labelDx` / `labelDy` / `labelAt` are deliberately NOT applied.
+           They are collision repairs authored against archify's router,
+           measured in the positions THAT router produced — and this one
+           does not produce the same collisions, so honouring them moves
+           labels off clear ground and onto the nodes they were nudged away
+           from. Dropping the nudge and keeping the wording is the reading
+           that preserves the meaning; the field stays in the type so a
+           specification carrying it still typechecks. */
+        /* @__PURE__ */ jsx(
+          EdgeLabel,
+          {
+            x: route.label.x,
+            y: route.label.y,
+            axis: route.label.axis,
+            text: wire.edge.label,
+            chip: wire.edge.classification,
+            note: wire.edge.note
+          },
+          wire.edge.id ?? index
+        )
+      ) : null
+    ) })
+  };
+}
+function wiresFor(edges, boxes, decorate) {
+  if (!edges) return [];
+  const out = [];
+  for (const edge of edges) {
+    const from = boxes.get(edge.from);
+    const to = boxes.get(edge.to);
+    if (!from || !to) continue;
+    out.push({ edge, from, to, ...decorate?.(edge) });
+  }
+  return out;
+}
+export {
+  renderWires,
+  wiresFor
+};
+//# sourceMappingURL=wires.js.map

package/dist/diagrams/lib/wires.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/diagrams/lib/wires.tsx"],"sourcesContent":["import type { ReactNode } from 'react'\nimport type { EdgeBase, Side, Variant } from '../spec'\nimport type { Box } from './geometry'\nimport { edgeClasses, EdgeLabel, edgeMarker, edgeStroke } from './marks'\nimport { routeEdge, spreadPorts, type PortUse } from './route'\n\n/** One line to draw, once its two boxes are known. */\nexport interface Wire {\n  edge: EdgeBase & { variant?: Variant | 'return'; classification?: string; note?: string }\n  from: Box\n  to: Box\n  /** Overrides the variant's own stroke weight — a main path drawn heavier. */\n  weight?: number\n  /** An open arrowhead rather than a filled one. */\n  open?: boolean\n  /**\n   * Whether this line's `via` / `channelX` / `channelY` mean anything here.\n   *\n   * A waypoint is an ABSOLUTE coordinate in whatever space the author's nodes\n   * were placed in. When a specification pins its nodes with `pos`, that space\n   * is this renderer's space too and the waypoints land exactly where they were\n   * meant to. When the nodes are placed from a lane and a column, this renderer\n   * chose the coordinates — so the author's waypoints refer to a grid that does\n   * not exist here, and following them drags lines across unrelated nodes.\n   *\n   * So the rule is per line and not per figure: honour the waypoints when both\n   * of a line's endpoints were placed absolutely, and route automatically\n   * otherwise. Defaults to false, which is the safe half.\n   */\n  keepWaypoints?: boolean\n}\n\n/**\n * Every line in a figure, routed together.\n *\n * Together rather than one at a time, because port spreading is a property of a\n * FACE and not of a line: how far off centre a given arrow sits depends on how\n * many others land on the same face, which no single line can know. Routing\n * them independently is what produces three arrowheads stacked on one point.\n *\n * Lines that pin their own geometry — `via`, a channel, an explicit side — opt\n * out of the spread. An author who placed a line has already answered the\n * question the spread exists to answer, and moving it afterwards makes the\n * control useless.\n *\n * Returns the paths and the labels separately because ORDER IS THE MASK: a\n * label's plate has to be painted over every line in the figure, not merely\n * over its own. Interleaving them puts the third line on top of the first\n * line's label.\n */\nexport function renderWires(\n  wires: Wire[],\n  uid: string,\n): { paths: ReactNode; labels: ReactNode } {\n  const uses: PortUse[] = []\n\n  wires.forEach((wire, index) => {\n    const { edge } = wire\n    const pinned =\n      wire.keepWaypoints === true &&\n      Boolean(edge.via?.length || edge.channelX !== undefined || edge.channelY !== undefined)\n    if (pinned) return\n    if (edge.fromSide) uses.push({ face: `${edge.from}:${edge.fromSide}`, ref: `${index}:from` })\n    if (edge.toSide) uses.push({ face: `${edge.to}:${edge.toSide}`, ref: `${index}:to` })\n    if (!edge.fromSide) uses.push({ face: `${edge.from}:auto`, ref: `${index}:from` })\n    if (!edge.toSide) uses.push({ face: `${edge.to}:auto`, ref: `${index}:to` })\n  })\n\n  const offsets = spreadPorts(uses)\n\n  const routed = wires.map((wire, index) => {\n    const { edge } = wire\n    const keep = wire.keepWaypoints === true\n    return {\n      wire,\n      index,\n      route: routeEdge({\n        from: wire.from,\n        to: wire.to,\n        fromSide: edge.fromSide as Side | undefined,\n        toSide: edge.toSide as Side | undefined,\n        mode: edge.route,\n        via: keep ? edge.via : undefined,\n        channelX: keep ? edge.channelX : undefined,\n        channelY: keep ? edge.channelY : undefined,\n        fromOffset: offsets.get(`${index}:from`),\n        toOffset: offsets.get(`${index}:to`),\n      }),\n    }\n  })\n\n  return {\n    paths: (\n      <g data-diagram-wires=\"\">\n        {routed.map(({ wire, index, route }) => (\n          <path\n            key={wire.edge.id ?? index}\n            d={route.d}\n            fill=\"none\"\n            data-edge={wire.edge.id}\n            markerEnd={`url(#${uid}-${wire.open ? 'arrow-open' : edgeMarker(wire.edge.variant)})`}\n            className={edgeClasses(wire.edge.variant)}\n            {...edgeStroke(wire.edge.variant, wire.weight)}\n          />\n        ))}\n      </g>\n    ),\n    labels: (\n      <g data-diagram-wire-labels=\"\">\n        {routed.map(({ wire, index, route }) =>\n          wire.edge.label ? (\n            /* `labelDx` / `labelDy` / `labelAt` are deliberately NOT applied.\n               They are collision repairs authored against archify's router,\n               measured in the positions THAT router produced — and this one\n               does not produce the same collisions, so honouring them moves\n               labels off clear ground and onto the nodes they were nudged away\n               from. Dropping the nudge and keeping the wording is the reading\n               that preserves the meaning; the field stays in the type so a\n               specification carrying it still typechecks. */\n            <EdgeLabel\n              key={wire.edge.id ?? index}\n              x={route.label.x}\n              y={route.label.y}\n              axis={route.label.axis}\n              text={wire.edge.label}\n              chip={wire.edge.classification}\n              note={wire.edge.note}\n            />\n          ) : null,\n        )}\n      </g>\n    ),\n  }\n}\n\n/** Resolves an edge's endpoints against a box index, dropping any that dangle. */\nexport function wiresFor<E extends EdgeBase>(\n  edges: E[] | undefined,\n  boxes: Map<string, Box>,\n  decorate?: (edge: E) => Partial<Wire>,\n): Wire[] {\n  if (!edges) return []\n  const out: Wire[] = []\n  for (const edge of edges) {\n    const from = boxes.get(edge.from)\n    const to = boxes.get(edge.to)\n    // A relationship naming a node that is not in the figure is a specification\n    // error, and drawing it from nowhere to nowhere would hide that. The\n    // figures filter the same edges through `liveEdges` before they get here,\n    // so the drop is announced once in development and the summary list agrees\n    // with the picture; this guard is what makes that agreement structural\n    // rather than a convention every renderer has to remember.\n    if (!from || !to) continue\n    out.push({ edge, from, to, ...decorate?.(edge) })\n  }\n  return out\n}\n"],"mappings":"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","names":[]}