@mark1russell7/highways 0.1.3 → 0.1.5

package/build/index.d.ts

@@ -244,6 +244,15 @@ export declare function hubChainBoard(): Graph;
  * On a level with many groups, some level links go around the outer edge of the board.
  */
 export declare function manyGroupsBoard(): Graph;
+/**
+ * This function makes the far view of a board after a host layout packs it.
+ * The board has 96 boxes of one size in a grid of 12 columns and 8 rows.
+ * The boxes touch, with no gap between them. Each box links to a box near it, and 48 long links join boxes far apart.
+ * The links have no channel between the boxes. The roadmap item ROOM measures this board before and after `makeRoom`.
+ *
+ * The board is not in `CASES`, because the digests of the router fix the output on each board of `CASES`.
+ */
+export declare function packedGridBoard(): Graph;
 /** The case boards of the benchmark. Each board has a few hundred nodes at most, so the benchmark races them on each run. */
 export declare const CASES: readonly CaseBoard[];
 /** A plug: the point where a route leaves or enters a node, and the outward normal of its side. */
@@ -296,6 +305,160 @@ export declare function inflectionCurve(p0: Point, normal: Point, target: Point,
  * The curve starts and ends at most `radius` from the vertex, and at most half of each segment. The ends of the polyline stay.
  */
 export declare function roundCorners(p: readonly Point[], radius: number, steps?: number): Point[];
+/**
+ * A type of curve for a route.
+ *
+ * - `straight`: the polyline as it is.
+ * - `rounded`: a quadratic Bezier curve at each corner, as `roundCorners` draws it.
+ * - `spline`: a centripetal Catmull-Rom spline through the points. It does not overshoot or make loops.
+ * - `arc`: a circular arc at each corner, tangent to the two legs.
+ */
+export type CurveType = "straight" | "rounded" | "spline" | "arc";
+/** The curve types, in the order of the benchmark. */
+export declare const CURVE_TYPES: readonly CurveType[];
+/** The start of a curve: the pen goes to `to` and draws nothing. */
+export interface MoveSegment {
+  readonly kind: "move";
+  readonly to: Point;
+}
+/** A straight line from the end of the segment before to `to`. */
+export interface LineSegment {
+  readonly kind: "line";
+  readonly to: Point;
+}
+/** A cubic Bezier curve from the end of the segment before to `to`, with the control points `c1` and `c2`. */
+export interface CubicSegment {
+  readonly kind: "cubic";
+  readonly c1: Point;
+  readonly c2: Point;
+  readonly to: Point;
+}
+/**
+ * A circular arc from the end of the segment before to `to`. The arc has its center at `center` and the radius `radius`.
+ * It starts at the angle `start` and turns by `sweep` radians. A positive `sweep` turns from the x axis to the y axis.
+ * On a canvas, `ctx.arc(center.x, center.y, radius, start, start + sweep, sweep < 0)` draws it.
+ */
+export interface ArcSegment {
+  readonly kind: "arc";
+  readonly center: Point;
+  readonly radius: number;
+  readonly start: number;
+  readonly sweep: number;
+  readonly to: Point;
+}
+/**
+ * A segment of a curve. A curve is a list of segments: one `move` first, then lines, cubic curves and arcs.
+ * A renderer maps the list to SVG path data, to canvas calls or to the vertices of a mesh.
+ */
+export type CurveSegment = MoveSegment | LineSegment | CubicSegment | ArcSegment;
+/** This function gives the points of a polyline without the points that are nearer than `eps` to the point before them. */
+export declare function distinctPoints(points: readonly Point[], eps?: number): Point[];
+/**
+ * The free space of a board: the boxes that a curve must not go through.
+ * Make it one time for a board with `curveSpace`, and give it to each call of `curveOf`.
+ */
+interface CurveSpace {
+  /** The boxes of the board. */
+  readonly boxes: readonly Box[];
+  /** The tolerance of the samples of a curve, in units of the plane. */
+  readonly tolerance: number;
+  /**
+   * This method tells if the polyline `q` goes through a box that the polyline `p` does not go through.
+   * A polyline goes through a box when a part of it longer than `TOLERANCE` is inside the box made smaller by `TOLERANCE`.
+   */
+  addsHit(q: readonly Point[], p: readonly Point[]): boolean;
+}
+/**
+ * This function makes the free space of a board from its boxes. The boxes are the nodes, or the items of a zoom level.
+ * The curves sample each piece within `tolerance` of the curve for the test.
+ */
+export declare function curveSpace(boxes: readonly Box[], tolerance?: number): CurveSpace;
+/**
+ * This function gives a polyline that follows the curve. The distance from each part of the curve to the polyline is `tolerance` or less.
+ * The polyline starts at the point of the `move` and goes through the end of each segment.
+ * Hit tests, measures and renderers that draw only lines use this polyline.
+ */
+export declare function sampleCurve(segments: readonly CurveSegment[], tolerance?: number): Point[];
+/** This function gives the point at the parameter `t` of the cubic Bezier curve with the control points `p0`, `p1`, `p2` and `p3`. */
+export declare function cubicAt(p0: Point, p1: Point, p2: Point, p3: Point, t: number): Point;
+/**
+ * This function writes the segments as the data of an SVG path: the commands `M`, `L`, `C` and `A`.
+ * Each number has at most `digits` digits after the point.
+ */
+export declare function toSvgPath(segments: readonly CurveSegment[], digits?: number): string;
+/** This function gives the polyline as it is: one `move` to the first point and one `line` to each other point. */
+export declare function straightCurve(points: readonly Point[]): CurveSegment[];
+/** The options of `roundedCurve`. */
+interface RoundedOptions {
+  /** The largest distance from a corner to the start and to the end of its curve. The default is 12. */
+  readonly radius?: number;
+  /** The boxes that the curve must not go through. Without it, each corner gets the full radius. */
+  readonly space?: CurveSpace;
+}
+/**
+ * This function rounds each inner vertex of a polyline with a quadratic Bezier curve, as `roundCorners` does.
+ * The curve of a corner starts and ends at most `radius` from the vertex, and at most half of each leg. The ends of the polyline stay.
+ * The function gives each quadratic curve as the same cubic curve. With `space`, it makes the radius of a corner smaller until the curve
+ * goes through no box that the polyline avoids.
+ */
+export declare function roundedCurve(points: readonly Point[], options?: RoundedOptions): CurveSegment[];
+/** The options of `splineCurve`. */
+interface SplineOptions {
+  /**
+   * The tension of the spline, from 0 to 1. The value 0 gives the centripetal Catmull-Rom spline, and 1 gives the polyline.
+   * The default is 0.
+   */
+  readonly tension?: number;
+  /** The outward normal of the plug at the first point. With it, the curve leaves the first point along this normal. */
+  readonly startNormal?: Point;
+  /** The outward normal of the plug at the last point. With it, the curve comes into the last point against this normal. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through. Without it, each piece gets the full tangents. */
+  readonly space?: CurveSpace;
+}
+/**
+ * This function draws a centripetal Catmull-Rom spline through the points of a polyline (Yuksel, Schaefer and Keyser, 2011).
+ * Each piece between two points is one cubic Bezier curve. The centripetal knots keep the curve free of cusps and loops in a piece.
+ * The curve goes through each point. Its tangent at a point keeps one direction on the two sides of the point.
+ *
+ * With `space`, the function makes the tangents of a piece shorter until the piece goes through no box that its leg avoids.
+ * A piece with no tangent is the straight leg.
+ */
+export declare function splineCurve(points: readonly Point[], options?: SplineOptions): CurveSegment[];
+/** The options of `arcCurve`. */
+interface ArcOptions {
+  /** The largest radius of the arc at a corner. The default is 12. */
+  readonly radius?: number;
+  /** The boxes that the curve must not go through. Without it, each corner gets the largest radius that fits on its legs. */
+  readonly space?: CurveSpace;
+}
+/**
+ * This function puts a circular arc at each inner vertex of a polyline. The arc is tangent to the two legs of its corner.
+ * The tangent points stay on the first half of each leg, so the ends of the polyline stay.
+ * With `space`, the function makes the radius of a corner smaller until the arc goes through no box that the polyline avoids.
+ * On a polyline with only horizontal and vertical legs, each arc is a quarter circle.
+ */
+export declare function arcCurve(points: readonly Point[], options?: ArcOptions): CurveSegment[];
+/** The options of `curveOf`. Each type reads only the options that it uses. */
+export interface CurveOptions {
+  readonly type: CurveType;
+  /** The types `rounded` and `arc` read this radius of the corners. The default is 12. */
+  readonly radius?: number;
+  /** The type `spline` reads this tension, from 0 to 1. The default is 0. */
+  readonly tension?: number;
+  /** The type `spline` leaves the first point along this outward normal of its plug. */
+  readonly startNormal?: Point;
+  /** The type `spline` comes into the last point against this outward normal of its plug. */
+  readonly endNormal?: Point;
+  /** The boxes that the curve must not go through, from `curveSpace`. The type `straight` does not read it. */
+  readonly space?: CurveSpace;
+}
+/**
+ * This function gives the curve of a route: a polyline of a router, a lane of `laneRoutes` or a link of a zoom level.
+ * The curve starts at the first point and ends at the last point of the polyline.
+ * The output is a list of segments for any renderer. `toSvgPath` writes it as SVG path data, and `sampleCurve` gives points.
+ */
+export declare function curveOf(points: readonly Point[], options: CurveOptions): CurveSegment[];
 /** The nodes as obstacles, with a grid for fast tests. */
 export declare class Obstacles {
   #private;
@@ -338,6 +501,11 @@ export interface CornerGraphOptions {
    * The lattice links groups of nodes across empty space. Without it, the nearest corners of a group are all in that group.
    */
   readonly lattice?: number;
+  /**
+   * With `cones`, each corner also links to the nearest corner that it can see in each of four cones around the axes.
+   * Then a path can go along a long corridor between rows or columns of boxes. The default is false.
+   */
+  readonly cones?: boolean;
 }
 /**
  * A sparse visibility graph. Its vertices are the corners of the boxes, made larger by `margin`.
@@ -602,8 +770,123 @@ export declare function splitPoint(start: Point, targets: readonly Point[], spli
  * The edges outside the groups go as in the corner router.
  */
 export declare function trunksRouter(options: TrunksOptions): Router;
-/** The routers that the benchmark races. */
+/** 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[];
+/** 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;
+  readonly box: Box;
+}
+/** A link between two boxes. For a bundled link, `count` is the number of its edges. The default count is 1. */
+export interface RoomLink {
+  readonly source: string;
+  readonly target: string;
+  readonly count?: number;
+}
+/**
+ * A gap of a board: a boundary of the sweep over the left or top edges of the boxes.
+ * On the axis `x`, the gap is a vertical channel between two columns. On the axis `y`, it is a horizontal channel between two rows.
+ */
+export interface Gap {
+  readonly axis: "x" | "y";
+  /** The place of the gap in the order of the gaps on its axis, from 0. */
+  readonly index: number;
+  /** The coordinate where the boxes after the gap start, on the axis of the gap. */
+  readonly at: number;
+  /** The ids of the boxes that end at the near side of the gap. */
+  readonly before: readonly string[];
+  /** The ids of the boxes that start at the far side of the gap, at `at`. */
+  readonly after: readonly string[];
+  /** The current width of the gap: the distance from the nearest box edge before the gap to `at`. */
+  readonly width: number;
+  /** The number of lanes that the links need in the gap. */
+  readonly lanes: number;
+  /** The width that the gap needs: at least the current width, and at least `gutter + lanes × spacing`. */
+  readonly need: number;
+}
+/** The ways that `roomDemand` finds the lanes of each gap. */
+export type RoomMethod = "routes" | "lines";
+/** The options of `roomDemand` and `makeRoom`. */
+export interface RoomOptions {
+  /** The smallest width of each gap. The default is 8. */
+  readonly gutter?: number;
+  /** The width of one lane: the distance between two lines that run side by side. The default is 4. */
+  readonly spacing?: number;
+  /**
+   * The largest growth of the board on each axis, as a share of its size. The default is `Infinity`.
+   * When the lanes need more, each gap gets its gutter, and the lanes share the rest in proportion.
+   */
+  readonly maxGrowth?: number;
+  /**
+   * The way to find the lanes. The default is `routes`.
+   * With `routes`, the function routes the links one time on the board with each gap open to the gutter.
+   * The lanes of a gap are the most routes that run along the gap side by side.
+   * With `lines`, the lanes of a gap are the straight lines between the centers of the boxes that cross the gap.
+   */
+  readonly method?: RoomMethod;
+  /** The router of the method `routes`. Without it, the links go as the links of a zoom level (`levelLinks`), with the margin `gutter / 2`. */
+  readonly router?: Router;
+  /** With `count`, a link takes one lane for each of its edges. With `link`, the default, a link takes one lane. */
+  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> {
+  readonly gaps: readonly Gap[];
+  readonly items: T[];
+}
+/**
+ * This function gives the gaps of a board. A sweep over each axis sorts the left (or top) edges of the boxes.
+ * Each distinct edge after the first is a gap. The `lanes` of each gap are 0, and its `need` is its current width.
+ */
+export declare function boardGaps(items: readonly Boxed[], snap?: number): Gap[];
+/**
+ * This function moves the boxes apart, so that each gap gets the width `need`. The boxes keep their size, their order and their alignment.
+ * A box moves by the sum of the growth of each gap at or before its left (or top) edge. Thus a grid stays a grid.
+ * The function moves no box nearer to another box, so it makes no overlap.
+ */
+export declare function openGaps<T extends Boxed>(items: readonly T[], gaps: readonly Gap[], snap?: number): T[];
+/**
+ * This function gives the room that the links need in each gap of the board.
+ * The lanes of a gap come from the `method` of the options. The need of a gap is `gutter + lanes × spacing`, and not less than its current width.
+ */
+export declare function roomDemand(items: readonly Boxed[], links: readonly RoomLink[], options?: RoomOptions): Gap[];
+/** This function gives the demand of the board and the board with each gap open to its need. */
+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 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";
@@ -783,5 +1066,249 @@ 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;
-export type { CornersOptions, SectionsOptions, SharedOptions, TrunksOptions };
+/** 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.
+ *
+ * - `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 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`.
+ */
+export type Registry = { readonly [S in Step]: readonly Strategy<S>[]; };
+/** 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[];
+/**
+ * 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: 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`). */
+  readonly through: number;
+  /** The number of curves without a free space that go through such a box. */
+  readonly free: number;
+  /** The number of curves with the free space of the nodes (`curveSpace`) that go through such a box. */
+  readonly clamped: number;
+  /** The ratio of the length of all curves with the free space to the length of all polylines. */
+  readonly length: number;
+  /** The time to make all curves with the free space, in milliseconds. */
+  readonly ms: number;
+}
+/** The options of `benchCurves`. */
+export interface CurveBenchOptions {
+  /** The radius of the types `rounded` and `arc`. The default is 12. */
+  readonly radius?: number;
+  /** The tolerance of the samples of the curves. The default is 0.25. */
+  readonly tolerance?: number;
+}
+/**
+ * This function routes a graph with a router and makes each curve type of each route.
+ * It counts the curves that go through a box, with and without the free space, and it compares their length to the polylines.
+ * 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>[]): 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;
+  /** The state of the board: `packed`, `gutter` (each gap open to the gutter only), or a method of `roomDemand`. */
+  readonly board: string;
+  /** The area of the bounding box of the boxes, as a share of the area of the packed board. */
+  readonly area: number;
+  /** The faults of the links of the far view (`levelLinks` with each box as one item). */
+  readonly faults: LinkFaults;
+  /** The crossings of the links of the far view (`measureQuality`). */
+  readonly crossings: number;
+  /** The ink of the links of the far view. */
+  readonly ink: number;
+  /** The mean detour of the links of the far view. */
+  readonly detour: number;
+  /**
+   * The number of lane routes of the router `sections` that go through a box. Each shared segment opens to one lane for each edge,
+   * at the spacing of the options (`laneRoutes`).
+   */
+  readonly laneThrough: number;
+  /** The time of `makeRoom`, in milliseconds. It is 0 for the packed board. */
+  readonly ms: number;
+}
+/**
+ * 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.
+ * 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 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 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 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;
+/** 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 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, 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/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/bench/properties.ts","../src/bench/quality.ts","../src/bench/links.ts","../src/bench/run.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/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/room/lanes.ts","../src/bench/properties.ts","../src/bench/quality.ts","../src/bench/links.ts","../src/bench/run.ts","../src/strategies/model.ts","../src/bench/curves.ts","../src/bench/room.ts","../src/strategies/builtins.ts"],"mappings":"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"}