@mark1russell7/packing 0.1.3 → 0.1.4

package/src/index.ts

@@ -48,3 +48,37 @@ export { logSweep, push, rows, shelf, skyline, type LayoutStrategyOptions, type
 export { fromRects, toRects } from "./convert.ts";
 export { packWith, strategies, strategy } from "./registry.ts";
 export { checkHard, type HardBreaks } from "./check.ts";
+export {
+  canonicalJson,
+  countCell,
+  fnv1a32,
+  hashInput,
+  round3,
+  toPackInput,
+  type CorpusCell,
+  type CountScale,
+  type Edge,
+  type GeneratorParams,
+  type GeneratorStamp,
+  type LayoutInput,
+  type ObstacleLayout,
+  type SizeDistribution,
+} from "./layout-input.ts";
+export {
+  cards,
+  dashboard,
+  edgeCases,
+  gallery,
+  generator,
+  generators,
+  rectGrid,
+  rectScattered,
+  wordCloud,
+  type CorpusGenerator,
+  type EdgeCase,
+  type EdgeCaseParams,
+  type RectGridParams,
+  type RectScatteredParams,
+  type UiParams,
+} from "./generators.ts";
+export { corpus, type Corpus, type CorpusEntry, type CorpusManifest, type CorpusSpec } from "./corpus.ts";

package/src/layout-input.ts

@@ -0,0 +1,120 @@
+// The input file `layout-input/1` of `docs/FORMAT.md`: its types, its numbers, its canonical form and its hash.
+
+import type { Container, Item, Obstacle, PackInput } from "./contract.ts";
+import { sha256Hex, utf8 } from "./sha256.ts";
+import type { Cell } from "./strategy.ts";
+
+/** An edge between two boxes. The router reads it, and the packer ignores it. */
+export interface Edge {
+  id: string;
+  source: string;
+  target: string;
+  sourcePort?: string;
+  targetPort?: string;
+}
+
+/** The parameters of a generator: a name and a string or a number for each parameter. */
+export type GeneratorParams = Record<string, string | number>;
+
+/** The stamp of a generated input: the generator, its version, the full parameters and the seed. */
+export interface GeneratorStamp {
+  name: string;
+  version: number;
+  params: GeneratorParams;
+  seed: number;
+}
+
+/** One input file `layout-input/1`. `docs/FORMAT.md` gives each field. */
+export interface LayoutInput {
+  schema: "layout-input/1";
+  id: string;
+  set: string;
+  family: string;
+  seed: number;
+  /** The origin: `made-up`, `published:<set>` or `known-best:<construction>`. */
+  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;
+  /** The first 16 hex characters of the SHA-256 of the canonical form of the other fields. */
+  hash: string;
+}
+
+/** The layout of the obstacles (`docs/research/TAXONOMY.md`, dimension 3). */
+export type ObstacleLayout = "none" | "center" | "scattered" | "wall" | "corridors" | "touching" | "edge";
+
+/** The distribution of the sizes of the items (`docs/research/TAXONOMY.md`, dimension 6). */
+export type SizeDistribution = "identical" | "nearIdentical" | "uniform" | "heavyTail" | "bimodal" | "extremeAspect";
+
+/** The scale of the count of the items (`docs/research/TAXONOMY.md`, dimension 7). */
+export type CountScale = "1" | "10" | "100" | "1k" | "10k";
+
+/**
+ * The cell of a generated input: one value for each dimension of the packer. The cell of `cellOf` has the dimensions
+ * that the input tells. The generator adds the layout of the obstacles, the sizes, the count and the mode.
+ */
+export interface CorpusCell extends Cell {
+  obstacles: ObstacleLayout;
+  sizes: SizeDistribution;
+  count: CountScale;
+  mode: "offline" | "online" | "incremental";
+}
+
+/** This function gives the `fnv1a32` hash of the UTF-8 bytes of a string, as `docs/FORMAT.md` gives it. */
+export function fnv1a32(text: string): number {
+  let h = 0x811c9dc5;
+  for (const b of utf8(text)) h = Math.imul(h ^ b, 0x01000193) >>> 0;
+  return h;
+}
+
+/** This function rounds the numbers of a file to 3 decimals. A half goes up, and the value `-0` becomes 0. */
+export function round3(x: number): number {
+  const v = Math.round(x * 1000) / 1000;
+  return Object.is(v, -0) ? 0 : v;
+}
+
+/**
+ * This function gives the canonical form of a value: sorted keys, no whitespace and the numbers of `JSON.stringify`
+ * after `round3`. A key with the value `undefined` is not in the form.
+ */
+export function canonicalJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value as Record<string, unknown>)
+      .filter(([, v]) => v !== undefined)
+      .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+  }
+  return JSON.stringify(typeof value === "number" ? round3(value) : value);
+}
+
+/** 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 function hashInput(file: Omit<LayoutInput, "hash"> | LayoutInput): string {
+  const rest: Partial<LayoutInput> = { ...file };
+  delete rest.hash;
+  return sha256Hex(canonicalJson(rest)).slice(0, 16);
+}
+
+/** 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 function countCell(count: number): CountScale {
+  if (count <= 3) return "1";
+  if (count <= 31) return "10";
+  if (count <= 316) return "100";
+  if (count <= 3162) return "1k";
+  return "10k";
+}
+
+/** This function gives the packing input of a file. The boxes become the items, and the edges go. */
+export function toPackInput(file: Pick<LayoutInput, "container" | "boxes" | "obstacles" | "gap">): PackInput {
+  const input: PackInput = { container: file.container, items: file.boxes };
+  if (file.obstacles !== undefined) input.obstacles = file.obstacles;
+  if (file.gap !== undefined) input.gap = file.gap;
+  return input;
+}

