@mark1russell7/highways 0.9.4 → 0.9.6

package/src/plugs/justify.ts

@@ -3,10 +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 { center, type Box, type Point } from "../geom.ts";
+import { fixedPortPoint, nodeIndex, type Edge, type Node, type Port, type Side } from "../model.ts";
 import { placePlug, type Plug } from "../plugs.ts";
 import type { PlugInput, PlugPair } from "../strategies/model.ts";
+import { alongAxis, placeInIntervals, portOfEnd, rangeInterval } from "./range.ts";
 
 /**
  * This function places `ideal.length` points on the segment from `lo` to `hi` of one side.
@@ -56,10 +57,11 @@ export function isotonic(v: readonly number[]): number[] {
  * 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.
+ * A plug of a port with a `range` stays in its range (PORT-RANGE), and the plugs keep their order and the gap (`placeInIntervals`).
  */
 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][] }>();
+  // The free plugs of each side: the index of the edge, the end (3 for the source, 4 for the target), the point of the other end and the port.
+  const sides = new Map<string, { node: Node; normal: Point; items: [number, 3 | 4, Point, Port | undefined][] }>();
   ends.forEach(([e, s, t, ps, pt], i) => {
     for (const [end, node, plug, other, k] of [
       [e.source, s, ps, pt, 3],
@@ -69,18 +71,19 @@ export function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number,
       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]);
+      side.items.push([i, k, other.point, portOfEnd(node, end)]);
     }
   });
   for (const { node, normal, items } of sides.values()) {
-    if (items.length < 2) continue;
+    const ranged = items.some((x) => x[3]?.range !== undefined);
+    if (items.length < 2 && !ranged) 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]);
+    const placed = ranged ? spaceInRanges(b, normal, items, ideal, start + m, start + len - m, gap, inset) : 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 };
@@ -88,6 +91,35 @@ export function spacePlugs(ends: [Edge, Node, Node, Plug, Plug][], gap: number,
   }
 }
 
+/**
+ * This function places the free plugs of one side with ranges (PORT-RANGE). The order is the order of `justifyPlugs`.
+ * Each plug stays in the interval of its range, or in the room of the side without a range.
+ */
+function spaceInRanges(box: Box, normal: Point, items: readonly [number, 3 | 4, Point, Port | undefined][], ideal: readonly number[], lo: number, hi: number, gap: number, inset: number): number[] {
+  const side = sideOfNormal(normal);
+  const along = alongAxis(side);
+  const order = ideal.map((_, i) => i).sort((a, b) => ideal[a]! - ideal[b]! || items[a]![2][along] - items[b]![2][along] || a - b);
+  const span = order.map((j): [number, number] => rangeInterval(box, side, items[j]![3], inset) ?? [lo, hi]);
+  const at = placeInIntervals(
+    order.map((j) => ideal[j]!),
+    span.map((r) => r[0]),
+    span.map((r) => r[1]),
+    gap,
+  );
+  const out = new Array<number>(ideal.length);
+  order.forEach((j, i) => {
+    out[j] = at[i]!;
+  });
+  return out;
+}
+
+/** This function gives the side of an outward normal. */
+function sideOfNormal(n: Point): Side {
+  if (n.x > 0) return "east";
+  if (n.x < 0) return "west";
+  return n.y > 0 ? "south" : "north";
+}
+
 /** 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. */

package/src/plugs/leaders/index.ts

