@mark1russell7/highways 0.9.2 → 0.9.3

package/package.json

@@ -9,7 +9,7 @@
     "directory": "packages/core"
   },
   "homepage": "https://mark1russell7.github.io/highways/",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "type": "module",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

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/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;
+}

package/src/plugs/spread/index.ts

@@ -0,0 +1,217 @@
+/**
+ * The plug strategy `spread` (PLUG-SPREAD): the free plugs of each wall share the room of that wall with a minimum gap.
+ * The order on the wall keeps the order of the far ends, so two routes do not cross at the wall. No plug drops.
+ */
+import { center, type Box, type Point } from "../../geom.ts";
+import { nodeIndex, portOffset, type End, type Node, type Side } from "../../model.ts";
+import { nearestSide, placePlug, SIDE_NORMAL, sideToward, type Plug } from "../../plugs.ts";
+import type { PlugInput, PlugPair } from "../../strategies/model.ts";
+import { isotonic } from "../justify.ts";
+
+/** The options of the plug strategy `spread`. */
+export interface SpreadOptions {
+  /** The least gap between two plugs of one wall. When the room of the wall is too small, the gap shrinks evenly. The default is 8. */
+  readonly plugGap?: number;
+  /** The distance from a plug to a corner of its box, or a quarter of the wall when the wall is short. The default is 6. */
+  readonly inset?: number;
+  /** The number of passes that sort each wall again by the new places of the far ends. The default is 2. */
+  readonly rounds?: number;
+}
+
+/** The defaults of the plug strategy `spread`. */
+export const SPREAD_DEFAULTS: Required<SpreadOptions> = Object.freeze({ plugGap: 8, inset: 6, rounds: 2 });
+
+/** A free plug: one port of a node, or one end without a port. All the ends of one port share its plug. */
+interface Slot {
+  readonly node: Node;
+  readonly side: Side;
+  /** The place of the plug that faces the far end (`placePlug`), on the axis along the wall. */
+  readonly ideal: number;
+  /** The index of the port in the ports of its node, then the index of the slot. Thus the rows of a card keep their order in a tie. */
+  readonly rank: readonly [number, number];
+  /** The far end of the first end of the slot: a fixed plug, or the key of its slot. */
+  far?: Plug | string;
+  /** The place of the plug on the axis along the wall. */
+  at: number;
+}
+
+/** A wall: one side of one node, with its free slots and the places of its fixed plugs on the axis along the wall. */
+interface Wall {
+  readonly node: Node;
+  readonly side: Side;
+  readonly slots: Slot[];
+  readonly fixed: number[];
+}
+
+/** This function gives the axis along a side. */
+function alongOf(side: Side): "x" | "y" {
+  return side === "east" || side === "west" ? "y" : "x";
+}
+
+/** This function gives the room of a wall: the segment of the axis along the side, without the corner insets. */
+function roomOf(box: Box, side: Side, inset: number): [number, number] {
+  const along = alongOf(side);
+  const start = along === "y" ? box.y : box.x;
+  const len = along === "y" ? box.h : box.w;
+  const m = Math.min(inset, len / 4);
+  return [start + m, start + len - m];
+}
+
+/** This function gives the point of a side at `v` on the axis along the side. */
+function pointAt(box: Box, side: Side, v: number): Point {
+  if (side === "east") return { x: box.x + box.w, y: v };
+  if (side === "west") return { x: box.x, y: v };
+  if (side === "south") return { x: v, y: box.y + box.h };
+  return { x: v, y: box.y };
+}
+
+/**
+ * This function gives the sort key of a far point on a wall. The key has the order of the angle from the normal of the wall, from the center of the box.
+ * The key grows in the direction of the axis along the wall. Thus the plugs in the order of the keys do not cross at the wall.
+ */
+function keyOf(box: Box, side: Side, far: Point): number {
+  const c = center(box);
+  const n = SIDE_NORMAL[side];
+  const dx = far.x - c.x;
+  const dy = far.y - c.y;
+  const out = dx * n.x + dy * n.y;
+  const along = alongOf(side) === "y" ? dy : dx;
+  // A pseudo-angle with the order of the angle: a sum and one division, with no transcendental call. It goes from -2 to 2.
+  const size = Math.abs(out) + Math.abs(along);
+  if (size === 0) return 0;
+  const p = along / size;
+  if (out >= 0) return p;
+  return along >= 0 ? 2 - p : -2 - p;
+}
+
+/**
+ * This function places `ideal.length` plugs in their given order on the segment from `lo` to `hi`. Two neighbours are at least `gap` apart.
+ * The gap shrinks evenly when the segment is too short. The sum of the squares of the moves from the ideal places is the least.
+ */
+function placeInOrder(ideal: readonly number[], lo: number, hi: number, gap: number): number[] {
+  const k = ideal.length;
+  if (k === 0) return [];
+  const s = k > 1 ? Math.max(0, Math.min(gap, (hi - lo) / (k - 1))) : 0;
+  const y = isotonic(ideal.map((v, i) => v - i * s));
+  const top = Math.max(lo, hi - (k - 1) * s);
+  return y.map((v, i) => Math.max(lo, Math.min(top, v)) + i * s);
+}
+
+/**
+ * This function places the slots of one wall in their order. The fixed plugs cut the room into parts.
+ * Each slot goes into the part of its ideal place, and the parts keep the order of the slots. In each part, two plugs and a plug and a fixed plug are at least `gap` apart.
+ * The gap of a part shrinks evenly when the part is too short.
+ */
+function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number, hi: number, gap: number): void {
+  const cuts = [...new Set(fixed.filter((f) => f > lo - 1e-9 && f < hi + 1e-9))].sort((a, b) => a - b);
+  // The part i is from cuts[i - 1] to cuts[i]. The first part starts at lo, and the last part ends at hi.
+  const ends = [lo, ...cuts, hi];
+  const parts: Slot[][] = cuts.map(() => []).concat([[]]);
+  let part = 0;
+  for (const s of slots) {
+    let p = 0;
+    while (p < cuts.length && s.ideal > cuts[p]!) p++;
+    part = Math.max(part, p);
+    parts[part]!.push(s);
+  }
+  parts.forEach((list, p) => {
+    if (list.length === 0) return;
+    const a = ends[p]!;
+    const b = ends[p + 1]!;
+    const fa = p > 0 ? 1 : 0;
+    const fb = p < cuts.length ? 1 : 0;
+    const steps = list.length - 1 + fa + fb;
+    const s = steps > 0 ? Math.max(0, Math.min(gap, (b - a) / steps)) : gap;
+    const lower = a + fa * s;
+    const upper = Math.max(lower, b - fb * s);
+    const at = placeInOrder(
+      list.map((x) => x.ideal),
+      lower,
+      upper,
+      s,
+    );
+    list.forEach((x, i) => {
+      x.at = at[i]!;
+    });
+  });
+}
+
+/**
+ * This function gives the plugs of the plug strategy `spread`. A fixed plug stays at its point, and a plug with a side stays on that side.
+ * Each free plug goes on the side that faces the other end (`sideToward`). Then the free plugs of each wall share its room with at least `plugGap` between two of them.
+ * They keep the order of their far ends. The ends of one port share one plug.
+ *
+ * The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export function spreadEnds(input: PlugInput, options: SpreadOptions = {}): PlugPair[] {
+  const { graph } = input;
+  const gap = options.plugGap ?? SPREAD_DEFAULTS.plugGap;
+  const inset = options.inset ?? SPREAD_DEFAULTS.inset;
+  const rounds = options.rounds ?? SPREAD_DEFAULTS.rounds;
+  const byId = nodeIndex(graph);
+  const slots = new Map<string, Slot>();
+  const walls = new Map<string, Wall>();
+  // The plug of each end: a fixed plug, or the key of its slot.
+  const ends: { edge: string; source: Plug | string; target: Plug | string }[] = [];
+  const wallOf = (node: Node, side: Side): Wall => {
+    const key = JSON.stringify([node.id, side]);
+    let wall = walls.get(key);
+    if (!wall) {
+      const fixed: number[] = [];
+      for (const p of node.ports ?? []) {
+        const at = portOffset(node.box, p);
+        if (at === undefined) continue;
+        const point = { x: node.box.x + at.x, y: node.box.y + at.y };
+        if ((p.side ?? nearestSide(node.box, point)) === side) fixed.push(point[alongOf(side)]);
+      }
+      walls.set(key, (wall = { node, side, slots: [], fixed }));
+    }
+    return wall;
+  };
+  const plugOf = (node: Node, end: End, far: Node): Plug | string => {
+    const toward = center(far.box);
+    const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
+    if (port && portOffset(node.box, port) !== undefined) return placePlug(node, end, toward);
+    const key = port ? JSON.stringify([node.id, port.id]) : JSON.stringify([node.id, slots.size]);
+    if (slots.has(key)) return key;
+    const side = port?.side ?? sideToward(node.box, toward);
+    const ideal = placePlug(node, end, toward).point[alongOf(side)];
+    const slot: Slot = { node, side, ideal, rank: [port ? node.ports!.indexOf(port) : -1, slots.size], at: ideal };
+    slots.set(key, slot);
+    wallOf(node, side).slots.push(slot);
+    return key;
+  };
+  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 = plugOf(s, e.source, t);
+    const target = plugOf(t, e.target, s);
+    for (const [own, far] of [
+      [source, target],
+      [target, source],
+    ] as const) {
+      const slot = typeof own === "string" ? slots.get(own)! : undefined;
+      if (slot && slot.far === undefined) slot.far = far;
+    }
+    ends.push({ edge: e.id, source, target });
+  }
+  const resolve = (p: Plug | string): Plug => {
+    if (typeof p !== "string") return p;
+    const s = slots.get(p)!;
+    return { point: pointAt(s.node.box, s.side, s.at), normal: SIDE_NORMAL[s.side] };
+  };
+  // A pass sorts each wall by the places of the far ends as they are now, and places its plugs. A tie keeps the order of the last pass.
+  const order = new Map<Slot, number>();
+  for (let round = 0; round <= rounds; round++) {
+    for (const wall of walls.values()) {
+      const [lo, hi] = roomOf(wall.node.box, wall.side, inset);
+      const keys = new Map<Slot, number>(wall.slots.map((s) => [s, keyOf(wall.node.box, wall.side, resolve(s.far!).point)]));
+      const tie = (a: Slot, b: Slot): number => (round === 0 ? a.rank[0] - b.rank[0] || a.rank[1] - b.rank[1] : order.get(a)! - order.get(b)!);
+      const sorted = [...wall.slots].sort((a, b) => keys.get(a)! - keys.get(b)! || tie(a, b));
+      sorted.forEach((s, i) => order.set(s, i));
+      placeWall(sorted, wall.fixed, lo, hi, gap);
+    }
+  }
+  return ends.map((x) => ({ edge: x.edge, source: resolve(x.source), target: resolve(x.target) }));
+}

package/src/routers/corners.ts

@@ -1,7 +1,7 @@
-import { center, type Point } from "../geom.ts";
-import { nodeIndex, fixedPortPoint, resolvePorts, splitFrames, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
+import { center } from "../geom.ts";
+import { nodeIndex, resolvePorts, splitFrames, type Edge, type Graph, type Node, type Result, type Route, type Router } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
-import { justifyPlugs } from "../plugs/justify.ts";
+import { spacePlugs } from "../plugs/justify.ts";
 import { sidePlugs } from "../plugs/side.ts";
 import type { PlugPair, Strategy } from "../strategies/model.ts";
 import { WayFinder } from "../ways.ts";
@@ -98,39 +98,3 @@ function plugsByEdge(list: readonly PlugPair[]): Map<string, PlugPair[]> {
   }
   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.
- */
-function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number): void {
-  const inset = 6;
-  // 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 };
-    });
-  }
-}

