@mark1russell7/highways 0.9.5 → 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/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,47 +47,6 @@ 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.
- */
-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 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.
@@ -128,6 +91,7 @@ function placeWall(slots: readonly Slot[], fixed: readonly number[], lo: number,
     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]!;
@@ -138,6 +102,27 @@ 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) => idealOf(x)),
       lower,
@@ -205,7 +190,8 @@ export function spreadWith(input: PlugInput, options: SpreadOptions = {}, leader
     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;

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] };
 }

package/src/strategies/builtins.ts

@@ -83,6 +83,7 @@ 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 { ASSIGN_DEFAULTS, assignEnds, type AssignOptions } from "../plugs/assign/index.ts";
 import { LEADER_DEFAULTS, leaderEnds, type LeaderOptions } from "../plugs/leaders/index.ts";
 import { roomDemand, type RoomMethod, type RoomOptions } from "../room/index.ts";
 import { levelRoom, type LevelRoomOptions } from "../room/levels/index.ts";
@@ -103,7 +104,7 @@ import { TRACING_DEFAULTS, tracing, type TracingOptions } from "../whole/tracing
 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, JUSTIFY_SCHEMA, PIPELINE_SCHEMA, SIDE_PLUG_SCHEMA, SPREAD_SCHEMA, 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, KNEE_SCHEMA, BRONCHIAL_SCHEMA, BOARD_PORTFOLIO_SCHEMA, VENATION_SCHEMA, BALANCE_SCHEMA, MANIFOLD_SCHEMA, LEADER_SCHEMA, DETAIL_SCHEMA, CURRICULUM_SCHEMA, SLOT_SCHEMA, PREFERENCE_SCHEMA, FIREFLY_SCHEMA, TRACING_SCHEMA } from "./schemas.ts";
+import { ASSIGN_SCHEMA, DEPTHS_SCHEMA, JUSTIFY_SCHEMA, PIPELINE_SCHEMA, SIDE_PLUG_SCHEMA, SPREAD_SCHEMA, 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, KNEE_SCHEMA, BRONCHIAL_SCHEMA, BOARD_PORTFOLIO_SCHEMA, VENATION_SCHEMA, BALANCE_SCHEMA, MANIFOLD_SCHEMA, LEADER_SCHEMA, DETAIL_SCHEMA, CURRICULUM_SCHEMA, SLOT_SCHEMA, PREFERENCE_SCHEMA, FIREFLY_SCHEMA, TRACING_SCHEMA } from "./schemas.ts";
 
 /** The options of a router strategy: the options of its router, without the name and the limit of the benchmark. */
 export type RouterPreset<O> = Omit<O, "name" | "maxNodes">;
@@ -1026,6 +1027,7 @@ export const plugStrategies: {
   readonly justify: Strategy<"plugs", JustifyOptions>;
   readonly spread: Strategy<"plugs", SpreadOptions>;
   readonly leaders: Strategy<"plugs", LeaderOptions>;
+  readonly assign: Strategy<"plugs", AssignOptions>;
 } = Object.freeze({
   facing: defineStrategy({
     step: "plugs",
@@ -1067,6 +1069,14 @@ export const plugStrategies: {
     schema: LEADER_SCHEMA,
     run: (input, o) => leaderEnds(input, o),
   }),
+  assign: defineStrategy<"plugs", AssignOptions>({
+    step: "plugs",
+    name: "assign",
+    describe: "PLUG-ASSIGN. The plugs of each wall go into the ranges of their ports with a minimum gap. The most ends are in their range, then the order of the far ends.",
+    defaults: { ...ASSIGN_DEFAULTS },
+    schema: ASSIGN_SCHEMA,
+    run: (input, o) => assignEnds(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

@@ -9,6 +9,7 @@ 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 { AssignOptions } from "../plugs/assign/index.ts";
 import type { LeaderOptions } from "../plugs/leaders/index.ts";
 import type { BalanceOptions } from "../highways/balance/index.ts";
 import type { ManifoldOptions } from "../highways/manifolds/index.ts";
@@ -977,6 +978,12 @@ export const SPREAD_SCHEMA: OptionSchema<SpreadOptions> = {
   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 plug strategy `assign` (PLUG-ASSIGN). */
+export const ASSIGN_SCHEMA: OptionSchema<AssignOptions> = {
+  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." },
+};
+
 /** 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." },