@@ -0,0 +1,42 @@
+/**
+ * The plug strategy `leaders` (EDA-041): boundary leaders of the labeling of maps, used as the stubs of the plugs.
+ * Each wall places its plugs in an order that gives leaders with no crossing, and the least length of the leaders.
+ */
+import type { PlugInput, PlugPair } from "../../strategies/model.ts";
+import { spreadWith, SPREAD_DEFAULTS } from "../spread/index.ts";
+
+/**
+ * The type of leader of a plug. With `s`, the order of a wall is the order of the angles of the far ends, as in `spread`.
+ * With `po`, the stub leaves along the normal and turns once, so the order is the order of the far ends along the wall.
+ * With `opo`, the plugs of a wall go at even places, in the order of the angles.
+ */
+export type LeaderType = "s" | "po" | "opo";
+
+/** The values of `LeaderType`. */
+export const LEADER_TYPES: readonly LeaderType[] = Object.freeze(["s", "po", "opo"]);
+
+/** The options of the plug strategy `leaders`. */
+export interface LeaderOptions {
+  /** The type of leader. The default is `po`. */
+  readonly leader: LeaderType;
+  /** The least gap between two plugs of one wall, from 2 to 8. The default is 8. */
+  readonly slotSpacing: 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, from 0 to 4. The default is 2. */
+  readonly rounds: number;
+}
+
+/** The defaults of the plug strategy `leaders`. */
+export const LEADER_DEFAULTS: Readonly<LeaderOptions> = Object.freeze({ leader: "po", slotSpacing: 8, inset: SPREAD_DEFAULTS.inset, rounds: SPREAD_DEFAULTS.rounds });
+
+/**
+ * This function gives the plugs of the plug strategy `leaders` (EDA-041, after Bekos 2007). 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. The plugs of each wall keep at least `slotSpacing` between two of them.
+ * The type of leader sets their order and their places. The output has one entry for each edge with two known nodes, in the order of the edges.
+ */
+export function leaderEnds(input: PlugInput, options: Partial<LeaderOptions> = {}): PlugPair[] {
+  const o = { ...LEADER_DEFAULTS, ...options };
+  const spread = { plugGap: o.slotSpacing, inset: o.inset, rounds: o.rounds };
+  return spreadWith(input, spread, o.leader === "s" ? undefined : o.leader);
+}

package/src/plugs/range.ts

@@ -0,0 +1,120 @@
+/**
+ * Plug ranges (PORT-RANGE): a free plug of a port with `range` stays in that interval of its side.
+ * The plug rules read the interval of each plug, and place the plugs of a side in their order with a least gap.
+ */
+import type { Box, Point } from "../geom.ts";
+import type { End, Node, Port, Side } from "../model.ts";
+
+/** The tolerance of the comparisons of places along a side. */
+const EPS = 1e-9;
+
+/** This function gives the axis along a side. */
+export function alongAxis(side: Side): "x" | "y" {
+  return side === "east" || side === "west" ? "y" : "x";
+}
+
+/** This function gives the port of an end, or `undefined` when the end has no port or the node has no such port. */
+export function portOfEnd(node: Node, end: End): Port | undefined {
+  return end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
+}
+
+/**
+ * This function gives the interval of a plug with a range, on the axis along its side, or `undefined` for a port without a range.
+ * The interval is the range of the port, without the corner insets of the side.
+ * When the range is all in a corner inset, the interval is the range.
+ */
+export function rangeInterval(box: Box, side: Side, port: Port | undefined, inset = 6): [number, number] | undefined {
+  const range = port?.range;
+  if (range === undefined) return undefined;
+  const along = alongAxis(side);
+  const start = along === "y" ? box.y : box.x;
+  const len = along === "y" ? box.h : box.w;
+  const m = Math.min(inset, len / 4);
+  const lo = start + range[0] * len;
+  const hi = start + range[1] * len;
+  const a = Math.max(lo, start + m);
+  const b = Math.min(hi, start + len - m);
+  return a <= b ? [a, b] : [lo, hi];
+}
+
+/** This function moves a point of a side into the interval of its range, on the axis along the side. A point of a port without a range stays. */
+export function clampToRange(box: Box, side: Side, port: Port | undefined, point: Point, inset = 6): Point {
+  const r = rangeInterval(box, side, port, inset);
+  if (!r) return point;
+  const along = alongAxis(side);
+  const v = Math.max(r[0], Math.min(r[1], point[along]));
+  return along === "y" ? { x: point.x, y: v } : { x: v, y: point.y };
+}
+
+/**
+ * This function places `ideal.length` plugs of one side in their given order. The plug `i` stays in the interval from `lo[i]` to `hi[i]`.
+ * Two neighbours are at least `gap` apart. When the intervals are too short for the gap, the gap shrinks evenly to the largest gap that they let.
+ * The sum of the squares of the moves from the ideal places is the least.
+ *
+ * When the order cannot keep each plug in its interval, the plugs take the order of their ideal places in their intervals. Thus the intervals win over the order.
+ * The result is in the order of `ideal`.
+ */
+export function placeInIntervals(ideal: readonly number[], lo: readonly number[], hi: readonly number[], gap: number): number[] {
+  const k = ideal.length;
+  if (k === 0) return [];
+  let order = ideal.map((_, i) => i);
+  // A later plug with an interval wholly before the interval of an earlier plug breaks the order.
+  let most = -Infinity;
+  let broken = false;
+  for (const i of order) {
+    if (hi[i]! < most - EPS) broken = true;
+    most = Math.max(most, lo[i]!);
+  }
+  if (broken) {
+    const c = order.map((i) => Math.max(lo[i]!, Math.min(hi[i]!, ideal[i]!)));
+    order = [...order].sort((a, b) => c[a]! - c[b]! || a - b);
+  }
+  // The largest gap that the order lets: the plug j and the later plug i need (i - j)·s <= hi_i - lo_j.
+  let s = Math.max(0, gap);
+  for (let i = 1; i < k; i++) {
+    const hiI = hi[order[i]!]!;
+    for (let j = 0; j < i; j++) s = Math.min(s, (hiI - lo[order[j]!]!) / (i - j));
+  }
+  s = Math.max(0, s);
+  // With y_i = x_i - i·s, the gap becomes the rule y_i <= y_(i+1), and each y_i has the bounds L_i and U_i.
+  // The bounds become monotone: L_i is the most of the lower bounds before i, and U_i is the least of the upper bounds after i.
+  const lower = new Array<number>(k);
+  const upper = new Array<number>(k);
+  let run = -Infinity;
+  for (let i = 0; i < k; i++) lower[i] = run = Math.max(run, lo[order[i]!]! - i * s);
+  run = Infinity;
+  for (let i = k - 1; i >= 0; i--) upper[i] = run = Math.min(run, hi[order[i]!]! - i * s);
+  // Pool adjacent violators with bounds. The value of a block is its mean, clamped to the bounds of the block.
+  // The lower bound of a block is the lower bound of its last item, and its upper bound is the upper bound of its first item.
+  const sum: number[] = [];
+  const size: number[] = [];
+  const blockLo: number[] = [];
+  const blockHi: number[] = [];
+  const value: number[] = [];
+  const clamp = (v: number, a: number, b: number): number => Math.max(a, Math.min(b, v));
+  for (let i = 0; i < k; i++) {
+    sum.push(ideal[order[i]!]! - i * s);
+    size.push(1);
+    blockLo.push(lower[i]!);
+    blockHi.push(upper[i]!);
+    value.push(clamp(sum[sum.length - 1]!, lower[i]!, upper[i]!));
+    while (value.length > 1 && value[value.length - 2]! > value[value.length - 1]!) {
+      const t = value.length - 1;
+      sum[t - 1]! += sum[t]!;
+      size[t - 1]! += size[t]!;
+      blockLo[t - 1] = blockLo[t]!;
+      value[t - 1] = clamp(sum[t - 1]! / size[t - 1]!, blockLo[t - 1]!, blockHi[t - 1]!);
+      sum.pop();
+      size.pop();
+      blockLo.pop();
+      blockHi.pop();
+      value.pop();
+    }
+  }
+  const out = new Array<number>(k);
+  let i = 0;
+  value.forEach((v, b) => {
+    for (let j = 0; j < size[b]!; j++, i++) out[order[i]!] = v + i * s;
+  });
+  return out;
+}

