@thi.ng/grid-iterators 4.0.34 → 4.0.36

package/diamond-square.js

@@ -1,74 +1,54 @@
 import { defBitField } from "@thi.ng/bitfield/bitfield";
-/**
- * Yields iterator of 2D grid coordinates based on the recursive Diamond Square
- * algorithm. The given `exp` is a power of 2 exponent and the resulting
- * coordinates (in both directions) will be in the closed [0..2^exp] interval
- * (i.e. each axis is always a power-of-2 plus 1).
- *
- * @remarks
- * Reference: https://en.wikipedia.org/wiki/Diamond-square_algorithm
- *
- * @example
- * ```ts
- * // generate coords for a 17x17 grid
- * [...diamondSquare(4)]
- * // [
- * //   [0, 0],  [16, 0], [16, 16], [0, 16], [8, 0],  [8, 16],
- * //   [16, 8], [0, 8],  [8, 8],   [4, 0],  [12, 0], [12, 16],
- * //   [4, 16], [8, 4],  [8, 12],  [4, 8],  [12, 8], [0, 4],
- * //   ...
- * // ]
- * ```
- *
- * @param exp
- */
-export function* diamondSquare(exp) {
-    const size = 1 << exp;
-    const size1 = size + 1;
-    const s2 = size >> 1;
-    let res = size;
-    const idx = defBitField(size1 * size1);
-    const acc = [];
-    const $ = (x, y) => {
-        !idx.setAt(x + y * size1) && acc.push([x, y]);
-    };
-    $(0, 0);
-    $(res, 0);
-    $(res, res);
-    $(0, res);
-    yield* acc;
-    while (res > 1) {
-        const r2 = res >> 1;
-        for (let y = 0; y <= s2; y += res) {
-            const y1 = y + r2;
-            const y2 = y + res;
-            for (let x = r2; x <= s2; x += res) {
-                acc.length = 0;
-                const x1 = x - r2;
-                const x2 = x + r2;
-                $(x, y);
-                $(size - x, y);
-                $(size - x, size - y);
-                $(x, size - y);
-                $(x2, y1);
-                $(size - x2, y1);
-                $(size - x2, size - y1);
-                $(x2, size - y1);
-                $(x, y2);
-                $(size - x, y2);
-                $(size - x, size - y2);
-                $(x, size - y2);
-                $(x1, y1);
-                $(size - x1, y1);
-                $(size - x1, size - y1);
-                $(x1, size - y1);
-                $(x, y1);
-                $(size - x, y1);
-                $(size - x, size - y1);
-                $(x, size - y1);
-                yield* acc;
-            }
-        }
-        res = r2;
+function* diamondSquare(exp) {
+  const size = 1 << exp;
+  const size1 = size + 1;
+  const s2 = size >> 1;
+  let res = size;
+  const idx = defBitField(size1 * size1);
+  const acc = [];
+  const $ = (x, y) => {
+    !idx.setAt(x + y * size1) && acc.push([x, y]);
+  };
+  $(0, 0);
+  $(res, 0);
+  $(res, res);
+  $(0, res);
+  yield* acc;
+  while (res > 1) {
+    const r2 = res >> 1;
+    for (let y = 0; y <= s2; y += res) {
+      const y1 = y + r2;
+      const y2 = y + res;
+      for (let x = r2; x <= s2; x += res) {
+        acc.length = 0;
+        const x1 = x - r2;
+        const x2 = x + r2;
+        $(x, y);
+        $(size - x, y);
+        $(size - x, size - y);
+        $(x, size - y);
+        $(x2, y1);
+        $(size - x2, y1);
+        $(size - x2, size - y1);
+        $(x2, size - y1);
+        $(x, y2);
+        $(size - x, y2);
+        $(size - x, size - y2);
+        $(x, size - y2);
+        $(x1, y1);
+        $(size - x1, y1);
+        $(size - x1, size - y1);
+        $(x1, size - y1);
+        $(x, y1);
+        $(size - x, y1);
+        $(size - x, size - y1);
+        $(x, size - y1);
+        yield* acc;
+      }
     }
+    res = r2;
+  }
 }
+export {
+  diamondSquare
+};

package/filters.js

@@ -1,22 +1,12 @@
-/**
- * Returns true if x,y is on a right-to-left diagonal with spacing `n`.
- *
- * @param x
- * @param y
- * @param n
- */
-export const isOnDiagonal = ([x, y], n) => {
-    const d = ((x + y) / n) | 0;
-    return y === d * n - x;
+const isOnDiagonal = ([x, y], n) => {
+  const d = (x + y) / n | 0;
+  return y === d * n - x;
 };
-/**
- * Returns true if x,y is on a left-to-right diagonal with spacing `n`.
- *
- * @param x
- * @param y
- * @param n
- */
-export const isOnDiagonalAlt = ([x, y], N) => {
-    const d = ((x - y) / N) | 0;
-    return -y === d * N - x;
+const isOnDiagonalAlt = ([x, y], N) => {
+  const d = (x - y) / N | 0;
+  return -y === d * N - x;
+};
+export {
+  isOnDiagonal,
+  isOnDiagonalAlt
 };

package/flood-fill.js

@@ -1,81 +1,47 @@
 import { BitField, defBitField } from "@thi.ng/bitfield/bitfield";
-/**
- * Yields an iterator of 2D coordinates of the connected region around `x,y` for
- * which the given predicate succeeds. I.e. The function recursively explores
- * (in a row-major manner) the space in the `[0,0]..(width,height)` interval,
- * starting at given `x,y` and continues as long given predicate function
- * returns a truthy value.
- *
- * @remarks
- * Only the behavior is recursive, not the actual implementation (stack based).
- * Grid cells are visited max. once. A bit field is used to mark visited cells.
- *
- * @example
- * ```ts
- * const img = [
- *   1,0,1,0,
- *   0,0,0,0,
- *   0,1,1,0,
- *   0,1,1,1,
- * ];
- *
- * // flood fill connected region from point (2,1)
- * [...floodFill((x, y) => img[y * 4 + x] === 0, 2, 1, 4, 4)]
- * // [
- * //   [2, 1], [1, 1], [0, 1], [3, 1], [3, 2],
- * //   [3, 0], [0, 2], [0, 3], [1, 0]
- * // ]
- * ```
- *
- * @param pred -
- * @param x -
- * @param y -
- * @param width -
- * @param height -
- */
-export function* floodFill(pred, x, y, width, height) {
-    x |= 0;
-    y |= 0;
-    if (!pred(x, y))
-        return;
-    const queue = [[x, y]];
-    const visited = defBitField(width * height);
-    height--;
-    while (queue.length) {
-        [x, y] = queue.pop();
-        yield* partialRow(pred, queue, visited, x, y, width, height, -1);
-        yield* partialRow(pred, queue, visited, x + 1, y, width, height, 1);
-    }
+function* floodFill(pred, x, y, width, height) {
+  x |= 0;
+  y |= 0;
+  if (!pred(x, y))
+    return;
+  const queue = [[x, y]];
+  const visited = defBitField(width * height);
+  height--;
+  while (queue.length) {
+    [x, y] = queue.pop();
+    yield* partialRow(pred, queue, visited, x, y, width, height, -1);
+    yield* partialRow(pred, queue, visited, x + 1, y, width, height, 1);
+  }
 }
-/** @internal */
 function* partialRow(pred, queue, visited, x, y, width, height1, step) {
-    let idx = y * width + x;
-    if (visited.at(idx))
-        return;
-    let scanUp = false;
-    let scanDown = false;
-    while (x >= 0 && x < width && pred(x, y)) {
-        visited.setAt(idx);
-        yield [x, y];
-        if (y > 0) {
-            if (pred(x, y - 1) && !scanUp) {
-                queue.push([x, y - 1]);
-                scanUp = true;
-            }
-            else {
-                scanUp = false;
-            }
-        }
-        if (y < height1) {
-            if (pred(x, y + 1) && !scanDown) {
-                queue.push([x, y + 1]);
-                scanDown = true;
-            }
-            else {
-                scanDown = false;
-            }
-        }
-        x += step;
-        idx += step;
+  let idx = y * width + x;
+  if (visited.at(idx))
+    return;
+  let scanUp = false;
+  let scanDown = false;
+  while (x >= 0 && x < width && pred(x, y)) {
+    visited.setAt(idx);
+    yield [x, y];
+    if (y > 0) {
+      if (pred(x, y - 1) && !scanUp) {
+        queue.push([x, y - 1]);
+        scanUp = true;
+      } else {
+        scanUp = false;
+      }
+    }
+    if (y < height1) {
+      if (pred(x, y + 1) && !scanDown) {
+        queue.push([x, y + 1]);
+        scanDown = true;
+      } else {
+        scanDown = false;
+      }
     }
+    x += step;
+    idx += step;
+  }
 }
+export {
+  floodFill
+};

package/hilbert.js

@@ -1,65 +1,45 @@
 import { __opts } from "./utils.js";
-/**
- * Yields sequence of 2D grid coordinates along 2D Hilbert curve using given
- * `cols` and `rows` (each max. 32768 (2^15)).
- *
- * Ported & modified from original Java code by Christopher Kulla.
- * https://sourceforge.net/p/sunflow/code/HEAD/tree/trunk/src/org/sunflow/core/bucket/HilbertBucketOrder.java
- *
- * @param opts -
- */
-export function* hilbert2d(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    let hIndex = 0; // hilbert curve index
-    let hOrder = 0; // hilbert curve order
-    // fit to number of buckets
-    while ((1 << hOrder < cols || 1 << hOrder < rows) && hOrder < 15)
-        hOrder++;
-    const numBuckets = 1 << (2 * hOrder);
-    for (let i = 0, n = cols * rows; i < n; i++) {
-        let hx, hy;
-        do {
-            // adapted from Hacker's Delight
-            let s, t, comp, swap, cs, sr;
-            // s is the hilbert index, shifted to start in the middle
-            s = hIndex | (0x55555555 << (2 * hOrder)); // Pad s on left with 01
-            sr = (s >>> 1) & 0x55555555; // (no change) groups.
-            cs = ((s & 0x55555555) + sr) ^ 0x55555555;
-            // Compute complement & swap info in two-bit groups.
-            // Parallel prefix xor op to propagate both complement and
-            // swap info together from left to right (there is no step
-            // "cs ^= cs >> 1", so in effect it computes two independent
-            // parallel prefix operations on two interleaved sets of
-            // sixteen bits).
-            cs = cs ^ (cs >>> 2);
-            cs = cs ^ (cs >>> 4);
-            cs = cs ^ (cs >>> 8);
-            cs = cs ^ (cs >>> 16);
-            // Separate the swap and complement bits.
-            swap = cs & 0x55555555;
-            comp = (cs >>> 1) & 0x55555555;
-            // Calculate x and y in the odd & even bit positions
-            t = (s & swap) ^ comp;
-            s = s ^ sr ^ t ^ (t << 1);
-            // Clear out any junk on the left (unpad).
-            s = s & ((1 << (2 * hOrder)) - 1);
-            // Now "unshuffle" to separate the x and y bits.
-            t = (s ^ (s >>> 1)) & 0x22222222;
-            s = s ^ t ^ (t << 1);
-            t = (s ^ (s >>> 2)) & 0x0c0c0c0c;
-            s = s ^ t ^ (t << 2);
-            t = (s ^ (s >>> 4)) & 0x00f000f0;
-            s = s ^ t ^ (t << 4);
-            t = (s ^ (s >>> 8)) & 0x0000ff00;
-            s = s ^ t ^ (t << 8);
-            // Assign the two halves to x and y.
-            hx = s >>> 16;
-            hy = s & 0xffff;
-            hIndex++;
-        } while (
-        // Dont't emit any outside cells
-        (hx >= cols || hy >= rows || hx < 0 || hy < 0) &&
-            hIndex < numBuckets);
-        yield tx(hx, hy);
-    }
+function* hilbert2d(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  let hIndex = 0;
+  let hOrder = 0;
+  while ((1 << hOrder < cols || 1 << hOrder < rows) && hOrder < 15)
+    hOrder++;
+  const numBuckets = 1 << 2 * hOrder;
+  for (let i = 0, n = cols * rows; i < n; i++) {
+    let hx, hy;
+    do {
+      let s, t, comp, swap, cs, sr;
+      s = hIndex | 1431655765 << 2 * hOrder;
+      sr = s >>> 1 & 1431655765;
+      cs = (s & 1431655765) + sr ^ 1431655765;
+      cs = cs ^ cs >>> 2;
+      cs = cs ^ cs >>> 4;
+      cs = cs ^ cs >>> 8;
+      cs = cs ^ cs >>> 16;
+      swap = cs & 1431655765;
+      comp = cs >>> 1 & 1431655765;
+      t = s & swap ^ comp;
+      s = s ^ sr ^ t ^ t << 1;
+      s = s & (1 << 2 * hOrder) - 1;
+      t = (s ^ s >>> 1) & 572662306;
+      s = s ^ t ^ t << 1;
+      t = (s ^ s >>> 2) & 202116108;
+      s = s ^ t ^ t << 2;
+      t = (s ^ s >>> 4) & 15728880;
+      s = s ^ t ^ t << 4;
+      t = (s ^ s >>> 8) & 65280;
+      s = s ^ t ^ t << 8;
+      hx = s >>> 16;
+      hy = s & 65535;
+      hIndex++;
+    } while (
+      // Dont't emit any outside cells
+      (hx >= cols || hy >= rows || hx < 0 || hy < 0) && hIndex < numBuckets
+    );
+    yield tx(hx, hy);
+  }
 }
+export {
+  hilbert2d
+};

package/hvline.js

@@ -1,33 +1,39 @@
 import { asInt } from "@thi.ng/api/typedarray";
-export function* hline(x, y, len) {
-    [x, y, len] = asInt(x, y, len);
-    for (const xmax = x + len; x < xmax; x++) {
-        yield [x, y];
-    }
+function* hline(x, y, len) {
+  [x, y, len] = asInt(x, y, len);
+  for (const xmax = x + len; x < xmax; x++) {
+    yield [x, y];
+  }
 }
-export function* vline(x, y, len) {
-    [x, y, len] = asInt(x, y, len);
-    for (const ymax = y + len; y < ymax; y++) {
-        yield [x, y];
-    }
+function* vline(x, y, len) {
+  [x, y, len] = asInt(x, y, len);
+  for (const ymax = y + len; y < ymax; y++) {
+    yield [x, y];
+  }
 }
-export function* hlineClipped(x, y, len, left, top, right, bottom) {
-    [x, y, len] = asInt(x, y, len);
-    if (x >= right || y < top || y >= bottom)
-        return;
-    if (x < left) {
-        len += x - left;
-        x = left;
-    }
-    yield* hline(x, y, Math.min(len, right - x));
+function* hlineClipped(x, y, len, left, top, right, bottom) {
+  [x, y, len] = asInt(x, y, len);
+  if (x >= right || y < top || y >= bottom)
+    return;
+  if (x < left) {
+    len += x - left;
+    x = left;
+  }
+  yield* hline(x, y, Math.min(len, right - x));
 }
-export function* vlineClipped(x, y, len, left, top, right, bottom) {
-    [x, y, len] = asInt(x, y, len);
-    if (x < left || x >= right || y >= bottom)
-        return;
-    if (y < top) {
-        len += y - top;
-        y = top;
-    }
-    yield* vline(x, y, Math.min(len, bottom - y));
+function* vlineClipped(x, y, len, left, top, right, bottom) {
+  [x, y, len] = asInt(x, y, len);
+  if (x < left || x >= right || y >= bottom)
+    return;
+  if (y < top) {
+    len += y - top;
+    y = top;
+  }
+  yield* vline(x, y, Math.min(len, bottom - y));
 }
+export {
+  hline,
+  hlineClipped,
+  vline,
+  vlineClipped
+};

package/interleave.js

@@ -1,46 +1,21 @@
 import { map } from "@thi.ng/transducers/map";
 import { range2d } from "@thi.ng/transducers/range2d";
 import { __opts } from "./utils.js";
-/**
- * Yields 2D grid coordinates in the order of interleaved columns with
- * configurable `step` size (default: 2).
- *
- * @remarks
- * Returns columns in this order:
- *
- * - 0, step, 2 * step, 3 * step...
- * - 1, 2 * step + 1, 3 * step + 1...
- * - etc.
- *
- * Also see {@link interleaveRows2d}.
- *
- * @param opts -
- */
-export function* interleaveColumns2d(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    const step = (opts.step != null ? opts.step : 2) | 0;
-    for (let j = 0; j < step; j++) {
-        yield* map((p) => tx(p[1], p[0]), range2d(0, rows, j, cols, 1, step));
-    }
+function* interleaveColumns2d(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  const step = (opts.step != null ? opts.step : 2) | 0;
+  for (let j = 0; j < step; j++) {
+    yield* map((p) => tx(p[1], p[0]), range2d(0, rows, j, cols, 1, step));
+  }
 }
-/**
- * Similar to {@link interleaveColumns2d}, but yields 2D grid coordinates in
- * the order of interleaved rows with configurable `step` size (default:
- * 2).
- *
- * @remarks
- * Returns rows in this order:
- *
- * - 0, step, 2 * step, 3 * step...
- * - 1, 2 * step + 1, 3 * step + 1...
- * - etc.
- *
- * @param opts -
- */
-export function* interleaveRows2d(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    const step = (opts.step != null ? opts.step : 2) | 0;
-    for (let j = 0; j < step; j++) {
-        yield* map((p) => tx(p[0], p[1]), range2d(0, cols, j, rows, 1, step));
-    }
+function* interleaveRows2d(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  const step = (opts.step != null ? opts.step : 2) | 0;
+  for (let j = 0; j < step; j++) {
+    yield* map((p) => tx(p[0], p[1]), range2d(0, cols, j, rows, 1, step));
+  }
 }
+export {
+  interleaveColumns2d,
+  interleaveRows2d
+};

package/line.js

@@ -1,42 +1,32 @@
 import { asInt } from "@thi.ng/api/typedarray";
 import { liangBarsky } from "./clipping.js";
-export function* line(ax, ay, bx, by) {
-    [ax, ay, bx, by] = asInt(ax, ay, bx, by);
-    const dx = Math.abs(bx - ax);
-    const dy = -Math.abs(by - ay);
-    const sx = ax < bx ? 1 : -1;
-    const sy = ay < by ? 1 : -1;
-    let err = dx + dy;
-    while (true) {
-        yield [ax, ay];
-        if (ax === bx && ay === by)
-            return;
-        let t = err << 1;
-        if (t < dx) {
-            err += dx;
-            ay += sy;
-        }
-        if (t > dy) {
-            err += dy;
-            ax += sx;
-        }
+function* line(ax, ay, bx, by) {
+  [ax, ay, bx, by] = asInt(ax, ay, bx, by);
+  const dx = Math.abs(bx - ax);
+  const dy = -Math.abs(by - ay);
+  const sx = ax < bx ? 1 : -1;
+  const sy = ay < by ? 1 : -1;
+  let err = dx + dy;
+  while (true) {
+    yield [ax, ay];
+    if (ax === bx && ay === by)
+      return;
+    let t = err << 1;
+    if (t < dx) {
+      err += dx;
+      ay += sy;
     }
+    if (t > dy) {
+      err += dy;
+      ax += sx;
+    }
+  }
 }
-/**
- * Version of {@link line} yielding only coordinates in rect defined by
- * `left,top`..`right,bottom`. Returns undefined if circle lies completely
- * outside given clip rectangle.
- *
- * @param x1 -
- * @param y1 -
- * @param x2 -
- * @param y2 -
- * @param left -
- * @param top -
- * @param right -
- * @param bottom -
- */
-export const lineClipped = (x1, y1, x2, y2, left, top, right, bottom) => {
-    const res = liangBarsky(x1, y1, x2, y2, left, top, right - 1, bottom - 1);
-    return res ? line(res[0], res[1], res[2], res[3]) : undefined;
+const lineClipped = (x1, y1, x2, y2, left, top, right, bottom) => {
+  const res = liangBarsky(x1, y1, x2, y2, left, top, right - 1, bottom - 1);
+  return res ? line(res[0], res[1], res[2], res[3]) : void 0;
+};
+export {
+  line,
+  lineClipped
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/grid-iterators",
-  "version": "4.0.34",
+  "version": "4.0.36",
   "description": "2D grid and shape iterators w/ multiple orderings",
   "type": "module",
   "module": "./index.js",
@@ -24,8 +24,10 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
     "build:assets": "node tools/build-assets",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc internal",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -35,18 +37,18 @@
     "tool:assets": "tools:node-esm tools/build-assets.ts"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/arrays": "^2.7.6",
-    "@thi.ng/binary": "^3.3.39",
-    "@thi.ng/bitfield": "^2.3.8",
-    "@thi.ng/errors": "^2.4.4",
-    "@thi.ng/morton": "^3.1.55",
-    "@thi.ng/random": "^3.6.16",
-    "@thi.ng/transducers": "^8.8.13"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/arrays": "^2.7.8",
+    "@thi.ng/binary": "^3.4.0",
+    "@thi.ng/bitfield": "^2.3.10",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/morton": "^3.1.57",
+    "@thi.ng/random": "^3.6.18",
+    "@thi.ng/transducers": "^8.8.15"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -165,5 +167,5 @@
     ],
     "year": 2019
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }