@mark1russell7/packing 0.1.6 → 0.2.0

package/README.md

@@ -105,7 +105,7 @@ checkHard(input, output); // { "no-overlap": 0, "in-container": 0, "locked-kept"
 - `fixed` is `size`, `width`, `height` or `none`. A fixed height turns the axes. The value `none` uses the size search `logSweep`, which wraps `packFree`.
 - Each strategy declares its cells in `supports`. `cellOf(input)` gives the cell of an input. A strategy throws `UnsupportedCell` for an input outside its cells.
 - The strategies of this version do not turn items, read groups or pack shapes. A turnable item, a group or a shape gives `UnsupportedCell`.
-- `checkHard` counts the breaks of the hard rules: `no-overlap`, `in-container`, `locked-kept` and `complete`.
+- `checkHard` counts the breaks of the hard rules: `no-overlap`, `in-container`, `locked-kept` and `complete`. It reads the true shape of each obstacle, as `packHard` of `@mark1russell7/layout-contract` does.
 - `fromRects` and `toRects` connect the interface to the `Rect` objects.
 
 `docs/PACKER.md` in the repository gives the interface in full.

package/build/index.d.ts

@@ -1,3 +1,4 @@
+import { DEFAULT_TOLERANCE, Direction, Direction as Direction$1, EPS, Item, Item as Item$1, LayoutContainer, LayoutContainer as LayoutContainer$1, LayoutEdge, LayoutEdge as LayoutEdge$1, LayoutGenerator, LayoutInput, LayoutInput as LayoutInput$1, Margin, MeasureSpec as MeasureSpec$1, Obstacle, PackHard, PackHard as PackHard$1, PackInput, PackOutput, Placement, Port, RECORD_EPS, Region, Side, Sides, Sides as Sides$1, StageTrace, Tolerance, checkInput, turnPoint, turnPort, turnRegion } from "@mark1russell7/layout-contract";
 /** A mutable two-dimensional vector. */
 export declare class Vector {
   #private;
@@ -258,179 +259,39 @@ interface MetricsOptions {
  * ```
  */
 export declare function packingMetrics(rects: readonly Rect[], options?: MetricsOptions): PackingMetrics;
-/** A region. The forms and the rules are those of `docs/FORMAT.md`. The y axis points down. */
-type Region = {
-  kind: "rect";
-  x: number;
-  y: number;
-  w: number;
-  h: number;
-} | {
-  kind: "polygon";
-  points: [number, number][];
-  holes?: [number, number][][];
-} | {
-  kind: "circle";
-  cx: number;
-  cy: number;
-  r: number;
-} | {
-  kind: "ellipse";
-  cx: number;
-  cy: number;
-  rx: number;
-  ry: number;
-};
-/** The container of a packing. */
-interface Container {
-  /** The width. Without it, the packer searches the width. */
-  w?: number;
-  /** The height. Without it, the packer searches the height. */
-  h?: number;
-  /** The sides that stay: `size` keeps `w` and `h`, `width` keeps `w`, `height` keeps `h`, and `none` searches both. */
-  fixed: "size" | "width" | "height" | "none";
-  /** The target aspect (the width divided by the height) for the value `none` of `fixed`. The default is 1. */
-  aspect?: number;
-  /** The weight of the aspect error in the objective. The value 0 gives the least area. The default is 1. */
-  aspectWeight?: number;
-  /** The shape. Without it, the container is the rectangle from 0, 0 to `w`, `h`. */
-  shape?: Region;
-  /** The space between the border and the items with their margins. The default is 0. */
-  inset?: number;
-}
-/** An obstacle: an area that no item enters. */
-interface Obstacle {
-  id: string;
-  region: Region;
-  /** Without it, the obstacle stays. With it, the packer can move the obstacle for `cost` times the distance. */
-  move?: {
-    cost: number;
-  };
-}
-/** The margin of an item on each side. */
-interface Margin {
-  top: number;
-  right: number;
-  bottom: number;
-  left: number;
-}
-/** A port on the border of an item. */
-interface Port {
-  id: string;
-  side: "top" | "right" | "bottom" | "left";
-  /** The point on the border of the item, relative to its top-left corner. Without it, the router chooses the point. */
-  x?: number;
-  y?: number;
-}
-/** An item to pack. The file format names it a box. */
-interface Item {
-  id: string;
-  w: number;
-  h: number;
-  /** The reading order. Without it, the index in the array is the rank. */
-  rank?: number;
-  group?: string;
-  parent?: string;
-  /** A shape relative to the origin of the item. Without it, the item is the rectangle `w` by `h`. */
-  shape?: Region;
-  /** A locked item keeps `x` and `y`. The packer reads it as an obstacle. */
-  locked?: boolean;
-  x?: number;
-  y?: number;
-  /** The value `true` lets the packer turn the item by 90 degrees. The default is `false`. */
-  turnable?: boolean;
-  /** A ring around the item that no other item and no route enters. The default is 0. */
-  margin?: number | Margin;
-  /** The ports. The packer keeps them, and turns them with the item. */
-  ports?: Port[];
-}
-/** The input of a packing: a `layout-input/1` file without `edges`, with `items` for `boxes`. */
-interface PackInput {
-  container: Container;
-  items: Item[];
-  obstacles?: Obstacle[];
-  /** The free space between two items with their margins. Routes use this space. The default is 0. */
-  gap?: number;
-}
-/** The position of one item after the packing. */
-interface Placement {
-  id: string;
-  x: number;
-  y: number;
-  /** The turn: 0 or 90, only for an item with `turnable` set to `true`. */
-  turn?: 0 | 90;
-}
-/** The facts of one stage of a packing. */
-interface StageTrace {
-  /** The id of the stage, for example `skyline` or `log-sweep`. */
-  id: string;
-  /** The time of the stage in milliseconds. */
-  ms: number;
-  /** The measures of the stage, by the names of `docs/FORMAT.md`. */
-  measures: Record<string, number>;
-}
-/** The output of a packing. The output does not change the input. */
-interface PackOutput {
-  placements: Placement[];
-  /** The ids of the items that the packer did not place. */
-  overflow: string[];
-  /** The size of the container after the packing. For a free size, the size that the search found. */
-  size: {
-    w: number;
-    h: number;
-  };
-  /** The new positions of the obstacles that moved. */
-  moved: {
-    id: string;
-    x: number;
-    y: number;
-  }[];
-  /** The facts of each stage, for the site and the records. */
-  trace: StageTrace[];
-}
-/** The tolerances of the hard rules. */
-interface Tolerance {
-  /** The rule `no-overlap`: two boxes overlap only by more than this value. */
-  overlap: number;
-  /** The router rule that a route does not go through a box. */
-  through: number;
-}
-/** The tolerance for the comparison of two numbers in an engine. */
-export declare const EPS = 1e-6;
-/** The tolerance for the comparison of two numbers of a file. The files round to 3 decimals. */
-export declare const RECORD_EPS = .001;
-/** The default tolerances of the hard rules. Each record writes its tolerances in its top-level field `tolerance`. */
-export declare const DEFAULT_TOLERANCE: Readonly<Tolerance>;
 /** This function gives the margin of an item on each side. A number is the same margin on each side. */
-export declare function marginOf(item: Pick<Item, "margin">): Margin;
-/** This function gives the point `px`, `py` of an item of height `h` after a turn of 90 degrees clockwise. */
-export declare function turnPoint(px: number, py: number, h: number): [number, number];
-/** This function turns a port of an item of height `h` by 90 degrees clockwise. The side turns from top to right. */
-export declare function turnPort(port: Port, h: number): Port;
-/** This function turns a region relative to an item of height `h` by 90 degrees clockwise. */
-export declare function turnRegion(region: Region, h: number): Region;
+export declare function marginOf(item: Pick<Item$1, "margin">): Sides$1;
 /**
  * This function gives an item after a turn of 90 degrees clockwise, with the y axis down (decision 1 of
  * `docs/PACKER.md`). The width and the height change places. The top-left corner, the id and the other fields stay.
  * The ports, the shape and the margin turn with the item. The function does not change its argument.
+ * It is `turnBox` of the contract.
  */
-export declare function turnItem(item: Item): Item;
-/** The direction of a measure: `lower` when a lower value is better, `higher` when a higher value is better. */
-type Direction = "lower" | "higher";
+export declare function turnItem(item: Item$1): Item$1;
 /** The family of a measure. Each family has a section in `docs/MEASURES.md`. */
 type MeasureFamily = "density" | "aspect" | "order" | "raggedness" | "overflow" | "stability" | "determinism" | "speed";
 /** The id of a measure of the packer. The ids are those of `docs/FORMAT.md`, and `highways` uses the same ids. */
 type MeasureId = "pack.area" | "pack.fill" | "pack.whitespace" | "pack.aspect" | "pack.aspectError" | "pack.order.inversions" | "pack.order.breaks" | "pack.raggedness" | "pack.overflow" | "pack.stability.moved" | "pack.stability.mean" | "pack.stability.q95" | "pack.deterministic" | "pack.search.widths" | "pack.search.ms";
-/** The facts of one measure: its family, its unit, its direction and its range. */
-interface MeasureSpec {
-  id: MeasureId;
-  family: MeasureFamily;
-  unit: string;
-  direction: Direction;
-  /** The lowest value. */
-  min: number;
-  /** The highest value. The value `Infinity` tells that the measure has no upper limit. */
-  max: number;
+/**
+ * The facts of one measure: its family, its unit, its direction and its range.
+ * It is `MeasureSpec` of the contract for a packer measure id, with a family.
+ */
+interface MeasureSpec extends MeasureSpec$1<MeasureId> {
+  readonly family: MeasureFamily;
+  /**
+   * The floor is the best value of a guard measure. The floor rule of `docs/PROMOTION.md` of `highways` reads it. Each
+   * guard of the packer has the floor 0. A measure without a floor has no floor rule.
+   */
+  readonly floor?: number;
+  /**
+   * The tolerance is the absolute tolerance at the floor. A candidate within the tolerance ties with a default at the floor.
+   *
+   * - `pack.order.inversions` and `pack.overflow` have the tolerance 0. Thus each new inversion and each new unplaced item is a loss.
+   * - `pack.aspectError` has 0.01, approximately 1% of the aspect. An exact tiling gives the default an error of 0.
+   * - `pack.stability.mean` has 0.005 container widths, and `pack.stability.q95` has 0.01. The default often moves no item.
+   * - `pack.stability.moved` has 0.02: 2% of the items that stay. On a small change, the default often moves no item.
+   */
+  readonly tol?: number;
 }
 /** The measures of one layout, by id. `measure` gives them. The values are not rounded. */
 interface LayoutMeasures {
@@ -460,7 +321,10 @@ interface MeasureOptions {
    */
   rowTolerance?: number;
 }
-/** The facts of each measure, by id. `docs/MEASURES.md` gives the full definitions. */
+/**
+ * The facts of each measure, by id. `docs/MEASURES.md` gives the full definitions. This record is the source of the floor
+ * and the tolerance of each guard of the packer.
+ */
 export declare const MEASURE_SPECS: Readonly<Record<MeasureId, MeasureSpec>>;
 /**
  * This function gives the measures of one layout, by the ids of `docs/MEASURES.md`. The values are not rounded. A
@@ -509,7 +373,7 @@ export declare function roundMeasures<T extends object>(measures: T): T;
  * - When both values are 0, the ratio is 1. When only the divisor is 0, the ratio is `Infinity`.
  * - The values are 0 or more. A negative value or `NaN` throws a `RangeError`.
  */
-export declare function pairedRatio(candidate: number, current: number, direction: Direction): number;
+export declare function pairedRatio(candidate: number, current: number, direction: Direction$1): number;
 /**
  * This function gives the quantile `q` of a list of numbers, with linear interpolation between the sorted values. The
  * position in the sorted list is `(n - 1) * q`. An empty list or a `q` outside 0 to 1 throws a `RangeError`.
@@ -684,64 +548,48 @@ export declare function strategy(id: string): Strategy;
  * context gets `mulberry32` with the seed. The default seed is 0.
  */
 export declare function packWith(id: string, input: PackInput, options?: unknown, seed?: number): PackOutput;
-/** The count of the breaks of each hard rule of the packer (`docs/FORMAT.md`). A good run has 0 for each rule. */
-interface HardBreaks {
-  "no-overlap": number;
-  "in-container": number;
-  "locked-kept": number;
-  complete: number;
-}
 /**
  * This function counts the breaks of the 4 hard rules of the packer for an output.
  *
  * - `no-overlap`: each pair of items with their margins, and each pair of an item and an obstacle, that overlap by more than `tolerance.overlap`.
  * - `in-container`: each item with its margin that goes out of a fixed side by more than `tolerance.overlap`. The inset of
  *   the container makes each fixed side smaller (decision 3 of `docs/PACKER.md`).
- * - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no position.
- * - `complete`: each item with no position that is not in the overflow.
+ * - `locked-kept`: each locked item that moved by more than `RECORD_EPS`, or that has no placement.
+ * - `complete`: each item with no placement that is not in the overflow. A locked item breaks `locked-kept` in its place.
+ *
+ * A locked item with no placement stays at its input position for `no-overlap` and `in-container`. A locked item with no
+ * `x` or no `y` in the input is a bad input. The rules skip it, as `packHard` of the contract does. `checkInput` finds it.
  *
- * The rules read a shape of the container, of an obstacle or of an item as its bounding box (decision 5). The bounding box
- * of an item shape is relative to the position of the item. The result has no tolerance in it.
+ * The test of an obstacle is exact: a circle, an ellipse and a polygon with holes count only their insides, as in `packHard`.
+ * The rules read a shape of the container or of an item as its bounding box (decision 5). The bounding box of an item
+ * shape is relative to the position of the item. The result has no tolerance in it.
  */
-export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">): HardBreaks;
-/** An edge between two boxes. The router reads it, and the packer ignores it. */
-interface Edge {
-  id: string;
-  source: string;
-  target: string;
-  sourcePort?: string;
-  targetPort?: string;
-}
+export declare function checkHard(input: PackInput, output: PackOutput, tolerance?: Pick<Tolerance, "overlap">): PackHard$1;
 /** The parameters of a generator: a name and a string or a number for each parameter. */
 type GeneratorParams = Record<string, string | number>;
-/** The stamp of a generated input: the generator, its version, the full parameters and the seed. */
-interface GeneratorStamp {
-  name: string;
-  version: number;
-  params: GeneratorParams;
-  seed: number;
+/**
+ * The stamp of a generated input: the generator, its version, the full parameters and the seed.
+ * It is `LayoutGenerator` of the contract with a string or a number for each parameter.
+ */
+interface GeneratorStamp extends LayoutGenerator {
+  readonly params: Readonly<GeneratorParams>;
 }
-/** One input file `layout-input/1`. `docs/FORMAT.md` gives each field. */
-interface LayoutInput {
-  schema: "layout-input/1";
-  id: string;
-  set: string;
-  family: string;
-  seed: number;
+/**
+ * A generated input file `layout-input/1`. It is a `LayoutInput` with each field that a generator writes.
+ * `docs/FORMAT.md` gives each field.
+ */
+interface GeneratedInput extends LayoutInput$1 {
+  readonly set: string;
+  readonly family: string;
+  readonly seed: number;
   /** The origin: `made-up`, `published:<set>` or `known-best:<construction>`. */
-  source: string;
+  readonly source: string;
   /** The generator of a generated input. A hand-made or published input has `null`. */
-  generator: GeneratorStamp | null;
-  container: Container;
-  obstacles?: Obstacle[];
-  gap?: number;
-  boxes: Item[];
-  edges: Edge[];
-  base?: string;
-  change?: string;
-  step?: number;
+  readonly generator: GeneratorStamp | null;
+  readonly container: LayoutContainer$1;
+  readonly edges: readonly LayoutEdge$1[];
   /** The first 16 hex characters of the SHA-256 of the canonical form of the other fields. */
-  hash: string;
+  readonly hash: string;
 }
 /** The layout of the obstacles (`docs/research/TAXONOMY.md`, dimension 3). */
 type ObstacleLayout = "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
@@ -769,11 +617,14 @@ export declare function round3(x: number): number;
  */
 export declare function canonicalJson(value: unknown): string;
 /** This function gives the hash of an input file: the first 16 hex characters of the SHA-256 of its canonical form without `hash`. */
-export declare function hashInput(file: Omit<LayoutInput, "hash"> | LayoutInput): string;
+export declare function hashInput(file: LayoutInput$1): string;
 /** This function gives the scale of a count: the nearest of 1, 10, 100, 1000 and 10000 on a log scale. The count 0 gives `1`. */
 export declare function countCell(count: number): CountScale;
-/** This function gives the packing input of a file. The boxes become the items, and the edges go. */
-export declare function toPackInput(file: Pick<LayoutInput, "container" | "boxes" | "obstacles" | "gap">): PackInput;
+/**
+ * This function gives the packing input of a file. The boxes become the items, and the edges go.
+ * A file without a container gets `{ fixed: "none" }`, so the packer picks the size. It is `toPackInput` of the contract.
+ */
+export declare function toPackInput(file: Pick<LayoutInput$1, "container" | "boxes" | "obstacles" | "gap">): PackInput;
 /** A seeded generator of `layout-input/1` files. The same version, parameters and seed give the same file, byte for byte. */
 interface CorpusGenerator<P extends GeneratorParams = GeneratorParams> {
   /** The name. The file writes it in `generator.name`. */
@@ -791,7 +642,7 @@ interface CorpusGenerator<P extends GeneratorParams = GeneratorParams> {
   /** This method gives the cell of each input of the parameters. The cell does not depend on the seed. */
   cell(params?: Partial<P>): CorpusCell;
   /** This method gives the input file of a seed. The `id` is `<set>/<family>/s<seed>`. */
-  generate(seed: number, params?: Partial<P>, set?: string): LayoutInput;
+  generate(seed: number, params?: Partial<P>, set?: string): GeneratedInput;
 }
 /** The parameters of `rect-scattered`. */
 type RectScatteredParams = {
@@ -879,12 +730,12 @@ interface CorpusManifest {
 /** A corpus: the manifest and the input files, in the order of the specs and the seeds. */
 interface Corpus {
   manifest: CorpusManifest;
-  inputs: LayoutInput[];
+  inputs: GeneratedInput[];
 }
 /**
  * This function generates a corpus from specs. Each input gets the name of the corpus as its set. The function throws a
  * `RangeError` for an unknown generator, a different version or 2 inputs with the same id.
  */
 export declare function corpus(name: string, specs: readonly CorpusSpec[]): Corpus;
-export type { Cell, ChangeMeasures, Container, Corpus, CorpusCell, CorpusEntry, CorpusGenerator, CorpusManifest, CorpusSpec, CountScale, Dimension, DimensionValue, Direction, Edge, EdgeCase, EdgeCaseParams, FreeWidthOptions, FreeWidthResult, FreeWidthTry, GeneratorParams, GeneratorStamp, HardBreaks, Item, LayoutInput, LayoutMeasures, LayoutStrategyOptions, Margin, MeasureFamily, MeasureId, MeasureOptions, MeasureSpec, MetricsOptions, Obstacle, ObstacleLayout, PackContext, PackInput, PackLayoutOptions, PackOptions, PackOutput, PackingMetrics, Placement, Port, PushOptions, PushStrategyOptions, RectGridParams, RectScatteredParams, Region, ShelfOptions, SizeDistribution, SizeSearch, SortOrder, StageTrace, Strategy, Supports, Tolerance, UiParams };
+export { type Cell, type ChangeMeasures, type Corpus, type CorpusCell, type CorpusEntry, type CorpusGenerator, type CorpusManifest, type CorpusSpec, type CountScale, DEFAULT_TOLERANCE, type Dimension, type DimensionValue, type Direction, EPS, type EdgeCase, type EdgeCaseParams, type FreeWidthOptions, type FreeWidthResult, type FreeWidthTry, type GeneratedInput, type GeneratorParams, type GeneratorStamp, type Item, type LayoutContainer, type LayoutEdge, type LayoutInput, type LayoutMeasures, type LayoutStrategyOptions, type Margin, type MeasureFamily, type MeasureId, type MeasureOptions, type MeasureSpec, type MetricsOptions, type Obstacle, type ObstacleLayout, type PackContext, type PackHard, type PackInput, type PackLayoutOptions, type PackOptions, type PackOutput, type PackingMetrics, type Placement, type Port, type PushOptions, type PushStrategyOptions, RECORD_EPS, type RectGridParams, type RectScatteredParams, type Region, type ShelfOptions, type Side, type Sides, type SizeDistribution, type SizeSearch, type SortOrder, type StageTrace, type Strategy, type Supports, type Tolerance, type UiParams, checkInput, turnPoint, turnPort, turnRegion };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/contract.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["Item","Sides","ContractMeasureSpec","Direction","PackHard","LayoutContainer","LayoutEdge","LayoutInput"],"sources":["../src/vector.ts","../src/rect.ts","../src/order.ts","../src/pack.ts","../src/skyline.ts","../src/shelf.ts","../src/free.ts","../src/push.ts","../src/metrics.ts","../src/contract.ts","../src/measures.ts","../src/strategy.ts","../src/adapters.ts","../src/convert.ts","../src/registry.ts","../src/check.ts","../src/layout-input.ts","../src/generators.ts","../src/corpus.ts"],"mappings":"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"}