@thi.ng/grid-iterators 4.0.35 → 4.0.36

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/README.md

@@ -241,7 +241,7 @@ For Node.js REPL:
 const gridIterators = await import("@thi.ng/grid-iterators");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 2.58 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 2.61 KB
 
 ## Dependencies
 

package/api.js

@@ -1 +0,0 @@
-export {};

package/circle.js

@@ -1,73 +1,60 @@
 import { asInt } from "@thi.ng/api/typedarray";
 import { clipped, intersectRectCircle } from "./clipping.js";
 import { hline } from "./hvline.js";
-export function* circle(cx, cy, r, fill = true) {
-    [cx, cy, r] = asInt(cx, cy, r);
-    if (r < 1)
-        return;
-    let x = 0;
-    let y = r;
-    let y2 = r * r;
-    let sum = y2 + r;
-    let dx2 = 1;
-    let dy2 = 2 * r - 1;
-    while (x <= y) {
-        if (fill) {
-            yield* hline(cx - y, cy + x, y << 1);
-            if (x)
-                yield* hline(cx - y, cy - x, y << 1);
+function* circle(cx, cy, r, fill = true) {
+  [cx, cy, r] = asInt(cx, cy, r);
+  if (r < 1)
+    return;
+  let x = 0;
+  let y = r;
+  let y2 = r * r;
+  let sum = y2 + r;
+  let dx2 = 1;
+  let dy2 = 2 * r - 1;
+  while (x <= y) {
+    if (fill) {
+      yield* hline(cx - y, cy + x, y << 1);
+      if (x)
+        yield* hline(cx - y, cy - x, y << 1);
+    } else {
+      yield [cx - y, cy + x];
+      if (y)
+        yield [cx + y, cy + x];
+      if (x) {
+        yield [cx - y, cy - x];
+        if (y)
+          yield [cx + y, cy - x];
+      }
+      if (x !== y) {
+        yield [cx - x, cy - y];
+        if (x)
+          yield [cx + x, cy - y];
+        if (y) {
+          yield [cx - x, cy + y];
+          if (x)
+            yield [cx + x, cy + y];
         }
-        else {
-            yield [cx - y, cy + x];
-            if (y)
-                yield [cx + y, cy + x];
-            if (x) {
-                yield [cx - y, cy - x];
-                if (y)
-                    yield [cx + y, cy - x];
-            }
-            if (x !== y) {
-                yield [cx - x, cy - y];
-                if (x)
-                    yield [cx + x, cy - y];
-                if (y) {
-                    yield [cx - x, cy + y];
-                    if (x)
-                        yield [cx + x, cy + y];
-                }
-            }
-        }
-        sum -= dx2;
-        if (sum <= y2) {
-            if (fill && x !== y) {
-                yield* hline(cx - x, cy - y, x << 1);
-                if (y)
-                    yield* hline(cx - x, cy + y, x << 1);
-            }
-            y--;
-            y2 -= dy2;
-            dy2 -= 2;
-        }
-        x++;
-        dx2 += 2;
+      }
     }
+    sum -= dx2;
+    if (sum <= y2) {
+      if (fill && x !== y) {
+        yield* hline(cx - x, cy - y, x << 1);
+        if (y)
+          yield* hline(cx - x, cy + y, x << 1);
+      }
+      y--;
+      y2 -= dy2;
+      dy2 -= 2;
+    }
+    x++;
+    dx2 += 2;
+  }
 }
-/**
- * Version of {@link circle} yielding only coordinates in rect defined by
- * `left,top`..`right,bottom`. Returns undefined if circle lies completely
- * outside given clip rectangle.
- *
- * @param cx -
- * @param cy -
- * @param r -
- * @param left -
- * @param top -
- * @param right -
- * @param bottom -
- * @param fill -
- */
-export const circleClipped = (cx, cy, r, left, top, right, bottom, fill = true) => {
-    return intersectRectCircle(left, top, right, bottom, cx, cy, r)
-        ? clipped(circle(cx, cy, r, fill), left, top, right, bottom)
-        : undefined;
+const circleClipped = (cx, cy, r, left, top, right, bottom, fill = true) => {
+  return intersectRectCircle(left, top, right, bottom, cx, cy, r) ? clipped(circle(cx, cy, r, fill), left, top, right, bottom) : void 0;
+};
+export {
+  circle,
+  circleClipped
 };

package/clipping.js

@@ -1,77 +1,36 @@
-/**
- * Filters points from `src` iterable to remove any falling outside the rect
- * defined by `left,top`..`right,bottom`.
- *
- * @param src -
- * @param left -
- * @param top -
- * @param right -
- * @param bottom -
- */
-export function* clipped(src, left, top, right, bottom) {
-    for (let p of src) {
-        if (p[0] >= left && p[0] < right && p[1] >= top && p[1] < bottom)
-            yield p;
-    }
+function* clipped(src, left, top, right, bottom) {
+  for (let p of src) {
+    if (p[0] >= left && p[0] < right && p[1] >= top && p[1] < bottom)
+      yield p;
+  }
 }
-/** @internal */
 const axis = (a, b, c) => (a < b ? a - b : a > b + c ? a - b - c : 0) ** 2;
-/**
- * Based on [thi.ng/geom-isec](https://thi.ng/geom-isec), but inlined to avoid
- * dependency.
- *
- * @param x -
- * @param y -
- * @param w -
- * @param h -
- * @param cx -
- * @param cy -
- * @param r -
- *
- * @internal
- */
-export const intersectRectCircle = (x, y, w, h, cx, cy, r) => axis(cx, x, w) + axis(cy, y, h) <= r * r;
-/**
- * Based on [`liangBarsky2Raw()`](https://docs.thi.ng/umbrella/geom-clip-line/functions/liangBarsky2Raw.html), but with diff return type.
- *
- * @param ax -
- * @param ay -
- * @param bx -
- * @param by -
- * @param minx -
- * @param miny -
- * @param maxx -
- * @param maxy -
- *
- * @internal
- */
-export const liangBarsky = (ax, ay, bx, by, minx, miny, maxx, maxy) => {
-    const dx = bx - ax;
-    const dy = by - ay;
-    let alpha = 0;
-    let beta = 1;
-    const clip = (p, q) => {
-        if (p < 0) {
-            const r = q / p;
-            if (r > beta)
-                return false;
-            r > alpha && (alpha = r);
-        }
-        else if (p > 0) {
-            const r = q / p;
-            if (r < alpha)
-                return false;
-            r < beta && (beta = r);
-        }
-        else if (q < 0) {
-            return false;
-        }
-        return true;
-    };
-    return clip(-dx, ax - minx) &&
-        clip(dx, maxx - ax) &&
-        clip(-dy, ay - miny) &&
-        clip(dy, maxy - ay)
-        ? [alpha * dx + ax, alpha * dy + ay, beta * dx + ax, beta * dy + ay]
-        : undefined;
+const intersectRectCircle = (x, y, w, h, cx, cy, r) => axis(cx, x, w) + axis(cy, y, h) <= r * r;
+const liangBarsky = (ax, ay, bx, by, minx, miny, maxx, maxy) => {
+  const dx = bx - ax;
+  const dy = by - ay;
+  let alpha = 0;
+  let beta = 1;
+  const clip = (p, q) => {
+    if (p < 0) {
+      const r = q / p;
+      if (r > beta)
+        return false;
+      r > alpha && (alpha = r);
+    } else if (p > 0) {
+      const r = q / p;
+      if (r < alpha)
+        return false;
+      r < beta && (beta = r);
+    } else if (q < 0) {
+      return false;
+    }
+    return true;
+  };
+  return clip(-dx, ax - minx) && clip(dx, maxx - ax) && clip(-dy, ay - miny) && clip(dy, maxy - ay) ? [alpha * dx + ax, alpha * dy + ay, beta * dx + ax, beta * dy + ay] : void 0;
+};
+export {
+  clipped,
+  intersectRectCircle,
+  liangBarsky
 };

package/column-ends.js

@@ -1,15 +1,12 @@
 import { __opts } from "./utils.js";
-/**
- * Filtered version of {@link columns2d}, only including end points of
- * each column.
- *
- * @param opts -
- */
-export function* columnEnds2d(opts) {
-    let { cols, rows, tx } = __opts(opts);
-    rows--;
-    for (let x = 0; x < cols; x++) {
-        yield tx(x, 0);
-        yield tx(x, rows);
-    }
+function* columnEnds2d(opts) {
+  let { cols, rows, tx } = __opts(opts);
+  rows--;
+  for (let x = 0; x < cols; x++) {
+    yield tx(x, 0);
+    yield tx(x, rows);
+  }
 }
+export {
+  columnEnds2d
+};

package/columns.js

@@ -1,11 +1,9 @@
 import { repeatedly2d } from "@thi.ng/transducers/repeatedly2d";
 import { __opts } from "./utils.js";
-/**
- * Yields sequence of 2D grid coordinates in column-major order.
- *
- * @param opts -
- */
-export const columns2d = (opts) => {
-    const { cols, rows, tx } = __opts(opts);
-    return repeatedly2d((y, x) => tx(x, y), rows | 0, cols | 0);
+const columns2d = (opts) => {
+  const { cols, rows, tx } = __opts(opts);
+  return repeatedly2d((y, x) => tx(x, y), rows | 0, cols | 0);
+};
+export {
+  columns2d
 };

package/diagonal-ends.js

@@ -1,28 +1,21 @@
 import { diagonal2d } from "./diagonal.js";
 import { __opts } from "./utils.js";
-/**
- * Filtered version of {@link diagonal2d}, only including end points of the
- * diagonals. Unless `all` option is enabled (default: false), the very first
- * and last points are skipped, i.e. `[0,0]` and `[cols-1, rows-1]`.
- *
- * @remarks
- * `cols` and `rows` MUST be both >= 2.
- *
- * @param opts -
- */
-export function* diagonalEnds2d(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    const num = cols * rows - 1;
-    const maxX = cols - 1;
-    const maxY = rows - 1;
-    const check = opts.all ? (i) => i > 0 && i < num : () => true;
-    let i = 0;
-    for (let p of diagonal2d({ cols, rows })) {
-        if (check(i)) {
-            const [x, y] = p;
-            if (x === 0 || x === maxX || y === 0 || y === maxY)
-                yield tx(x, y);
-        }
-        i++;
+function* diagonalEnds2d(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  const num = cols * rows - 1;
+  const maxX = cols - 1;
+  const maxY = rows - 1;
+  const check = opts.all ? (i2) => i2 > 0 && i2 < num : () => true;
+  let i = 0;
+  for (let p of diagonal2d({ cols, rows })) {
+    if (check(i)) {
+      const [x, y] = p;
+      if (x === 0 || x === maxX || y === 0 || y === maxY)
+        yield tx(x, y);
     }
+    i++;
+  }
 }
+export {
+  diagonalEnds2d
+};

package/diagonal-slope.js

@@ -1,112 +1,80 @@
 import { assert } from "@thi.ng/errors/assert";
 import { __opts } from "./utils.js";
-/**
- * Similar to {@link diagonalSlopeX}. Yields sequence of 2D grid coordinates in
- * diagonal order with configurable slope, starting at [0,0]. Each diagonal
- * starts at y=0 and progresses in +y direction and every `step` steps, one
- * step in -x direction.
- *
- * @example
- * ```ts
- * // iterate grid in diagonals of 1:3 ratio (x:y)
- * [...diagonalSlopeY({ cols: 5, step: 3 })]
- * // [
- * //   [0, 0], [0, 1 ], [0, 2 ],
- * //   [1, 0], [1, 1 ], [1, 2 ],
- * //   [0, 3], [0, 4 ], [2, 0 ],
- * //   [2, 1], [2, 2 ], [1, 3 ],
- * //   [1, 4], [3, 0 ], [3, 1 ],
- * //   [3, 2], [2, 3 ], [2, 4 ],
- * //   [4, 0], [4, 1 ], [4, 2 ],
- * //   [3, 3], [3, 4 ], [4, 3 ],
- * //   [4, 4]
- * // ]
- * ```
- *
- * @param opts -
- */
-export function* diagonalSlopeY(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    const maxX = cols - 1;
-    const slope = opts.slope | 0;
-    assert(slope > 0, "slope must be > 0");
-    const num = cols * rows - 1;
-    let x = 0;
-    let y = 0;
-    let nx = Math.min(1, maxX);
-    let ny = nx > 0 ? 0 : slope;
-    let n = slope;
-    const reset = () => {
+function* diagonalSlopeY(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  const maxX = cols - 1;
+  const slope = opts.slope | 0;
+  assert(slope > 0, "slope must be > 0");
+  const num = cols * rows - 1;
+  let x = 0;
+  let y = 0;
+  let nx = Math.min(1, maxX);
+  let ny = nx > 0 ? 0 : slope;
+  let n = slope;
+  const reset = () => {
+    n = slope;
+    x = nx;
+    y = ny;
+    if (nx < maxX)
+      nx++;
+    else
+      ny += slope;
+  };
+  for (let i = 0; i <= num; i++) {
+    yield tx(x, y);
+    if (--n > 0) {
+      y++;
+      if (y >= rows)
+        reset();
+    } else {
+      x--;
+      y++;
+      if (x < 0 || y >= rows)
+        reset();
+      else
         n = slope;
-        x = nx;
-        y = ny;
-        if (nx < maxX)
-            nx++;
-        else
-            ny += slope;
-    };
-    for (let i = 0; i <= num; i++) {
-        yield tx(x, y);
-        if (--n > 0) {
-            y++;
-            if (y >= rows)
-                reset();
-        }
-        else {
-            x--;
-            y++;
-            if (x < 0 || y >= rows)
-                reset();
-            else
-                n = slope;
-        }
     }
+  }
 }
-/**
- * Similar to {@link diagonalSlopeY}. Yields sequence of 2D grid coordinates in
- * diagonal order with configurable slope, starting at [step-1,0]. Each
- * diagonal starts at y=0 and progresses in -x direction and every `step`
- * steps, one step in +y direction.
- *
- * @param opts -
- */
-export function* diagonalSlopeX(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    const maxX = cols - 1;
-    const slope = opts.slope | 0;
-    assert(slope > 0, "slope must be > 0");
-    const num = cols * rows - 1;
-    let x = Math.min(slope - 1, maxX);
-    let y = 0;
-    let n = x + 1;
-    let nx = Math.min(x + slope, maxX);
-    let ny = nx > 0 ? 0 : slope;
-    const reset = () => {
-        x = nx;
-        y = ny;
-        if (nx < maxX) {
-            nx = Math.min(nx + slope, maxX);
-            n = slope;
-        }
-        else {
-            ny++;
-            n = (x % slope) + 1;
-        }
-    };
-    for (let i = 0; i <= num; i++) {
-        yield tx(x, y);
-        if (--n > 0) {
-            x--;
-            if (x < 0)
-                reset();
-        }
-        else {
-            x--;
-            y++;
-            if (x < 0 || y >= rows)
-                reset();
-            else
-                n = slope;
-        }
+function* diagonalSlopeX(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  const maxX = cols - 1;
+  const slope = opts.slope | 0;
+  assert(slope > 0, "slope must be > 0");
+  const num = cols * rows - 1;
+  let x = Math.min(slope - 1, maxX);
+  let y = 0;
+  let n = x + 1;
+  let nx = Math.min(x + slope, maxX);
+  let ny = nx > 0 ? 0 : slope;
+  const reset = () => {
+    x = nx;
+    y = ny;
+    if (nx < maxX) {
+      nx = Math.min(nx + slope, maxX);
+      n = slope;
+    } else {
+      ny++;
+      n = x % slope + 1;
     }
+  };
+  for (let i = 0; i <= num; i++) {
+    yield tx(x, y);
+    if (--n > 0) {
+      x--;
+      if (x < 0)
+        reset();
+    } else {
+      x--;
+      y++;
+      if (x < 0 || y >= rows)
+        reset();
+      else
+        n = slope;
+    }
+  }
 }
+export {
+  diagonalSlopeX,
+  diagonalSlopeY
+};

package/diagonal.js

@@ -1,32 +1,24 @@
 import { __opts } from "./utils.js";
-/**
- * Yields sequence of 2D grid coordinates in diagonal order starting at [0,0]
- * and using given `cols` and `rows`. Each diagonal starts at y=0 and progresses
- * in -x,+y direction.
- *
- * Ported & modified from original Java code by Christopher Kulla.
- * https://sourceforge.net/p/sunflow/code/HEAD/tree/trunk/src/org/sunflow/core/bucket/DiagonalBucketOrder.java
- *
- * @param opts -
- */
-export function* diagonal2d(opts) {
-    const { cols, rows, tx } = __opts(opts);
-    const num = cols * rows - 1;
-    for (let x = 0, y = 0, nx = 1, ny = 0, i = 0; i <= num; i++) {
-        yield tx(x, y);
-        if (i !== num) {
-            do {
-                if (y === ny) {
-                    y = 0;
-                    x = nx;
-                    ny++;
-                    nx++;
-                }
-                else {
-                    x--;
-                    y++;
-                }
-            } while (y >= rows || x >= cols);
+function* diagonal2d(opts) {
+  const { cols, rows, tx } = __opts(opts);
+  const num = cols * rows - 1;
+  for (let x = 0, y = 0, nx = 1, ny = 0, i = 0; i <= num; i++) {
+    yield tx(x, y);
+    if (i !== num) {
+      do {
+        if (y === ny) {
+          y = 0;
+          x = nx;
+          ny++;
+          nx++;
+        } else {
+          x--;
+          y++;
         }
+      } while (y >= rows || x >= cols);
     }
+  }
 }
+export {
+  diagonal2d
+};