package/src/strategies/builtins.ts

@@ -74,6 +74,9 @@ import { ZIPPER_DEFAULTS, zipperPlan, type ZipperOptions } from "../highways/zip
 import { depthLevels, type DepthLevelOptions } from "../levels/depths/index.ts";
 import type { Graph, Result, Router } from "../model.ts";
 import { facingEnds } from "../plugs/facing/index.ts";
+import { justifyEnds, type JustifyOptions } from "../plugs/justify.ts";
+import { sideEnds, type SidePlugOptions } from "../plugs/side.ts";
+import { SPREAD_DEFAULTS, spreadEnds, type SpreadOptions } from "../plugs/spread/index.ts";
 import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
 import { levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
 import { cornersRouter, type CornersOptions } from "../routers/corners.ts";
@@ -87,7 +90,7 @@ import { runPipeline, type PipelineOptions } from "../whole/pipeline/index.ts";
 import { createRegistry, defineStrategy, type AnyStrategy, type CurveInput, type LaneBoard, type Registry, type Strategy } from "./model.ts";
 import type { OptionSchema } from "./options.ts";
 import { AREA_SCHEMA, CONFLUENT_SCHEMA, CROSSBAR_SCHEMA, FRECHET_SCHEMA, MLSEB_SCHEMA, POWER_SCHEMA, SBEB_SCHEMA } from "./schemas.ts";
-import { DEPTHS_SCHEMA, PIPELINE_SCHEMA } from "./schemas.ts";
+import { DEPTHS_SCHEMA, JUSTIFY_SCHEMA, PIPELINE_SCHEMA, SIDE_PLUG_SCHEMA, SPREAD_SCHEMA } from "./schemas.ts";
 import { CLOTHOID_SCHEMA, CORNERS_SCHEMA, CORRIDOR_SCHEMA, CONSENSUS_SCHEMA, CUBU_SCHEMA, CUT_SCHEMA, DIFFUSION_SCHEMA, DIVIDED_SCHEMA, EDGE_PATH_SCHEMA, FDEB_SCHEMA, FLOW_CLUSTER_SCHEMA, FLOW_FIELD_SCHEMA, GROWTH_SCHEMA, HDBSCAN_SCHEMA, HIERARCHY_SCHEMA, HIGHWAY_SCHEMA, HOUGH_SCHEMA, HUB_ARC_SCHEMA, KD_SCHEMA, KDEEB_SCHEMA, KEY_SCHEMA, LANES_SCHEMA, LEVEL_HIGHWAY_SCHEMA, LEVEL_ROOM_SCHEMA, LINK_COMMUNITY_SCHEMA, MEET_SCHEMA, MESH_SCHEMA, MINGLE_SCHEMA, NESTED_SCHEMA, OD_CELL_SCHEMA, P_HUB_SCHEMA, QUICKBUNDLES_SCHEMA, RADIUS_SCHEMA, RESISTANCE_SCHEMA, RIDGE_SCHEMA, ROAD_CLASS_SCHEMA, ROOM_SCHEMA, SCALE_SPACE_SCHEMA, SECTION_SCHEMA, SELECT_SCHEMA, SECTIONS_SCHEMA, SHARED_ALL_SCHEMA, SHARED_SCHEMA, SMOOTH_SCHEMA, SOFT_KEY_SCHEMA, SPECTRAL_SCHEMA, SPIRAL_SCHEMA, STUB_SCHEMA, TENSION_SCHEMA, TERRITORY_SCHEMA, TRACLUS_SCHEMA, TRUNKS_SCHEMA, WEISZFELD_SCHEMA, WSPD_SCHEMA, ZIPPER_SCHEMA, STEINER_SCHEMA, GAP_SCHEMA, STREET_SCHEMA, SEARCH_SCHEMA, INTERCHANGE_SCHEMA } from "./schemas.ts";
 
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
@@ -957,6 +960,9 @@ export const highwayStrategies: {
 /** The built-in plug rules: the strategies of the step `plugs`. The router `corners` routes between their plugs with its option `plug`. */
 export const plugStrategies: {
   readonly facing: Strategy<"plugs", object>;
+  readonly side: Strategy<"plugs", SidePlugOptions>;
+  readonly justify: Strategy<"plugs", JustifyOptions>;
+  readonly spread: Strategy<"plugs", SpreadOptions>;
 } = Object.freeze({
   facing: defineStrategy({
     step: "plugs",
@@ -966,6 +972,30 @@ export const plugStrategies: {
     schema: {},
     run: (input) => facingEnds(input),
   }),
+  side: defineStrategy<"plugs", SidePlugOptions>({
+    step: "plugs",
+    name: "side",
+    describe: "WILD-001. The search of a route starts from the whole free side, and the plug goes where the way leaves the side. It is `corners` with `plugs: side`.",
+    defaults: { bend: 1, inset: 6, most: 16 },
+    schema: SIDE_PLUG_SCHEMA,
+    run: (input, o) => sideEnds(input, o),
+  }),
+  justify: defineStrategy<"plugs", JustifyOptions>({
+    step: "plugs",
+    name: "justify",
+    describe: "WILD-002. The plugs of `facing`, then the free plugs of each side keep their order and a minimum gap. They move the least distance.",
+    defaults: { plugGap: 8 },
+    schema: JUSTIFY_SCHEMA,
+    run: (input, o) => justifyEnds(input, o),
+  }),
+  spread: defineStrategy<"plugs", SpreadOptions>({
+    step: "plugs",
+    name: "spread",
+    describe: "PLUG-SPREAD. The free plugs of each wall share its room with a minimum gap, in the order of their far ends. On a short wall the gap shrinks, and no plug drops.",
+    defaults: { ...SPREAD_DEFAULTS },
+    schema: SPREAD_SCHEMA,
+    run: (input, o) => spreadEnds(input, o),
+  }),
 });
 
 /** The built-in level rules: the strategies of the step `levels`. The router `sections` makes its zoom levels with its option `level`. */

package/src/strategies/schemas.ts

@@ -6,6 +6,9 @@ import type { MlsebOptions } from "../highways/mlseb/index.ts";
 import type { PowerOptions } from "../highways/power/index.ts";
 import type { SbebOptions } from "../highways/sbeb/index.ts";
 import type { CutOptions } from "../groups/cut/index.ts";
+import type { JustifyOptions } from "../plugs/justify.ts";
+import type { SidePlugOptions } from "../plugs/side.ts";
+import type { SpreadOptions } from "../plugs/spread/index.ts";
 import type { KdOptions } from "../groups/kd/index.ts";
 import type { KeyOptions } from "../groups/keys/index.ts";
 import type { HighwayBase } from "../highways/base.ts";
@@ -928,6 +931,25 @@ export const DEPTHS_SCHEMA: OptionSchema<DepthLevelOptions> = {
   levels: SECTIONS_SCHEMA.levels,
 };
 
+/** The declarations of the options of the plug strategy `side` (WILD-001). The defaults are the plugs of `corners` with `plugs: "side"`. */
+export const SIDE_PLUG_SCHEMA: OptionSchema<SidePlugOptions> = {
+  bend: { type: "number", min: 0, max: 4, step: 0.25, default: 1, describe: "The cost of a slant first leg: its length grows by this value times its angle to the normal." },
+  inset: { type: "number", min: 0, max: 12, step: 1, default: 6, describe: "A plug stays this far from the corners of its side." },
+  most: { type: "integer", min: 1, max: 64, step: 1, default: 16, describe: "The largest number of places that the search tries on each side." },
+};
+
+/** The declarations of the options of the plug strategy `justify` (WILD-002). */
+export const JUSTIFY_SCHEMA: OptionSchema<JustifyOptions> = {
+  plugGap: { type: "number", min: 0, max: 24, step: 1, default: 8, describe: "The free plugs of a side keep their order and at least this gap. 0 keeps each plug where it faces." },
+};
+
+/** The declarations of the options of the plug strategy `spread` (PLUG-SPREAD). */
+export const SPREAD_SCHEMA: OptionSchema<SpreadOptions> = {
+  plugGap: { type: "number", min: 0, max: 24, step: 1, default: 8, describe: "The least gap between two plugs of one wall. On a short wall, the gap shrinks evenly." },
+  inset: { type: "number", min: 0, max: 12, step: 1, default: 6, describe: "A plug stays this far from the corners of its wall." },
+  rounds: { type: "integer", min: 0, max: 8, step: 1, default: 2, describe: "The passes that sort each wall again by the new places of the far ends." },
+};
+
 /** The declarations of the options of the whole strategy `pipeline`. */
 export const PIPELINE_SCHEMA: OptionSchema<PipelineOptions> = {
   router: { type: "strategy", step: "router", describe: "The router. A highway plan takes its place." },