@mark1russell7/highways 0.1.4 → 0.2.0

package/build/index.d.ts

@@ -96,6 +96,8 @@ export interface Node {
   readonly id: string;
   readonly box: Box;
   readonly ports?: readonly Port[];
+  /** This data is free for the grouping rules of the nodes. The rule `keys` reads the string `data.group` by default. */
+  readonly data?: Readonly<Record<string, unknown>>;
 }
 /** One end of an edge: a node, and optionally one plug of that node. */
 export interface End {
@@ -652,7 +654,11 @@ export interface SectionOptions {
   readonly cap?: number;
   /** The tree stops at this depth. The default is 16. */
   readonly maxDepth?: number;
+  /** A cell shrinks to one quarter at most this many times without a split. Then it stops. The default is 32. */
+  readonly collapse?: number;
 }
+/** The default values of `SectionOptions`. */
+export declare const SECTION_DEFAULTS: Readonly<Required<SectionOptions>>;
 /**
  * This function makes the tree of sections of the nodes. A cell with more than `cap` nodes splits in four.
  * When the nodes of a cell are all in one quarter, the cell becomes that quarter and does not make a level.
@@ -662,6 +668,55 @@ export declare function buildSections(nodes: readonly Node[], options?: SectionO
 export declare function allSections(root: Section): Section[];
 /** This function gives the depth of the deepest section. */
 export declare function treeDepth(root: Section): number;
+/**
+ * This function examines a tree of sections from a grouping rule. It throws an error when the tree is not valid for `count` nodes.
+ * In a valid tree, each node is in exactly one leaf. The children of a section split its nodes, and a child is one level deeper than its parent.
+ */
+export declare function checkSections(root: Section, count: number): void;
+/**
+ * This function gives the tree of sections of the grouping rule `quadtree`: the cells of a quadtree of the plane (`buildSections`).
+ * It is the default grouping rule of the router `sections`.
+ */
+export declare function quadtreeGroups(graph: Graph, options?: SectionOptions): Section;
+/** A key rule gives the key of the group of a node. A node without a key is a group alone. */
+type NodeKey = (node: Node, index: number) => string | undefined;
+/** The options of the grouping rule `keys`. */
+interface KeyOptions {
+  /** This function gives the key of the group of each node. The default is `byDataGroup`. */
+  readonly key?: NodeKey;
+  /**
+   * With this value, a group with more nodes than its `cap` splits into the cells of a quadtree, as `buildSections` does.
+   * Without it, each group is one leaf. The default is no split.
+   */
+  readonly split?: SectionOptions;
+}
+/** This key rule gives the string `data.group` of the node, or `undefined` when the node has no such string. */
+export declare const byDataGroup: NodeKey;
+/**
+ * This function gives the tree of sections of the grouping rule `keys`. The root holds each node. Each child of the root holds the nodes of one key,
+ * in the order of their first node. The id of a group is `s:` and its key. A node without a key is a group alone, with the id `s#` and its index.
+ * Thus the far view of the router `sections` shows one item for each group.
+ */
+export declare function keyedSections(nodes: readonly Node[], options?: KeyOptions): Section;
+/** This function gives the tree of sections of the grouping rule `keys` for a graph. */
+export declare function keyGroups(graph: Graph, options?: KeyOptions): Section;
+/** This function gives the median width of the shown items of each level, in units of the plane. */
+export declare function itemSizes(levels: readonly Level[]): number[];
+/** The far-view thresholds of `pickLevel`, in pixels on the screen. */
+export interface PickOptions {
+  /** When a node is at least this wide on the screen, the view shows each route. */
+  readonly routesAt: number;
+  /** A level is fine enough when its median item is at least this wide on the screen. */
+  readonly itemAt: number;
+}
+/** The default thresholds: a node of 22 pixels shows its routes, and a group of 120 pixels shows its parts. */
+export declare const PICK: PickOptions;
+/**
+ * This function picks the level that a camera shows at a scale, in pixels for each unit of the plane. The sizes come from `itemSizes`.
+ * The value `sizes.length` stands for the routes of each edge. The last level holds the nodes alone.
+ * Each threshold that `options` does not give gets its value from `PICK`.
+ */
+export declare function pickLevel(sizes: readonly number[], scale: number, options?: Partial<PickOptions>): number;
 /** This function gives the point where the ray from the center of the box to `toward` leaves the box. */
 export declare function boxExit(box: Box, toward: Point): Point;
 /**
@@ -705,73 +760,16 @@ interface SharedOptions extends WayOptions {
  * The result gives each stretch as a run, with the order of its lanes.
  */
 export declare function sharedRouter(options: SharedOptions): Router;
-/** The options of the router with sections. */
-interface SectionsOptions extends WayOptions, SectionOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
+/** The options of the links of a level: the options of the ways, and two limits of the level links. */
+interface LevelLinkOptions extends WayOptions {
   /**
-   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
-   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   * The margin of the second corner graph. A gap between two boxes wider than approximately 1.5 times this margin lets a link through.
+   * The second graph uses the smaller of this value and `margin`. The default is 1.
    */
-  readonly hubs?: number;
-  /** A way through the hubs can be at most this many times as long as the line between its plugs. Else the edge goes directly. The default is 2. */
-  readonly stretch?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
-}
-/**
- * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
- * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
- * Each way from hub to hub is found one time, so all the edges on it share its points.
- * The edges in one section of the lowest level go straight around the nodes.
- *
- * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
- *
- * The result gives one zoom level for each depth of the tree.
- * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
- */
-export declare function sectionsRouter(options: SectionsOptions): Router;
-/** The options of the trunk router. */
-interface TrunksOptions extends WayOptions {
-  /** The name in the benchmark. */
-  readonly name: string;
-  /** The grouping rule. The edges from one plug with one key share a trunk. */
-  readonly rule: GroupRule;
-  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
-  readonly split?: number;
-  /** A group with fewer edges stays unbundled. The default is 2. */
-  readonly minSize?: number;
-  /** The benchmark skips a fixture with more nodes. */
-  readonly maxNodes?: number;
+  readonly tightMargin?: number;
+  /** A plug stays at least this far from the corners of its side. The level links use the smaller of this value and `margin`. The default is 6. */
+  readonly plugInset?: number;
 }
-/** The rule that groups the edges by the collection of their target, in `data.collection`. */
-export declare const byCollection: GroupRule;
-/**
- * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
- * A group with fewer than `minSize` edges does not appear.
- */
-export declare function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize?: number): Map<string, Edge[]>;
-/**
- * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
- * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
- */
-export declare function laneOrder(dir: Point, from: Point, branches: readonly {
-  readonly edge: string;
-  readonly next: Point;
-}[]): string[];
-/**
- * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
- * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
- */
-export declare function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point;
-/**
- * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
- * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
- * The edges outside the groups go as in the corner router.
- */
-export declare function trunksRouter(options: TrunksOptions): Router;
-/** The routers that the benchmark races. */
-export declare const ROUTERS: readonly Router[];
 /** An item with a box: a node of a graph, an item of a level or a box of a host layout. */
 export interface Boxed {
   readonly id: string;
@@ -830,6 +828,12 @@ export interface RoomOptions {
   readonly lanes?: "link" | "count";
   /** Two box edges nearer than this distance make one boundary of the sweep. The default is 0.5. */
   readonly snap?: number;
+  /**
+   * The number of passes of the demand. The default is 1.
+   * Each pass after the first finds the lanes again on the board that the passes before it opened, and adds the growth that it needs.
+   * The limit `maxGrowth` applies to the sum of the passes.
+   */
+  readonly passes?: number;
 }
 /** The demand of a board and the board with its gaps open. */
 export interface Room<T extends Boxed> {
@@ -856,6 +860,232 @@ export declare function roomDemand(items: readonly Boxed[], links: readonly Room
 export declare function makeRoom<T extends Boxed>(items: readonly T[], links: readonly RoomLink[], options?: RoomOptions): Room<T>;
 /** This function gives the links between the nodes of a graph, with the count of the edges of each pair. A loop does not count. */
 export declare function roomLinks(graph: Graph): RoomLink[];
+/** The input of a curve strategy: one polyline and the context of its route. */
+export interface CurveInput {
+  /** These points are the polyline: a route of a router, a lane of `laneRoutes` or a link of a zoom level. */
+  readonly points: readonly Point[];
+  /** The curve leaves the first point along this outward normal of its plug, if the strategy reads it. */
+  readonly startNormal?: Point;
+  /** The curve comes into the last point against this outward normal of its plug, if the strategy reads it. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through, from `curveSpace`. */
+  readonly space?: CurveSpace;
+}
+/** The input of a room strategy: the boxes of a board and the links between them. */
+export interface RoomInput {
+  readonly items: readonly Boxed[];
+  readonly links: readonly RoomLink[];
+}
+/**
+ * The steps that have strategies, with the fixed input and output type of each step.
+ *
+ * - `group`: a graph in, the tree of sections out. The router `sections` makes its hubs and its zoom levels from this tree.
+ * - `router`: a graph in, the routes (and the `levels`, `bundles` and `runs`) out.
+ * - `curve`: a polyline in, the segments of a curve out.
+ * - `room`: the boxes and links of a board in, the gaps of the board with their need out.
+ */
+export interface StepTypes {
+  readonly group: {
+    readonly input: Graph;
+    readonly output: Section;
+  };
+  readonly router: {
+    readonly input: Graph;
+    readonly output: Result;
+  };
+  readonly curve: {
+    readonly input: CurveInput;
+    readonly output: CurveSegment[];
+  };
+  readonly room: {
+    readonly input: RoomInput;
+    readonly output: Gap[];
+  };
+}
+/** The name of a step that has strategies. */
+export type Step = keyof StepTypes;
+/** The input type of a step. */
+export type StepInput<S extends Step> = StepTypes[S]["input"];
+/** The output type of a step. */
+export type StepOutput<S extends Step> = StepTypes[S]["output"];
+/** The steps that have strategies, in the order of the pipeline. */
+export declare const STEPS: readonly Step[];
+/**
+ * A strategy: one way to do one step, with a name and a description.
+ * The same input and the same options must give the same output.
+ */
+export interface Strategy<S extends Step = Step, O extends object = object> {
+  /** The step of the strategy. It fixes the input and the output type. */
+  readonly step: S;
+  /** The name of the strategy. Each name is unique in its step of a registry. */
+  readonly name: string;
+  /** One or two sentences that tell what the strategy does. The site and the documents show them. */
+  readonly describe: string;
+  /** The values of the options when the caller gives no value. */
+  readonly defaults: Readonly<O>;
+  /** The benchmark skips an input with more nodes than this. Without it, the strategy takes each input. */
+  readonly maxNodes?: number;
+  /** This method does the step. Each option that `options` does not give gets its value from `defaults`. */
+  run(input: StepInput<S>, options?: Partial<O>): StepOutput<S>;
+}
+/** A strategy of any step. A registry holds a list of these. */
+export type AnyStrategy = { [S in Step]: Strategy<S>; }[Step];
+/** The definition of a strategy, for `defineStrategy`. */
+export interface StrategyDefinition<S extends Step, O extends object> {
+  readonly step: S;
+  readonly name: string;
+  readonly describe: string;
+  /** These values are the options when the caller gives no value. Give `{}` for a strategy without options. */
+  readonly defaults: O;
+  readonly maxNodes?: number;
+  /** This function does the step. It gets each option, from the caller or from `defaults`. */
+  run(input: StepInput<S>, options: Readonly<O>): StepOutput<S>;
+}
+/**
+ * This function makes a strategy from its definition. The strategy fills the missing options from `defaults`.
+ * When the caller gives no option, the definition gets the `defaults` object itself.
+ */
+export declare function defineStrategy<S extends Step, O extends object>(definition: StrategyDefinition<S, O>): Strategy<S, O>;
+/**
+ * A registry: the strategies of each step, in order. A registry is data. No import changes it.
+ * A consumer makes its own registry with `createRegistry`, and adds a strategy with `register`.
+ * The list `group` is optional in the type, so a registry from version 0.1.5 stays a registry. `createRegistry` always gives it.
+ */
+export type Registry = { readonly [S in Exclude<Step, "group">]: readonly Strategy<S>[]; } & {
+  readonly group?: readonly Strategy<"group">[];
+};
+/** This function makes a registry from a list of strategies. It keeps their order. Two strategies with one step and one name are an error. */
+export declare function createRegistry(strategies: readonly AnyStrategy[]): Registry;
+/** This function gives a new registry with the strategies of `registry` and then `strategies`. It does not change `registry`. */
+export declare function register(registry: Registry, ...strategies: readonly AnyStrategy[]): Registry;
+/** This function gives the strategies of one step of a registry, in order. */
+export declare function listStrategies<S extends Step>(registry: Registry, step: S): readonly Strategy<S>[];
+/** This function gives the strategy of one step with a name, or `undefined` when the registry has no such strategy. */
+export declare function findStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S> | undefined;
+/** This function gives the strategy of one step with a name. When the registry has no such strategy, the function throws an error. */
+export declare function getStrategy<S extends Step>(registry: Registry, step: S, name: string): Strategy<S>;
+/** This function gives a `Router` that runs a router strategy with the options. The router keeps the name and the `maxNodes` of the strategy. */
+export declare function asRouter<O extends object>(strategy: Strategy<"router", O>, options?: Partial<O>): Router;
+/** This function gives the router strategies of a registry as `Router` objects, in order. The benchmark races them. */
+export declare function routersOf(registry: Registry): Router[];
+/**
+ * The options of the router with sections. Each option has a default, and the defaults give the output of version 0.1.5.
+ * The options `cap`, `maxDepth` and `collapse` are the limits of the default grouping rule, the quadtree of `buildSections`.
+ * The options `tightMargin` and `plugInset` are the limits of the level links (`levelLinks`).
+ */
+interface SectionsOptions extends LevelLinkOptions, SectionOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /**
+   * The number of hubs on each side of the lowest common section that a way passes. A smaller number gives shorter ways
+   * and fewer shared ways. Without it, a way passes each hub from its node up.
+   */
+  readonly hubs?: number;
+  /**
+   * The hub limit. A way through the hubs can be at most this many times as long as the line between its plugs, plus `stretchPad` margins.
+   * Else the edge goes directly. The default is 2. The value `Infinity` keeps each way through the hubs.
+   */
+  readonly stretch?: number;
+  /** A way through the hubs can be this many margins longer than `stretch` times the line between its plugs. The default is 4. */
+  readonly stretchPad?: number;
+  /**
+   * A way skips a hub that is more than this many units farther from the target than the nearest approach of the way before it.
+   * The default is 80, two times `BACKTRACK_MIN`. The value `Infinity` keeps each hub.
+   */
+  readonly hubSlack?: number;
+  /**
+   * The grouping rule: a strategy of the step `group` that makes the tree of sections. The hubs and the zoom levels come from this tree.
+   * Without it, the router uses the quadtree of `buildSections` with the options `cap`, `maxDepth` and `collapse`.
+   */
+  readonly group?: Strategy<"group">;
+  /** The options of the strategy `group`. The strategy gets its `defaults` for each option that this object does not give. */
+  readonly groupOptions?: object;
+  /**
+   * The depths of the tree that get a zoom level with groups. The last level, with each node alone, always comes after them.
+   * The default is each depth, from 0 to the depth of the deepest section.
+   */
+  readonly levels?: readonly number[];
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/**
+ * This function makes a router with a tree of sections. Each section has a hub: the free corner nearest to the center of its nodes.
+ * An edge goes from its node up the hubs of its sections to the lowest common section, across, and down to the other node.
+ * Each way from hub to hub is found one time, so all the edges on it share its points.
+ * The edges in one section of the lowest level go straight around the nodes.
+ *
+ * An edge skips a hub that takes it away from its target. A way that still goes out and back gives way to the direct way.
+ *
+ * The result gives one zoom level for each depth of the tree.
+ * A link of a level goes from the boundary of one item to the boundary of the other, around the other items.
+ */
+export declare function sectionsRouter(options: SectionsOptions): Router;
+/** The options of the trunk router. */
+interface TrunksOptions extends WayOptions {
+  /** The name in the benchmark. */
+  readonly name: string;
+  /** The grouping rule. The edges from one plug with one key share a trunk. */
+  readonly rule: GroupRule;
+  /** The split point is at this share of the way to the center of the targets. The default is 0.5. */
+  readonly split?: number;
+  /** A group with fewer edges stays unbundled. The default is 2. */
+  readonly minSize?: number;
+  /** The benchmark skips a fixture with more nodes. */
+  readonly maxNodes?: number;
+}
+/** The rule that groups the edges by the collection of their target, in `data.collection`. */
+export declare const byCollection: GroupRule;
+/**
+ * This function groups the edges by their source plug and their key. Each group keeps the order of the edges.
+ * A group with fewer than `minSize` edges does not appear.
+ */
+export declare function groupEdges(edges: readonly Edge[], rule: GroupRule, minSize?: number): Map<string, Edge[]>;
+/**
+ * This function gives the lane order of the branches that leave the split point `from`, with the trunk along `dir`.
+ * Lane 0 turns most to the left, in a frame with the y axis down. Thus two lanes do not cross at the split.
+ */
+export declare function laneOrder(dir: Point, from: Point, branches: readonly {
+  readonly edge: string;
+  readonly next: Point;
+}[]): string[];
+/**
+ * This function gives the split point of a bundle, on the line from `start` to the center of the targets.
+ * The point is at `split` of the way, but at most half of the way to the nearest target. It moves back toward `start` out of the boxes.
+ */
+export declare function splitPoint(start: Point, targets: readonly Point[], split: number, free: (p: Point) => boolean, step: number): Point;
+/**
+ * This function makes a router that bundles the edges by a rule. The edges of a group share one plug and one trunk
+ * to a split point. From there, each edge goes its own way. The router gives the bundles with their lane order.
+ * The edges outside the groups go as in the corner router.
+ */
+export declare function trunksRouter(options: TrunksOptions): Router;
+/** The built-in routers. The registry `STRATEGIES` holds the same routers as strategies, and the benchmark races the routers of the registry. */
+export declare const ROUTERS: readonly Router[];
+/**
+ * The lane order of the pieces of the links in one gap.
+ *
+ * - `links`: the order of the list of links. This order reads nothing of the board.
+ * - `ends`: the pieces that turn to the near side at their two ends come first. The pieces that turn to the far side come last.
+ * - `crossings`: the order with the fewest crossings between the pieces of the gap and the legs at their ends. A local search finds it.
+ */
+export type LaneOrder = "links" | "ends" | "crossings";
+/** The lane orders of `gapLanes`, in the order of the benchmark. */
+export declare const LANE_ORDERS: readonly LaneOrder[];
+/** The options of `gapLanes`. */
+export interface GapLaneOptions {
+  /** The largest distance between two lanes. A narrow gap puts its lanes nearer. The default is 4. */
+  readonly spacing?: number;
+  /** The lane order in each gap. The default is `crossings`. */
+  readonly order?: LaneOrder;
+  /** Two box edges nearer than this distance make one boundary of the sweep, as in `boardGaps`. The default is 0.5. */
+  readonly snap?: number;
+}
+/**
+ * This function gives each link that runs along a gap its own lane in the gap. The lanes of a gap are `spacing` apart, around its middle line.
+ * A leg of a link moves across its gap only, so the link keeps its plugs and the axes of its legs.
+ * When a move puts a link through more boxes than before, the link keeps its points.
+ */
+export declare function gapLanes(items: readonly Boxed[], links: readonly LevelLink[], options?: GapLaneOptions): LevelLink[];
 /** A broken hard rule. A correct router has none. */
 export interface Violation {
   readonly rule: "complete" | "ends-at-plugs" | "fixed-plugs" | "no-pass-through" | "counts-sum" | "link-ends" | "bundle-trunk" | "run-shared";
@@ -1035,11 +1265,14 @@ export declare function formatTable(rows: readonly BenchRow[]): string;
  * A router without such levels gets a dash in the columns of the levels.
  */
 export declare function formatFaults(rows: readonly BenchRow[]): string;
-/** One row of the benchmark of the curves: one curve type on the routes of one router on one fixture. */
-export interface CurveBenchRow {
+/**
+ * One row of the benchmark of the curves: one curve type on the routes of one router on one fixture.
+ * The type `T` of the name of the curve is `CurveType` for `benchCurves`, and `string` for `benchCurveStrategies`.
+ */
+export interface CurveBenchRow<T extends string = CurveType> {
   readonly router: string;
   readonly fixture: string;
-  readonly type: CurveType;
+  readonly type: T;
   /** The number of routes. */
   readonly links: number;
   /** The number of polylines that go through a box that is not one of their ends (`measureLinks`). */
@@ -1066,8 +1299,13 @@ export interface CurveBenchOptions {
  * The type `spline` leaves each plug along the normal of the nearest side of its node.
  */
 export declare function benchCurves(router: Router, fixture: string, graph: Graph, options?: CurveBenchOptions): CurveBenchRow[];
+/**
+ * This function does the work of `benchCurves` with a list of curve strategies, in place of the curve types.
+ * The option `radius` goes to each strategy. A strategy without such an option does not read it.
+ */
+export declare function benchCurveStrategies(router: Router, fixture: string, graph: Graph, curves: readonly Strategy<"curve">[], options?: CurveBenchOptions): CurveBenchRow<string>[];
 /** This function writes the rows of `benchCurves` as a Markdown table. */
-export declare function formatCurves(rows: readonly CurveBenchRow[]): string;
+export declare function formatCurves(rows: readonly CurveBenchRow<string>[]): string;
 /** One row of the benchmark of the room: one state of a board, packed or open, and the measures of its links. */
 export interface RoomBenchRow {
   readonly fixture: string;
@@ -1093,15 +1331,141 @@ export interface RoomBenchRow {
 }
 /**
  * This function measures the links of one board. It measures the links of the far view, with each node of the graph as one item of a level.
- * It also measures the lane routes of the router `sections` at the lane width `spacing`.
+ * With a lane order, each link of the far view gets its own lane in each gap (`gapLanes` at the lane width `spacing`).
+ * Without it, the links of a gap share the lines of the level links.
+ * The function also measures the lane routes of the router `sections` at the lane width `spacing`.
+ */
+export declare function measureBoard(graph: Graph, spacing: number, order?: LaneOrder): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms">;
+/**
+ * This function measures a packed board, the board with each gap open to the gutter only, and the board that each room strategy opens.
+ * The options are the same for each strategy, except `method`. The default strategies are the methods `routes` and `lines` of `roomDemand`.
+ */
+export declare function benchRoom(fixture: string, graph: Graph, options?: RoomOptions, methods?: readonly Strategy<"room">[]): RoomBenchRow[];
+/** One setting of a sweep of the room: the options of `makeRoom` and the lane order of the far view. */
+export interface RoomSetting {
+  /** The name of the setting in the column `board`. */
+  readonly name: string;
+  readonly options: RoomOptions;
+  /** The lane order of the far view. Without it, the links of a gap share the lines of the level links. */
+  readonly lanes?: LaneOrder;
+}
+/**
+ * This function measures the board that `makeRoom` opens with each setting, with the method `routes`.
+ * The first row is the fair baseline: the board with each gap open to the gutter of `baseline` only, measured at the spacing of `baseline`.
  */
-export declare function measureBoard(graph: Graph, spacing: number): Omit<RoomBenchRow, "fixture" | "board" | "area" | "ms">;
+export declare function sweepRoom(fixture: string, graph: Graph, settings: readonly RoomSetting[], baseline?: RoomOptions): RoomBenchRow[];
+/** The values of `maxGrowth` of the sweep of ROOM-A. */
+export declare const GROWTH_SWEEP: readonly number[];
+/** This function gives the settings of ROOM-A: the area and the faults for each `maxGrowth`, at gutter 8 and spacing 4. */
+export declare function growthSettings(values?: readonly number[]): RoomSetting[];
 /**
- * This function measures a packed board, the board with each gap open to the gutter only, and the board that `makeRoom` opens with each method.
- * The options of `makeRoom` are the same for each method, except `method`.
+ * This function gives the settings of ROOM-C: each lane order of the far view at each spacing, at gutter 8.
+ * The order `shared` is the far view without lanes, as before ROOM-C.
  */
-export declare function benchRoom(fixture: string, graph: Graph, options?: RoomOptions): RoomBenchRow[];
+export declare function laneSettings(spacings?: readonly number[], orders?: readonly LaneOrder[]): RoomSetting[];
+/** This function gives the settings of ROOM-D: each gutter with each number of passes, at spacing 4. */
+export declare function passSettings(gutters?: readonly number[], passes?: readonly number[]): RoomSetting[];
 /** This function writes the rows of `benchRoom` as a Markdown table. */
 export declare function formatRoom(rows: readonly RoomBenchRow[]): string;
-export type { ArcOptions, CornersOptions, CurveSpace, RoundedOptions, SectionsOptions, SharedOptions, SplineOptions, TrunksOptions };
+/** The options of one setting of the router `sections`, without the name. */
+export type SectionsSettingOptions = Omit<SectionsOptions, "name" | "maxNodes">;
+/** One setting of a sweep of the router `sections`. */
+export interface SectionsSetting {
+  /** The name of the setting in the column `setting`. */
+  readonly name: string;
+  readonly options: SectionsSettingOptions;
+}
+/** One row of a sweep of the router `sections`: one setting on one board, and the measures of its routes and of its zoom levels. */
+export interface SectionsBenchRow {
+  readonly fixture: string;
+  readonly setting: string;
+  /** The faults of the routes of the edges (`measureRouteFaults`). */
+  readonly faults: LinkFaults;
+  /** The sum of the faults of the levels with groups (`measureLevelFaults` and `sumFaults`). */
+  readonly levelFaults: LinkFaults;
+  /** The sum of the overlaps of the levels with groups. */
+  readonly overlaps: number;
+  /** The number of routes that go through hubs: the routes that are not the same as the direct route of their edge. */
+  readonly hubRoutes: number;
+  /** The number of shared stretches of way of the result (`runs`). */
+  readonly runs: number;
+  /** The number of zoom levels, with the last level of single nodes. */
+  readonly levels: number;
+  /** The number of items of the far view: the first level with more than one item. */
+  readonly farItems: number;
+  /** The time of one route, in milliseconds. */
+  readonly ms: number;
+}
+/**
+ * This function measures the router `sections` on one board with each setting. The first row is the fair baseline: the defaults, with no option.
+ * The direct routes come from the hub limit 0, so `hubRoutes` counts the routes that use the hubs.
+ */
+export declare function sweepSections(fixture: string, graph: Graph, settings: readonly SectionsSetting[]): SectionsBenchRow[];
+/** The values of the hub limit (`stretch`) of the sweep of CUSTOM. The default is 2. */
+export declare const STRETCH_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the hub limit: one setting for each value of `stretch`. */
+export declare function stretchSettings(values?: readonly number[]): SectionsSetting[];
+/** The values of `hubSlack` of the sweep of CUSTOM. The default is 80. */
+export declare const SLACK_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the slack of the hubs: one setting for each value of `hubSlack`. */
+export declare function slackSettings(values?: readonly number[]): SectionsSetting[];
+/** The values of the section limit (`cap`) of the sweep of CUSTOM. The default is 8. */
+export declare const CAP_SWEEP: readonly number[];
+/** This function gives the settings of the sweep of the section limit: one setting for each value of `cap`. */
+export declare function capSettings(values?: readonly number[]): SectionsSetting[];
+/**
+ * This function gives one setting for each grouping rule: the router `sections` with the strategy as its option `group`.
+ * The map `options` gives the options of a strategy by its name.
+ */
+export declare function groupSettings(strategies?: readonly Strategy<"group">[], options?: Readonly<Record<string, object>>): SectionsSetting[];
+/** This function writes the rows of `sweepSections` as a Markdown table. */
+export declare function formatSections(rows: readonly SectionsBenchRow[]): string;
+/** 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">;
+/** The built-in router strategies, in the order of the benchmark. They route as the routers of `ROUTERS`. */
+export declare const routerStrategies: {
+  readonly straight: Strategy<"router", object>;
+  readonly plugs: Strategy<"router", object>;
+  readonly corners: Strategy<"router", RouterPreset<CornersOptions>>;
+  readonly "corners-smooth": Strategy<"router", RouterPreset<CornersOptions>>;
+  readonly trunks: Strategy<"router", RouterPreset<TrunksOptions>>;
+  readonly shared: Strategy<"router", RouterPreset<SharedOptions>>;
+  readonly "shared-all": Strategy<"router", RouterPreset<SharedOptions>>;
+  readonly sections: Strategy<"router", RouterPreset<SectionsOptions>>;
+  readonly "sections-tree": Strategy<"router", RouterPreset<SectionsOptions>>;
+};
+/** The options of the curve strategies `rounded` and `arc`. */
+export interface RadiusOptions {
+  /** The radius of the corners. The default is 12. */
+  readonly radius: number;
+}
+/** The options of the curve strategy `spline`. */
+export interface TensionOptions {
+  /** The tension of the spline, from 0 (the spline) to 1 (the polyline). The default is 0. */
+  readonly tension: number;
+}
+/** The built-in curve strategies, in the order of `CURVE_TYPES`. Each one gives the same segments as `curveOf` with its type. */
+export declare const curveStrategies: {
+  readonly straight: Strategy<"curve", object>;
+  readonly rounded: Strategy<"curve", RadiusOptions>;
+  readonly spline: Strategy<"curve", TensionOptions>;
+  readonly arc: Strategy<"curve", RadiusOptions>;
+};
+/** The options of a room strategy: the options of `roomDemand`, without the method. */
+export type RoomPreset = Omit<RoomOptions, "method">;
+/** The built-in room strategies: the methods of `roomDemand`. */
+export declare const roomStrategies: {
+  readonly routes: Strategy<"room", RoomPreset>;
+  readonly lines: Strategy<"room", RoomPreset>;
+};
+/** The built-in grouping rules: the strategies of the step `group`. The router `sections` makes its hubs and its zoom levels from their tree. */
+export declare const groupStrategies: {
+  readonly quadtree: Strategy<"group", Required<SectionOptions>>;
+  readonly keys: Strategy<"group", KeyOptions>;
+};
+/** The built-in strategies of each step, in order. A consumer adds its own: `createRegistry([...BUILT_IN_STRATEGIES, mine])`. */
+export declare const BUILT_IN_STRATEGIES: readonly AnyStrategy[];
+/** The registry of the built-in strategies. The benchmark and the site take their lists from it. */
+export declare const STRATEGIES: Registry;
+export type { ArcOptions, CornersOptions, CurveSpace, KeyOptions, NodeKey, RoundedOptions, SectionsOptions, SharedOptions, SplineOptions, TrunksOptions };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geom.ts","../src/grid.ts","../src/model.ts","../src/fixtures.ts","../src/cases.ts","../src/plugs.ts","../src/curves.ts","../src/curves/model.ts","../src/curves/space.ts","../src/curves/sample.ts","../src/curves/straight/index.ts","../src/curves/rounded/index.ts","../src/curves/spline/index.ts","../src/curves/arc/index.ts","../src/curves/index.ts","../src/visibility.ts","../src/ways.ts","../src/segments.ts","../src/sections.ts","../src/routers/straight.ts","../src/routers/plugs.ts","../src/routers/corners.ts","../src/routers/shared.ts","../src/routers/sections.ts","../src/routers/trunks.ts","../src/routers/index.ts","../src/room/index.ts","../src/bench/properties.ts","../src/bench/quality.ts","../src/bench/links.ts","../src/bench/run.ts","../src/bench/curves.ts","../src/bench/room.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/geom.ts","../src/grid.ts","../src/model.ts","../src/fixtures.ts","../src/cases.ts","../src/plugs.ts","../src/curves.ts","../src/curves/model.ts","../src/curves/space.ts","../src/curves/sample.ts","../src/curves/straight/index.ts","../src/curves/rounded/index.ts","../src/curves/spline/index.ts","../src/curves/arc/index.ts","../src/curves/index.ts","../src/visibility.ts","../src/ways.ts","../src/segments.ts","../src/sections.ts","../src/groups/quadtree/index.ts","../src/groups/keys/index.ts","../src/pick.ts","../src/routers/straight.ts","../src/routers/plugs.ts","../src/routers/corners.ts","../src/routers/shared.ts","../src/levels.ts","../src/room/index.ts","../src/strategies/model.ts","../src/routers/sections.ts","../src/routers/trunks.ts","../src/routers/index.ts","../src/room/lanes.ts","../src/bench/properties.ts","../src/bench/quality.ts","../src/bench/links.ts","../src/bench/run.ts","../src/bench/curves.ts","../src/bench/room.ts","../src/bench/sections.ts","../src/strategies/builtins.ts"],"mappings":"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"}