package/src/plugs/row-cards.ts

@@ -44,3 +44,45 @@ export function rowCardsBoard(options: RowCardsOptions = {}): Graph {
     }
   return { nodes, edges };
 }
+
+/** The options of `tallCardsBoard`. */
+export interface TallCardsOptions {
+  /** The number of rows of each card. The default is 20. */
+  readonly rows?: number;
+  /** The height of one row. The default is 55. */
+  readonly rowHeight?: number;
+  /** The number of rows that the box of the rows of each card shows. The list repeats for more cards. The default is `[3, 4, 5, 3, 4, 5]`. */
+  readonly visible?: readonly number[];
+  /** The height of the header of a card, above the box of its rows. The default is 40. */
+  readonly header?: number;
+  /** The height of the footer of a card, below the box of its rows. The default is 24. */
+  readonly footer?: number;
+  /** With `true`, each port has the range of its row (PORT-RANGE). The default is `true`. */
+  readonly ranges?: boolean;
+}
+
+/**
+ * This function gives a board of 6 cards with tall rows (PORT-RANGE, PLUG-ASSIGN), in 3 columns and 2 lines. It has the links of `rowCardsBoard`.
+ * The box of the rows of a card is smaller than the card, because the card has a header and a footer. The box shows only some rows.
+ * The port `o<row>` is on the east side, and the port `i<row>` is on the west side.
+ * The range of a port is the reach of its row. It goes from the top of the box of the rows plus half a row to its bottom minus half a row.
+ */
+export function tallCardsBoard(options: TallCardsOptions = {}): Graph {
+  const rows = options.rows ?? 20;
+  const rowHeight = options.rowHeight ?? 55;
+  const visible = options.visible ?? [3, 4, 5, 3, 4, 5];
+  const header = options.header ?? 40;
+  const footer = options.footer ?? 24;
+  const ranged = options.ranges ?? true;
+  const base = rowCardsBoard({ rows });
+  const w = 160;
+  const tall = header + Math.max(...visible) * rowHeight + footer;
+  const nodes = base.nodes.map((n, c): Node => {
+    const v = visible[c % visible.length]!;
+    const h = header + v * rowHeight + footer;
+    const range: [number, number] = [(header + rowHeight / 2) / h, (header + v * rowHeight - rowHeight / 2) / h];
+    const ports = (n.ports ?? []).map((p): Port => ({ id: p.id, side: p.id.startsWith("o") ? "east" : "west", ...(ranged ? { range } : {}) }));
+    return { id: n.id, box: { x: (c % 3) * (w + 200), y: Math.floor(c / 3) * (tall + 160), w, h }, ports };
+  });
+  return { nodes, edges: base.edges };
+}

package/src/plugs/side.ts

@@ -8,6 +8,7 @@ import { placePlug, pointOnSide, SIDE_NORMAL, sideToward, type Plug } from "../p
 import type { PlugInput, PlugPair } from "../strategies/model.ts";
 import type { Terminal } from "../visibility.ts";
 import { WayFinder } from "../ways.ts";
+import { clampToRange, rangeInterval } from "./range.ts";
 
 /** The options of `sidePlugs`. */
 export interface SidePlugOptions {
@@ -50,6 +51,12 @@ function freeSide(node: Node, end: End, toward: Point, inset: number): FreeSide
   const m = Math.min(inset, len / 4);
   const at = side === "east" ? b.x + b.w : side === "west" ? b.x : side === "south" ? b.y + b.h : b.y;
   const point = pointOnSide(b, side, toward, inset);
+  // A port with a range (PORT-RANGE) keeps its plug in the interval of the range.
+  const range = port?.range === undefined ? undefined : rangeInterval(b, side, port, inset);
+  if (range) {
+    const facing = clampToRange(b, side, port, point, inset);
+    return { node, side, normal: SIDE_NORMAL[side], along, at, lo: range[0], hi: range[1], facing: { point: facing, normal: SIDE_NORMAL[side] } };
+  }
   return { node, side, normal: SIDE_NORMAL[side], along, at, lo: start + m, hi: start + len - m, facing: { point, normal: SIDE_NORMAL[side] } };
 }
 

