@mark1russell7/highways 0.9.1 → 0.9.3

package/src/bench/screen/screen.ts

@@ -1,17 +1,20 @@
-import type { Graph, Result, Route } from "../../model.ts";
+import type { Graph, Level, Result, Route } from "../../model.ts";
 import { stableOrderStrategy } from "../../order/index.ts";
 import { repairStrategy } from "../../repair/index.ts";
 import { STRATEGIES } from "../../strategies/builtins.ts";
 import { asRouter, createRegistry, getStrategy, listStrategies, register, STEPS, type AnyStrategy, type Registry, type Strategy } from "../../strategies/model.ts";
-import { compareStep, highwayRouters, isRoutedStep, stepRouters, type CompareRow, type CompareStep, type RoutedStep, type StepComparison } from "../compare.ts";
+import { compareStep, highwayRouters, isRoutedStep, stepRouters, wholeBoard, type CompareRow, type CompareStep, type RoutedStep, type StepComparison } from "../compare.ts";
 import { bundledShare, bundleStretch, mergeAngle } from "../measures/bundles.ts";
 import { highwayEdits } from "../measures/highways.ts";
 import { laneArea, laneCrossings, laneFidelity, lanesThrough, occupiedArea, openLanes, orthogonality, routeSeparation, runProfile } from "../measures/lanes.ts";
-import { linkAgreement } from "../measures/levels.ts";
+import { farLevel, groupFill, itemOverlaps, silhouette } from "../measures/groups.ts";
+import { levelRatio, linkAgreement } from "../measures/levels.ts";
 import { orderFragility } from "../measures/order.ts";
 import { paretoFront, type Objective } from "../measures/pareto.ts";
 import { boardUnit } from "../measures/routes.ts";
+import { boxDisplacement, distanceDistortion, roomOrderFaults } from "../measures/room.ts";
 import { routeStability } from "../measures/stability.ts";
+import { routeSymmetry } from "../measures/symmetry.ts";
 import { quantile } from "../measures/stats.ts";
 import { checkLevels, checkProperties, TOLERANCE } from "../properties.ts";
 import { measureQuality } from "../quality.ts";
@@ -227,11 +230,30 @@ function screenRegistry(step: ScreenStep, strategies: readonly (Strategy<ScreenS
 /** This function tells if a step of the screen gives routes. The step `router` gives routes, and each step of `RoutedStep` gives routes as a router. */
 const givesRoutes = (step: ScreenStep): step is "router" | RoutedStep => step === "router" || isRoutedStep(step);
 
+/** This function gives the measures of the shape of the groups and of the levels: G4, G5, G7 and Z5. A value without its data is not in the result. */
+function groupShapeValues(graph: Graph, levels: readonly Level[]): Record<string, number> {
+  const values: Record<string, number> = {};
+  if (levels.length === 0) return values;
+  values["G5.overlaps"] = itemOverlaps(levels);
+  const far = farLevel(levels);
+  const fill = far && groupFill(graph, far);
+  if (fill !== undefined) values["G4.fill"] = fill;
+  const sil = far && silhouette(graph, far);
+  if (sil !== undefined) values["G7.silhouette"] = sil;
+  const ratio = levelRatio(levels);
+  if (ratio) {
+    values["Z5.max"] = ratio.max;
+    values["Z5.spread"] = ratio.spread;
+  }
+  return values;
+}
+
 /**
  * This function gives the values of a row of `compareStep`, with the measures of `measureQuality` for a router.
  * A router also gets the bundled share (B2), the merge angle (B6) and the bundle stretch (B3) against the routes `base` of `corners`.
  * It also gets the measures of MEAS3A: R12, R14, B5, B7, B8, B9, M1 and M4. The lane measures open each shared segment at `MEASURE_LANE_WIDTH`.
- * A result with zoom levels also gets the link agreement (Z9), for a router and for a grouping rule.
+ * A result with zoom levels also gets the link agreement (Z9) and `groupShapeValues`, for a router and for a grouping rule.
+ * A router also gets the symmetry of its routes (H3). A whole strategy also gets M2, M3 and M5 of the board of its output.
  */
 function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () => readonly Route[]): Record<string, number> {
   const values: Record<string, number> = { ...row.values };
@@ -265,10 +287,21 @@ function rowValues(step: ScreenStep, graph: Graph, row: CompareRow, base: () =>
     }
     values["M1.area"] = laneArea(graph, open);
     values["M4.laneThrough"] = lanesThrough(graph, open);
+    const h3 = routeSymmetry(graph, routes);
+    if (h3 !== undefined) values["H3.share"] = h3;
   }
   if ((givesRoutes(step) || step === "group") && row.result?.levels) {
-    const la = linkAgreement(graph, row.result.levels, row.result.routes, boardUnit(graph));
+    const levels = row.result.levels;
+    const la = linkAgreement(graph, levels, row.result.routes, boardUnit(graph));
     if (la !== undefined) values["Z9.mean"] = la;
+    Object.assign(values, groupShapeValues(graph, levels));
+  }
+  // The step `whole` can move the boxes with a room strategy. M2, M3 and M5 compare the board of the output with the input board.
+  if (step === "whole" && row.result) {
+    const board = wholeBoard(row.result) ?? graph;
+    values["M2.order"] = roomOrderFaults(graph.nodes, board.nodes);
+    values["M3.displacement"] = boxDisplacement(graph.nodes, board.nodes, boardUnit(graph));
+    values["M5.stress"] = distanceDistortion(graph.nodes, board.nodes);
   }
   return values;
 }