package/src/sha256.ts

@@ -0,0 +1,93 @@
+// SHA-256 (FIPS 180-4) in plain TypeScript. The hash of a corpus file needs it, and a browser has no synchronous SHA-256.
+
+/** The round constants of SHA-256. */
+const K = new Uint32Array([
+  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be,
+  0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa,
+  0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85,
+  0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+  0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
+  0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+/** The first hash value of SHA-256. */
+const H0 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+
+/** This function turns a 32-bit word to the right by `n` bits. */
+const rotr = (x: number, n: number): number => (x >>> n) | (x << (32 - n));
+
+/**
+ * This function gives the UTF-8 bytes of a string. A lone surrogate becomes U+FFFD, as with `TextEncoder`. The
+ * package has no `TextEncoder` type, because its code operates on each runtime with no global types.
+ */
+export function utf8(text: string): Uint8Array {
+  const out: number[] = [];
+  for (let i = 0; i < text.length; i++) {
+    let c = text.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff && i + 1 < text.length) {
+      const next = text.charCodeAt(i + 1);
+      if (next >= 0xdc00 && next <= 0xdfff) {
+        c = 0x10000 + ((c - 0xd800) << 10) + (next - 0xdc00);
+        i++;
+      }
+    }
+    if (c >= 0xd800 && c <= 0xdfff) c = 0xfffd;
+    if (c < 0x80) out.push(c);
+    else if (c < 0x800) out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+    else if (c < 0x10000) out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    else out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+  }
+  return Uint8Array.from(out);
+}
+
+/** This function gives the SHA-256 of the UTF-8 bytes of a string, as 64 lowercase hex characters. */
+export function sha256Hex(text: string): string {
+  const bytes = utf8(text);
+  const length = bytes.length;
+  const padded = new Uint8Array((((length + 9 + 63) / 64) | 0) * 64);
+  padded.set(bytes);
+  padded[length] = 0x80;
+  const view = new DataView(padded.buffer);
+  const bits = length * 8;
+  view.setUint32(padded.length - 8, Math.floor(bits / 0x100000000));
+  view.setUint32(padded.length - 4, bits >>> 0);
+
+  const hash = [...H0];
+  const w = new Uint32Array(64);
+  for (let block = 0; block < padded.length; block += 64) {
+    for (let t = 0; t < 16; t++) w[t] = view.getUint32(block + t * 4);
+    for (let t = 16; t < 64; t++) {
+      const a = w[t - 15]!;
+      const b = w[t - 2]!;
+      const s0 = rotr(a, 7) ^ rotr(a, 18) ^ (a >>> 3);
+      const s1 = rotr(b, 17) ^ rotr(b, 19) ^ (b >>> 10);
+      w[t] = (w[t - 16]! + s0 + w[t - 7]! + s1) | 0;
+    }
+    let [a, b, c, d, e, f, g, h] = hash as [number, number, number, number, number, number, number, number];
+    for (let t = 0; t < 64; t++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = (e & f) ^ (~e & g);
+      const t1 = (h + s1 + ch + K[t]! + w[t]!) | 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = (a & b) ^ (a & c) ^ (b & c);
+      const t2 = (s0 + maj) | 0;
+      h = g;
+      g = f;
+      f = e;
+      e = (d + t1) | 0;
+      d = c;
+      c = b;
+      b = a;
+      a = (t1 + t2) | 0;
+    }
+    hash[0] = (hash[0]! + a) | 0;
+    hash[1] = (hash[1]! + b) | 0;
+    hash[2] = (hash[2]! + c) | 0;
+    hash[3] = (hash[3]! + d) | 0;
+    hash[4] = (hash[4]! + e) | 0;
+    hash[5] = (hash[5]! + f) | 0;
+    hash[6] = (hash[6]! + g) | 0;
+    hash[7] = (hash[7]! + h) | 0;
+  }
+  return hash.map((x) => (x >>> 0).toString(16).padStart(8, "0")).join("");
+}