package/src/plugs/spread/index.ts

@@ -7,6 +7,8 @@ import { nodeIndex, portOffset, type End, type Node, type Side } from "../../mod
 import { nearestSide, placePlug, SIDE_NORMAL, sideToward, type Plug } from "../../plugs.ts";
 import type { PlugInput, PlugPair } from "../../strategies/model.ts";
 import { isotonic } from "../justify.ts";
+import { placeInIntervals, rangeInterval } from "../range.ts";
+import { alongOf, keyOf, pointAt, roomOf } from "../walls.ts";
 
 /** The options of the plug strategy `spread`. */
 export interface SpreadOptions {
@@ -29,6 +31,8 @@ interface Slot {
   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 interval of the range of the port on the axis along the wall (PORT-RANGE), or `undefined` for a port without a range. */
+  readonly range?: 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. */
@@ -43,45 +47,18 @@ interface Wall {
   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.
+ * This function gives the sort key of a far point for a po-leader (EDA-041): its place on the axis along the wall.
+ * A far point behind the wall gets the key of `keyOf` with a large shift, so it goes to an end of the wall.
  */
-function keyOf(box: Box, side: Side, far: Point): number {
+function poKeyOf(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;
+  const out = (far.x - c.x) * n.x + (far.y - c.y) * n.y;
+  const along = alongOf(side) === "y" ? far.y : far.x;
+  if (out > 0) return along;
+  const k = keyOf(box, side, far);
+  return k >= 0 ? 1e12 + k : -1e12 + k;
 }
 
 /**
@@ -102,7 +79,7 @@ function placeInOrder(ideal: readonly number[], lo: number, hi: number, gap: num
  * 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 {
+function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number, hi: number, gap: number, idealOf: (s: Slot) => number = (s) => s.ideal): 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];
@@ -110,10 +87,11 @@ function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number,
   let part = 0;
   for (const s of slots) {
     let p = 0;
-    while (p < cuts.length && s.ideal > cuts[p]!) p++;
+    while (p < cuts.length && idealOf(s) > cuts[p]!) p++;
     part = Math.max(part, p);
     parts[part]!.push(s);
   }
+  const ranged = slots.some((s) => s.range !== undefined);
   parts.forEach((list, p) => {
     if (list.length === 0) return;
     const a = ends[p]!;
@@ -124,8 +102,29 @@ function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number,
     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);
+    if (ranged) {
+      // Each plug with a range stays in the part of its range (PORT-RANGE). A range out of the part gives the nearest place of the part.
+      const span = list.map((x): [number, number] => {
+        if (!x.range) return [lower, upper];
+        const lo = Math.max(lower, x.range[0]);
+        const hi = Math.min(upper, x.range[1]);
+        if (lo <= hi) return [lo, hi];
+        const v = x.range[1] < lower ? lower : upper;
+        return [v, v];
+      });
+      const at = placeInIntervals(
+        list.map((x) => idealOf(x)),
+        span.map((r) => r[0]),
+        span.map((r) => r[1]),
+        s,
+      );
+      list.forEach((x, i) => {
+        x.at = at[i]!;
+      });
+      return;
+    }
     const at = placeInOrder(
-      list.map((x) => x.ideal),
+      list.map((x) => idealOf(x)),
       lower,
       upper,
       s,
@@ -144,6 +143,21 @@ function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number,
  * 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[] {
+  return spreadWith(input, options);
+}
+
+/**
+ * The order and the places of the plugs of one wall in the strategy `leaders` (EDA-041).
+ * With `po`, the sort key of a far end in front of the wall is its place on the axis along the wall.
+ * With `opo`, the plugs of a wall go at even places in the order of the keys of `spread`.
+ */
+export type WallLeader = "po" | "opo";
+
+/**
+ * This function does the work of `spreadEnds`, and of the strategy `leaders` with the argument `leader`.
+ * Without `leader`, it gives the plugs of `spread`.
+ */
+export function spreadWith(input: PlugInput, options: SpreadOptions = {}, leader?: WallLeader): PlugPair[] {
   const { graph } = input;
   const gap = options.plugGap ?? SPREAD_DEFAULTS.plugGap;
   const inset = options.inset ?? SPREAD_DEFAULTS.inset;
@@ -176,7 +190,8 @@ export function spreadEnds(input: PlugInput, options: SpreadOptions = {}): PlugP
     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 };
+    const range = rangeInterval(node.box, side, port, inset);
+    const slot: Slot = { node, side, ideal, rank: [port ? node.ports!.indexOf(port) : -1, slots.size], at: ideal, ...(range ? { range } : {}) };
     slots.set(key, slot);
     wallOf(node, side).slots.push(slot);
     return key;
@@ -206,11 +221,16 @@ export function spreadEnds(input: PlugInput, options: SpreadOptions = {}): PlugP
   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 key = leader === "po" ? poKeyOf : keyOf;
+      const keys = new Map<Slot, number>(wall.slots.map((s) => [s, key(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);
+      if (leader === "opo") {
+        // The even places: the plugs split the room into equal parts, so the plug spacing of the wall is the largest that it can be.
+        const even = new Map<Slot, number>(sorted.map((s, i) => [s, lo + ((i + 0.5) * (hi - lo)) / sorted.length]));
+        placeWall(sorted, wall.fixed, lo, hi, gap, (s) => even.get(s)!);
+      } else placeWall(sorted, wall.fixed, lo, hi, gap);
     }
   }
   return ends.map((x) => ({ edge: x.edge, source: resolve(x.source), target: resolve(x.target) }));

package/src/plugs/walls.ts

@@ -0,0 +1,47 @@
+/**
+ * The walls of the plug strategies `spread`, `leaders` and `assign`: one side of one node, its room, and the order of its far ends.
+ */
+import { center, type Box, type Point } from "../geom.ts";
+import type { Side } from "../model.ts";
+import { SIDE_NORMAL } from "../plugs.ts";
+
+/** This function gives the axis along a side. */
+export 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. */
+export 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. */
+export 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.
+ */
+export 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;
+}

package/src/plugs.ts

@@ -1,5 +1,6 @@
 import { center, type Box, type Point } from "./geom.ts";
 import { fixedPortPoint, type End, type Node, type Side } from "./model.ts";
+import { clampToRange } from "./plugs/range.ts";
 
 /** A plug: the point where a route leaves or enters a node, and the outward normal of its side. */
 export interface Plug {
@@ -64,12 +65,13 @@ export function pointOnSide(box: Box, side: Side, toward: Point, inset = 6): Poi
 
 /**
  * This function places the plug of one end of an edge. A fixed plug stays at its point. A plug with a side stays on that side.
- * The router places a free plug on the side that faces `toward`.
+ * The router places a free plug on the side that faces `toward`. A free plug of a port with a `range` stays in that range (`clampToRange`).
  */
 export function placePlug(node: Node, end: End, toward: Point): Plug {
   const fixed = fixedPortPoint(node, end);
   const port = end.port === undefined ? undefined : node.ports?.find((p) => p.id === end.port);
   if (fixed) return { point: fixed, normal: SIDE_NORMAL[port?.side ?? nearestSide(node.box, fixed)] };
   const side = port?.side ?? sideToward(node.box, toward);
-  return { point: pointOnSide(node.box, side, toward), normal: SIDE_NORMAL[side] };
+  const point = pointOnSide(node.box, side, toward);
+  return { point: port?.range === undefined ? point : clampToRange(node.box, side, port, point), normal: SIDE_NORMAL[side] };
 }