@@ -426,6 +459,8 @@ export function screen(step: ScreenStep, strategies: readonly (Strategy<ScreenSt
       const values = rowValues(step, graph, row, cornersBase);
       // Z2 is the count of the hard rule `link-ends`, as a measure. The steps `router`, `highway` and `group` check the rule.
       if (hard["link-ends"] !== undefined) values["Z2.linkEnds"] = hard["link-ends"];
+      // Z1 is the count of the hard rule `counts-sum`, as a measure, the same way.
+      if (hard["counts-sum"] !== undefined) values["Z1.countsSum"] = hard["counts-sum"];
       if (optima && withOptima.has(input.id) && row.result) Object.assign(values, gapValues(input, graph, row.result, cornersBase(), gapBase(), optima));
       if (shuffles > 0 && row.result) {
         const router = asRouter(strategy as Strategy<"router">, own[row.strategy]);

package/src/bench/suite.ts

@@ -15,7 +15,7 @@ import { asRouter, listStrategies, STEPS, type LaneBoard, type Registry, type St
 import { measureLevelFaults, sumFaults } from "./links.ts";
 import { checkLevels } from "./properties.ts";
 import { ambiguity, inkSaved } from "./measures/bundles.ts";
-import { bendingEnergy, curveFaults, g1Defect, g2Defect } from "./measures/curves.ts";
+import { bendingEnergy, curvatureVariation, curveDeviation, curveFaults, g1Defect, g2Defect } from "./measures/curves.ts";
 import { balance, cutShare, farLevel, groupStability, levelGrouping, modularity, treeCost } from "./measures/groups.ts";
 import { nestingFaults, orderStability, positionStability } from "./measures/levels.ts";
 import { paretoFront, type Objective } from "./measures/pareto.ts";
@@ -328,7 +328,7 @@ export interface CurveRun {
   readonly edges: readonly string[];
 }
 
-/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C6 and the curve rules). */
+/** This function draws the routes of a result with each curve strategy and measures the curves (C1, C2, C3, C4, C6, C8 and the curve rules). */
 export function curveRuns(graph: Graph, result: Result, curves: readonly Strategy<"curve">[], options: CurveRunOptions): CurveRun[] {
   const byId = nodeIndex(graph);
   const edges = new Map(graph.edges.map((e) => [e.id, e]));
@@ -363,6 +363,8 @@ export function curveRuns(graph: Graph, result: Result, curves: readonly Strateg
     const g1: number[] = [];
     const g2: number[] = [];
     const energy: number[] = [];
+    const variation: number[] = [];
+    const deviation: number[] = [];
     const rules = { "curve-clear": 0, "curve-ends": 0, "curve-g1": 0, "curve-simple": 0 };
     let length = 0;
     drawn.forEach((segments, i) => {
@@ -371,6 +373,8 @@ export function curveRuns(graph: Graph, result: Result, curves: readonly Strateg
       g1.push(g1Defect(segments));
       g2.push(g2Defect(segments, u));
       energy.push(bendingEnergy(s, 0.25));
+      variation.push(curvatureVariation(s, 0.25));
+      deviation.push(curveDeviation(s, r.points, u / 4) / u);
       length += polylineLength(s);
       const normals = options.normals.has(curve.name);
       const f = curveFaults({
@@ -394,6 +398,10 @@ export function curveRuns(graph: Graph, result: Result, curves: readonly Strateg
       "C2.max": g2.reduce((m, x) => Math.max(m, x), 0),
       "C3.median": quantile(energy, 0.5) || 0,
       "C3.q95": quantile(energy, 0.95) || 0,
+      "C4.median": quantile(variation, 0.5) || 0,
+      "C4.q95": quantile(variation, 0.95) || 0,
+      "C8.median": quantile(deviation, 0.5) || 0,
+      "C8.max": deviation.reduce((m, x) => Math.max(m, x), 0),
       "C6.length": ink > 0 ? length / ink : 1,
       ...rules,
     };

package/src/highways/follow.ts

@@ -1,5 +1,5 @@
 import { center, dist, pointBoxDistance, type Point } from "../geom.ts";
-import { fixedPortPoint, nodeIndex, resolvePorts, type End, type Graph, type Node, type Result, type Route, type SharedRun } from "../model.ts";
+import { fixedPortPoint, nodeIndex, outerGraph, type End, type Graph, type Node, type Result, type Route, type SharedRun } from "../model.ts";
 import { placePlug } from "../plugs.ts";
 import { orderLanes, type RunOrder } from "../segments.ts";
 import { WayFinder, type WayOptions } from "../ways.ts";
@@ -69,7 +69,7 @@ function slice(stops: Stops, on: number, off: number): Point[] {
  * The same graph, plan and options give the same result.
  */
 export function follow(input: Graph, plan: HighwayPlan, options: FollowOptions = {}): Result {
-  const graph = resolvePorts(input);
+  const graph = outerGraph(input);
   const byId = nodeIndex(graph);
   const ways = new WayFinder(graph.nodes, options);
   const base = new Map((options.routes?.routes ?? []).map((r) => [r.edge, r.points]));

package/src/index.ts

@@ -18,6 +18,8 @@ export * from "./room/index.ts";
 export * from "./room/lanes.ts";
 export * from "./room/levels/index.ts";
 export * from "./plugs/facing/index.ts";
+export * from "./plugs/spread/index.ts";
+export * from "./plugs/fix.ts";
 export * from "./levels/depths/index.ts";
 export * from "./whole/pipeline/index.ts";
 export * from "./bench/properties.ts";

package/src/model.ts

@@ -30,6 +30,12 @@ export interface Node {
   readonly ports?: readonly Port[];
   /** This data is free for the grouping rules of the nodes. The rule `keys` reads the string `data.group` by default. */
   readonly data?: Readonly<Record<string, unknown>>;
+  /**
+   * This id names the frame node that holds the node. A frame is a node that another node names as its parent.
+   * An edge from a plug of a frame to a node in the frame is an inner edge (`splitFrames`). The router `corners` routes it inside the frame.
+   * A parent that names no node, or a cycle of parents, makes each router throw a `RangeError`.
+   */
+  readonly parent?: string;
 }
 
 /** One end of an edge: a node, and optionally one plug of that node. */
@@ -56,6 +62,8 @@ export interface Graph {
 export interface Route {
   readonly edge: string;
   readonly points: readonly Point[];
+  /** This id names the frame of an inner route: the route stays inside the box of that node. An outer route has no frame. */
+  readonly frame?: string;
 }
 
 /**
@@ -194,3 +202,62 @@ export function fixedPortPoint(node: Node, end: End): Point | undefined {
   if (at === undefined) return undefined;
   return { x: node.box.x + at.x, y: node.box.y + at.y };
 }
+
+/**
+ * An inner edge: an edge from a plug of a frame to a node in that frame, at any depth.
+ * `plug` tells which end of the edge is the plug of the frame.
+ */
+export interface InnerEdge {
+  readonly edge: Edge;
+  readonly frame: string;
+  readonly plug: "source" | "target";
+}
+
+/** This function throws a `RangeError` when the parent of a node names no node, or when the parents of a node make a cycle. */
+export function checkParents(graph: Graph, byId: ReadonlyMap<string, Node> = nodeIndex(graph)): void {
+  const done = new Set<string>();
+  for (const n of graph.nodes) {
+    const seen = new Set<string>();
+    for (let m: Node | undefined = n; m?.parent !== undefined && !done.has(m.id); ) {
+      seen.add(m.id);
+      const p = byId.get(m.parent);
+      if (!p) throw new RangeError(`The parent "${m.parent}" of the node "${m.id}" names no node of the graph.`);
+      if (seen.has(p.id)) throw new RangeError(`The parents of the node "${n.id}" make a cycle through the node "${p.id}".`);
+      m = p;
+    }
+    for (const id of seen) done.add(id);
+  }
+}
+
+/** This function tells if the node `frame` holds the node `id`, at any depth. A node does not hold itself. */
+function holds(byId: ReadonlyMap<string, Node>, frame: string, id: string): boolean {
+  for (let p = byId.get(id)?.parent; p !== undefined; p = byId.get(p)?.parent) if (p === frame) return true;
+  return false;
+}
+
+/**
+ * This function checks the parents of a graph (`checkParents`), and takes its inner edges out.
+ * An inner edge of the frame F has a plug of F (`End.port`) at one end. F holds the node at the other end.
+ * The graph that it gives keeps each node and the other edges. A graph without `parent` comes back as the same object, with no inner edge.
+ */
+export function splitFrames(graph: Graph): { readonly graph: Graph; readonly inner: readonly InnerEdge[] } {
+  if (!graph.nodes.some((n) => n.parent !== undefined)) return { graph, inner: [] };
+  const byId = nodeIndex(graph);
+  checkParents(graph, byId);
+  const inner: InnerEdge[] = [];
+  const edges = graph.edges.filter((e) => {
+    if (e.source.port !== undefined && holds(byId, e.source.node, e.target.node)) inner.push({ edge: e, frame: e.source.node, plug: "source" });
+    else if (e.target.port !== undefined && holds(byId, e.target.node, e.source.node)) inner.push({ edge: e, frame: e.target.node, plug: "target" });
+    else return true;
+    return false;
+  });
+  return { graph: inner.length === 0 ? graph : { ...graph, edges }, inner };
+}
+
+/**
+ * This function gives the graph of a router without frames. It has the plugs of `resolvePorts`, and no inner edges (`splitFrames`).
+ * Each router except `corners` uses it at the start of `route`. So an inner edge gets no route from such a router.
+ */
+export function outerGraph(graph: Graph): Graph {
+  return splitFrames(resolvePorts(graph)).graph;
+}

package/src/plugs/fix.ts

@@ -0,0 +1,112 @@
+/**
+ * Fixed ports from a plug rule (FIX-PORTS): the plugs of the rule become the fixed `at` of the ports.
+ * Then each router takes each plug rule, because each router keeps a fixed plug at its point.
+ */
+import { nearestSide, SIDE_NORMAL, type Plug } from "../plugs.ts";
+import { nodeIndex, portOffset, resolvePorts, splitFrames, type Edge, type End, type Graph, type Node, type Port, type Side } from "../model.ts";
+import { STRATEGIES } from "../strategies/builtins.ts";
+import { getStrategy, type Registry, type Strategy } from "../strategies/model.ts";
+import { WayFinder, type WayOptions } from "../ways.ts";
+
+/** The options of `fixPorts`. */
+export interface FixPortsOptions {
+  /** The options of the plug rule. The rule gets its `defaults` for each option that this object does not give. */
+  readonly plugOptions?: object;
+  /** The registry that gives the rule by its name. The default is `STRATEGIES`. */
+  readonly registry?: Registry;
+  /** The options of the way finder that a rule reads, for example `side`. The defaults are the defaults of the router `corners`. */
+  readonly ways?: WayOptions;
+  /**
+   * With `true`, an end without a port gets a new fixed port, with the id `<edge id>:source` or `<edge id>:target`.
+   * The default is `false`: such an end stays free.
+   */
+  readonly newPorts?: boolean;
+}
+
+/** This function gives the side of a plug from its normal. */
+function sideOf(plug: Plug, node: Node): Side {
+  for (const [side, n] of Object.entries(SIDE_NORMAL) as [Side, { x: number; y: number }][]) if (n.x === plug.normal.x && n.y === plug.normal.y) return side;
+  return nearestSide(node.box, plug.point);
+}
+
+/** This function gives an id that no port of the node has, from `base`. */
+function freeId(taken: Set<string>, base: string): string {
+  let id = base;
+  for (let i = 2; taken.has(id); i++) id = `${base}#${i}`;
+  taken.add(id);
+  return id;
+}
+
+/**
+ * This function runs the plug rule. It gives each free port a fixed `at` and a `side` from the plugs of the rule.
+ * A free port has no `at` and no `along`. A port of several ends takes the plug of its first end, in the order of the edges.
+ * A fixed port keeps its values, and a port of no edge stays free.
+ *
+ * The rule sees the graph of `corners`: the plugs of `resolvePorts`, without the inner edges of the frames.
+ * The rule is a strategy of the step `plugs`, or the name of one in the registry.
+ * The output is a new graph. The function does not change the input.
+ */
+export function fixPorts(graph: Graph, rule: Strategy<"plugs"> | string, options: FixPortsOptions = {}): Graph {
+  const strategy = typeof rule === "string" ? getStrategy(options.registry ?? STRATEGIES, "plugs", rule) : rule;
+  const outer = splitFrames(resolvePorts(graph)).graph;
+  const pairs = strategy.run({ graph: outer, ways: new WayFinder(outer.nodes, options.ways) }, options.plugOptions);
+  const byEdge = new Map<string, (typeof pairs)[number][]>();
+  for (const p of pairs) {
+    const list = byEdge.get(p.edge);
+    if (list) list.push(p);
+    else byEdge.set(p.edge, [p]);
+  }
+  const byId = nodeIndex(graph);
+  // The new fixed ports of each node, by the port id, and the new ports for the ends without a port.
+  const fixed = new Map<string, Map<string, Port>>();
+  const added = new Map<string, Port[]>();
+  const taken = new Map<string, Set<string>>();
+  const portsOf = (node: Node): Map<string, Port> => {
+    let m = fixed.get(node.id);
+    if (!m) fixed.set(node.id, (m = new Map()));
+    return m;
+  };
+  const fix = (node: Node, plug: Plug, base: Port): Port => ({
+    ...base,
+    side: sideOf(plug, node),
+    at: { x: plug.point.x - node.box.x, y: plug.point.y - node.box.y },
+  });
+  // The outer graph has the edge objects of the input. An inner edge keeps its ends, because the rule did not see it.
+  const outerEdges = new Set(outer.edges);
+  const edges = graph.edges.map((e): Edge => {
+    if (!outerEdges.has(e)) return e;
+    const pair = byEdge.get(e.id)?.shift();
+    if (!pair) return e;
+    const end = (which: "source" | "target", plug: Plug): End => {
+      const own = e[which];
+      const node = byId.get(own.node);
+      if (!node) return own;
+      if (own.port === undefined) {
+        if (!options.newPorts) return own;
+        let ids = taken.get(node.id);
+        if (!ids) taken.set(node.id, (ids = new Set((node.ports ?? []).map((p) => p.id))));
+        const id = freeId(ids, `${e.id}:${which}`);
+        const list = added.get(node.id) ?? [];
+        list.push(fix(node, plug, { id }));
+        added.set(node.id, list);
+        return { ...own, port: id };
+      }
+      const port = node.ports?.find((p) => p.id === own.port);
+      if (!port || portOffset(node.box, port) !== undefined) return own;
+      const m = portsOf(node);
+      if (!m.has(port.id)) m.set(port.id, fix(node, plug, port));
+      return own;
+    };
+    const source = end("source", pair.source);
+    const target = end("target", pair.target);
+    return source === e.source && target === e.target ? e : { ...e, source, target };
+  });
+  const nodes = graph.nodes.map((n): Node => {
+    const m = fixed.get(n.id);
+    const more = added.get(n.id);
+    if (!m && !more) return n;
+    const ports = (n.ports ?? []).map((p) => m?.get(p.id) ?? p);
+    return { ...n, ports: more ? [...ports, ...more] : ports };
+  });
+  return { ...graph, nodes, edges };
+}

package/src/plugs/justify.ts

@@ -3,6 +3,11 @@
  * They move the least distance from their ideal places.
  */
 
+import { center, type Point } from "../geom.ts";
+import { fixedPortPoint, nodeIndex, type Edge, type Node } from "../model.ts";
+import { placePlug, type Plug } from "../plugs.ts";
+import type { PlugInput, PlugPair } from "../strategies/model.ts";
+
 /**
  * This function places `ideal.length` points on the segment from `lo` to `hi` of one side.
  * The points keep the order of their ideal places. Two neighbours are at least `gap` apart, or the side divided evenly when it is too short.
@@ -46,3 +51,64 @@ export function isotonic(v: readonly number[]): number[] {
   });
   return out;
 }
+
+/**
+ * This function moves the free plugs of each side of each node, so that two of them are at least `gap` apart (`justifyPlugs`).
+ * The plugs keep their order on the side. Two plugs at one place take the order of their other ends. A fixed plug does not move.
+ * A plug stays `inset` from the corners of its side, or a quarter of the side when the side is short.
+ */
+export function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number, inset = 6): void {
+  // The free plugs of each side: the index of the edge, the end (3 for the source, 4 for the target) and the point of the other end.
+  const sides = new Map<string, { node: Node; normal: Point; items: [number, 3 | 4, Point][] }>();
+  ends.forEach(([e, s, t, ps, pt], i) => {
+    for (const [end, node, plug, other, k] of [
+      [e.source, s, ps, pt, 3],
+      [e.target, t, pt, ps, 4],
+    ] as const) {
+      if (fixedPortPoint(node, end) !== undefined) continue;
+      const key = JSON.stringify([node.id, plug.normal.x, plug.normal.y]);
+      let side = sides.get(key);
+      if (!side) sides.set(key, (side = { node, normal: plug.normal, items: [] }));
+      side.items.push([i, k, other.point]);
+    }
+  });
+  for (const { node, normal, items } of sides.values()) {
+    if (items.length < 2) continue;
+    const along = normal.x !== 0 ? "y" : "x";
+    const b = node.box;
+    const start = along === "y" ? b.y : b.x;
+    const len = along === "y" ? b.h : b.w;
+    const m = Math.min(inset, len / 4);
+    const ideal = items.map(([i, k]) => ends[i]![k].point[along]);
+    const placed = justifyPlugs(ideal, start + m, start + len - m, gap, (j) => items[j]![2][along]);
+    items.forEach(([i, k], j) => {
+      const old = ends[i]![k];
+      ends[i]![k] = { point: along === "y" ? { x: old.point.x, y: placed[j]! } : { x: placed[j]!, y: old.point.y }, normal: old.normal };
+    });
+  }
+}
+
+/** The options of the plug strategy `justify`. */
+export interface JustifyOptions {
+  /** The least gap between two free plugs of one side. The default is 8. 0 keeps each plug where it faces. */
+  readonly plugGap?: number;
+}
+
+/**
+ * This function gives the plugs of the plug strategy `justify` (WILD-002): the plugs of `facing`, then the gaps of `spacePlugs`.
+ * The router `corners` with the option `plugGap` gives the same plugs.
+ */
+export function justifyEnds(input: PlugInput, options: JustifyOptions = {}): PlugPair[] {
+  const { graph } = input;
+  const byId = nodeIndex(graph);
+  const ends: [Edge, Node, Node, Plug, Plug][] = [];
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    ends.push([e, s, t, placePlug(s, e.source, center(t.box)), placePlug(t, e.target, center(s.box))]);
+  }
+  const gap = options.plugGap ?? 8;
+  if (gap > 0) spacePlugs(ends, gap);
+  return ends.map(([e, , , source, target]) => ({ edge: e.id, source, target }));
+}

package/src/plugs/row-cards.ts

@@ -0,0 +1,46 @@
+/**
+ * A made-up board of cards with rows (PLUG-SPREAD, FIX-PORTS): each row of a card links to one row of another card.
+ * The tests of the plug rules read it.
+ */
+import type { Edge, Graph, Node, Port } from "../model.ts";
+
+/** The options of `rowCardsBoard`. */
+export interface RowCardsOptions {
+  /** The number of columns of cards. The default is 3. */
+  readonly columns?: number;
+  /** The number of cards. The default is 6. */
+  readonly cards?: number;
+  /** The number of rows of each card. The default is 20. */
+  readonly rows?: number;
+  /** The height of one row. The default is 12. */
+  readonly rowHeight?: number;
+}
+
+/**
+ * This function gives a board of cards with rows. Each row has a free port `o<row>` for its link out and a free port `i<row>` for a link in.
+ * The row `r` of the card `c` links to the card `(c + 1 + r mod 5) mod cards`. Each card takes its links in on its rows in order.
+ * With the defaults, the board has 6 cards and 120 edges, and each card is 160 by 240.
+ */
+export function rowCardsBoard(options: RowCardsOptions = {}): Graph {
+  const columns = options.columns ?? 3;
+  const count = options.cards ?? 6;
+  const rows = options.rows ?? 20;
+  const rowHeight = options.rowHeight ?? 12;
+  const w = 160;
+  const h = rows * rowHeight;
+  const nodes: Node[] = [];
+  for (let c = 0; c < count; c++) {
+    const ports: Port[] = [];
+    for (let r = 0; r < rows; r++) ports.push({ id: `o${r}` }, { id: `i${r}` });
+    nodes.push({ id: `card${c}`, box: { x: (c % columns) * (w + 160), y: Math.floor(c / columns) * (h + 160), w, h }, ports });
+  }
+  const taken = new Array<number>(count).fill(0);
+  const edges: Edge[] = [];
+  for (let c = 0; c < count; c++)
+    for (let r = 0; r < rows; r++) {
+      const t = (c + 1 + (r % Math.min(5, count - 1))) % count;
+      const row = taken[t]!++ % rows;
+      edges.push({ id: `card${c}.r${r}`, source: { node: `card${c}`, port: `o${r}` }, target: { node: `card${t}`, port: `i${row}` } });
+    }
+  return { nodes, edges };
+}

package/src/plugs/side.ts

@@ -3,10 +3,11 @@
  * Thus the first leg goes straight out to the first corner of the way, and the plug is the foot of that leg.
  */
 import { center, dist, type Box, type Point } from "../geom.ts";
-import { fixedPortPoint, type End, type Node, type Side } from "../model.ts";
+import { fixedPortPoint, nodeIndex, type End, type Node, type Side } from "../model.ts";
 import { placePlug, pointOnSide, SIDE_NORMAL, sideToward, type Plug } from "../plugs.ts";
+import type { PlugInput, PlugPair } from "../strategies/model.ts";
 import type { Terminal } from "../visibility.ts";
-import type { WayFinder } from "../ways.ts";
+import { WayFinder } from "../ways.ts";
 
 /** The options of `sidePlugs`. */
 export interface SidePlugOptions {
@@ -136,3 +137,23 @@ export function sidePlugs(ways: WayFinder, s: Node, es: End, t: Node, et: End, o
   if (!way) return [ps, pt];
   return [from[way.from]!.plug, to[way.to]!.plug];
 }
+
+/**
+ * This function gives the plugs of the plug strategy `side` (WILD-001): the plugs of `sidePlugs` for each edge.
+ * It uses the way finder of the input, or a way finder with the default margin when the input has none.
+ * The router `corners` with the option `plugs: "side"` gives the same plugs.
+ */
+export function sideEnds(input: PlugInput, options: SidePlugOptions = {}): PlugPair[] {
+  const { graph } = input;
+  const byId = nodeIndex(graph);
+  const ways = input.ways ?? new WayFinder(graph.nodes);
+  const out: PlugPair[] = [];
+  for (const e of graph.edges) {
+    const s = byId.get(e.source.node);
+    const t = byId.get(e.target.node);
+    if (!s || !t) continue;
+    const [source, target] = sidePlugs(ways, s, e.source, t, e.target, options);
+    out.push({ edge: e.id, source, target });
+  }
+  return out;
+}