@thi.ng/rasterize 1.0.62 → 1.0.64

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **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/api.js

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

package/checks.js

@@ -1,3 +1,7 @@
 import { isFunction } from "@thi.ng/checks/is-function";
-export const isInBounds2D = ({ size }, x, y) => x >= 0 && x < size[0] && y >= 0 && y < size[1];
-export const ensureShader2D = (val) => isFunction(val) ? val : () => val;
+const isInBounds2D = ({ size }, x, y) => x >= 0 && x < size[0] && y >= 0 && y < size[1];
+const ensureShader2D = (val) => isFunction(val) ? val : () => val;
+export {
+  ensureShader2D,
+  isInBounds2D
+};

package/circle.js

@@ -1,3 +1,10 @@
 import { circleClipped } from "@thi.ng/grid-iterators/circle";
 import { __draw2D } from "./draw.js";
-export const drawCircle = (grid, x, y, r, val, fill = false) => __draw2D(circleClipped(x, y, r, 0, 0, grid.size[0], grid.size[1], fill), grid, val);
+const drawCircle = (grid, x, y, r, val, fill = false) => __draw2D(
+  circleClipped(x, y, r, 0, 0, grid.size[0], grid.size[1], fill),
+  grid,
+  val
+);
+export {
+  drawCircle
+};

package/draw.js

@@ -1,40 +1,46 @@
 import { isFunction } from "@thi.ng/checks/is-function";
 import { isPrimitive } from "@thi.ng/checks/is-primitive";
-/** @internal */
-export const __draw2D = (pts, grid, val) => isFunction(val)
-    ? __drawShader2D(pts, grid, val)
-    : __drawSolid2D(pts, grid, val);
-/** @internal */
-export const __drawSolid2D = (pts, grid, val) => {
-    if (!pts)
-        return grid;
-    if (isPrimitive(val)) {
-        const { data, offset, stride: [sx, sy], } = grid;
-        for (let p of pts) {
-            data[offset + p[0] * sx + p[1] * sy] = val;
-        }
+const __draw2D = (pts, grid, val) => isFunction(val) ? __drawShader2D(pts, grid, val) : __drawSolid2D(pts, grid, val);
+const __drawSolid2D = (pts, grid, val) => {
+  if (!pts)
+    return grid;
+  if (isPrimitive(val)) {
+    const {
+      data,
+      offset,
+      stride: [sx, sy]
+    } = grid;
+    for (let p of pts) {
+      data[offset + p[0] * sx + p[1] * sy] = val;
     }
-    else {
-        for (let p of pts) {
-            grid.setAtUnsafe(p[0], p[1], val);
-        }
+  } else {
+    for (let p of pts) {
+      grid.setAtUnsafe(p[0], p[1], val);
     }
-    return grid;
+  }
+  return grid;
 };
-/** @internal */
-export const __drawShader2D = (pts, grid, shader) => {
-    if (!pts)
-        return grid;
-    if (isPrimitive(grid.getAtUnsafe(0, 0))) {
-        const { data, offset, stride: [sx, sy], } = grid;
-        for (let { 0: x, 1: y } of pts) {
-            data[offset + x * sx + y * sy] = shader(grid, x, y);
-        }
+const __drawShader2D = (pts, grid, shader) => {
+  if (!pts)
+    return grid;
+  if (isPrimitive(grid.getAtUnsafe(0, 0))) {
+    const {
+      data,
+      offset,
+      stride: [sx, sy]
+    } = grid;
+    for (let { 0: x, 1: y } of pts) {
+      data[offset + x * sx + y * sy] = shader(grid, x, y);
     }
-    else {
-        for (let { 0: x, 1: y } of pts) {
-            grid.setAtUnsafe(x, y, shader(grid, x, y));
-        }
+  } else {
+    for (let { 0: x, 1: y } of pts) {
+      grid.setAtUnsafe(x, y, shader(grid, x, y));
     }
-    return grid;
+  }
+  return grid;
+};
+export {
+  __draw2D,
+  __drawShader2D,
+  __drawSolid2D
 };

package/flood-fill.js

@@ -4,27 +4,26 @@ import { equiv } from "@thi.ng/equiv";
 import { floodFill as $fill } from "@thi.ng/grid-iterators/flood-fill";
 import { isInBounds2D } from "./checks.js";
 import { __draw2D } from "./draw.js";
-/**
- * Fills cells in the connected region around `x,y` with given value or shader
- * function. If the latter, the shader is called for each grid coordinate and
- * returns a fill value. Returns updated grid.
- *
- * @param grid -
- * @param x -
- * @param y -
- * @param val -
- */
-export const floodFill = (grid, x, y, val) => isInBounds2D(grid, x, y)
-    ? __draw2D($fill(__pred(grid, x, y), x, y, grid.size[0], grid.size[1]), grid, val)
-    : grid;
+const floodFill = (grid, x, y, val) => isInBounds2D(grid, x, y) ? __draw2D(
+  $fill(__pred(grid, x, y), x, y, grid.size[0], grid.size[1]),
+  grid,
+  val
+) : grid;
 const __pred = (img, x, y) => {
-    const { data, offset, stride: [stride, rowStride], } = img;
-    let srcVal = img.getAtUnsafe(x, y);
-    if (isPrimitive(srcVal)) {
-        return (x, y) => data[offset + x * stride + y * rowStride] === srcVal;
-    }
-    if (isIterable(srcVal)) {
-        srcVal = [...srcVal];
-    }
-    return (x, y) => equiv(img.getAtUnsafe(x, y), srcVal);
+  const {
+    data,
+    offset,
+    stride: [stride, rowStride]
+  } = img;
+  let srcVal = img.getAtUnsafe(x, y);
+  if (isPrimitive(srcVal)) {
+    return (x2, y2) => data[offset + x2 * stride + y2 * rowStride] === srcVal;
+  }
+  if (isIterable(srcVal)) {
+    srcVal = [...srcVal];
+  }
+  return (x2, y2) => equiv(img.getAtUnsafe(x2, y2), srcVal);
+};
+export {
+  floodFill
 };

package/line.js

@@ -1,11 +1,19 @@
 import { lineClipped } from "@thi.ng/grid-iterators/line";
 import { __draw2D } from "./draw.js";
-export const drawLine = (grid, x1, y1, x2, y2, val) => __draw2D(lineClipped(x1, y1, x2, y2, 0, 0, grid.size[0], grid.size[1]), grid, val);
-export const traceLine = (grid, x1, y1, x2, y2, fn) => {
-    const pts = lineClipped(x1, y1, x2, y2, 0, 0, grid.size[0], grid.size[1]);
-    if (pts) {
-        for (let p of pts)
-            fn(p);
-    }
-    return grid;
+const drawLine = (grid, x1, y1, x2, y2, val) => __draw2D(
+  lineClipped(x1, y1, x2, y2, 0, 0, grid.size[0], grid.size[1]),
+  grid,
+  val
+);
+const traceLine = (grid, x1, y1, x2, y2, fn) => {
+  const pts = lineClipped(x1, y1, x2, y2, 0, 0, grid.size[0], grid.size[1]);
+  if (pts) {
+    for (let p of pts)
+      fn(p);
+  }
+  return grid;
+};
+export {
+  drawLine,
+  traceLine
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/rasterize",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "2D shape drawing & rasterization",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "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",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,17 +35,17 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/equiv": "^2.1.35",
-    "@thi.ng/grid-iterators": "^4.0.34",
-    "@thi.ng/porter-duff": "^2.1.50",
-    "@thi.ng/random": "^3.6.16",
-    "@thi.ng/transducers": "^8.8.13"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/equiv": "^2.1.37",
+    "@thi.ng/grid-iterators": "^4.0.36",
+    "@thi.ng/porter-duff": "^2.1.52",
+    "@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",
@@ -118,5 +120,5 @@
     "status": "alpha",
     "year": 2021
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/poly.js

@@ -1,67 +1,56 @@
 import { ensureShader2D } from "./checks.js";
-/**
- * Draws a filled polygon (simple, no holes) into given grid. Each grid cell's
- * value is obtained from user supplied shader function which will be called
- * with the pixel's `x,y` coords.
- *
- * Based on Efficient Polygon Fill Algorithm by Darel Rex Finley
- * http://alienryderflex.com/polygon_fill/
- *
- * Bounds calculation and clipping added by Karsten Schmidt
- *
- * @param grid -
- * @param pts -
- * @param val -
- */
-export const fillPoly = (grid, pts, val) => {
-    const numP = pts.length;
-    const [width, height] = grid.size;
-    const shader = ensureShader2D(val);
-    let minX = Infinity;
-    let minY = Infinity;
-    let maxX = -Infinity;
-    let maxY = -Infinity;
-    for (let i = numP; i-- > 0;) {
-        const { 0: x, 1: y } = pts[i];
-        minX = Math.min(minX, x);
-        maxX = Math.max(maxX, x);
-        minY = Math.min(minY, y);
-        maxY = Math.max(maxY, y);
+const fillPoly = (grid, pts, val) => {
+  const numP = pts.length;
+  const [width, height] = grid.size;
+  const shader = ensureShader2D(val);
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (let i2 = numP; i2-- > 0; ) {
+    const { 0: x, 1: y } = pts[i2];
+    minX = Math.min(minX, x);
+    maxX = Math.max(maxX, x);
+    minY = Math.min(minY, y);
+    maxY = Math.max(maxY, y);
+  }
+  minX = Math.max(minX | 0, 0);
+  maxX = Math.min(maxX | 0, width - 1);
+  minY = Math.max(minY | 0, 0);
+  maxY = Math.min(maxY | 0, height - 1);
+  if (minX >= width || maxX < 0 || minY >= height || maxY < 0)
+    return;
+  let i = 0;
+  let k = 0;
+  let j;
+  const isec = [];
+  for (let y = Math.max(0, minY); y <= maxY; y++) {
+    i = k = 0;
+    j = numP - 1;
+    isec.length = 0;
+    for (; i < numP; j = i, i++) {
+      const { 0: pix, 1: piy } = pts[i];
+      const { 0: pjx, 1: pjy } = pts[j];
+      if (piy < y && pjy >= y || pjy < y && piy >= y) {
+        isec[k++] = pix + (y - piy) / (pjy - piy) * (pjx - pix) | 0;
+      }
     }
-    minX = Math.max(minX | 0, 0);
-    maxX = Math.min(maxX | 0, width - 1);
-    minY = Math.max(minY | 0, 0);
-    maxY = Math.min(maxY | 0, height - 1);
-    if (minX >= width || maxX < 0 || minY >= height || maxY < 0)
-        return;
-    let i = 0;
-    let k = 0;
-    let j;
-    const isec = [];
-    for (let y = Math.max(0, minY); y <= maxY; y++) {
-        i = k = 0;
-        j = numP - 1;
-        isec.length = 0;
-        for (; i < numP; j = i, i++) {
-            const { 0: pix, 1: piy } = pts[i];
-            const { 0: pjx, 1: pjy } = pts[j];
-            if ((piy < y && pjy >= y) || (pjy < y && piy >= y)) {
-                isec[k++] = (pix + ((y - piy) / (pjy - piy)) * (pjx - pix)) | 0;
-            }
-        }
-        isec.sort((a, b) => a - b);
-        for (i = 0; i < k; i += 2) {
-            let x1 = isec[i];
-            if (x1 > maxX)
-                break;
-            let x2 = isec[i + 1];
-            if (x2 > minX) {
-                x1 < minX && (x1 = minX);
-                x2 > maxX && (x2 = maxX);
-                for (let x = x1; x <= x2; x++) {
-                    grid.setAtUnsafe(x, y, shader(grid, x, y));
-                }
-            }
+    isec.sort((a, b) => a - b);
+    for (i = 0; i < k; i += 2) {
+      let x1 = isec[i];
+      if (x1 > maxX)
+        break;
+      let x2 = isec[i + 1];
+      if (x2 > minX) {
+        x1 < minX && (x1 = minX);
+        x2 > maxX && (x2 = maxX);
+        for (let x = x1; x <= x2; x++) {
+          grid.setAtUnsafe(x, y, shader(grid, x, y));
         }
+      }
     }
+  }
+};
+export {
+  fillPoly
 };

package/polyline.js

@@ -1,12 +1,15 @@
 import { ensureShader2D } from "./checks.js";
 import { drawLine } from "./line.js";
-export const drawPolyLine = (grid, pts, val, closed = false) => {
-    val = ensureShader2D(val);
-    const n = pts.length;
-    let [i, j] = closed ? [0, n - 1] : [1, 0];
-    for (; i < n; j = i, i++) {
-        const a = pts[j];
-        const b = pts[i];
-        drawLine(grid, a[0], a[1], b[0], b[1], val);
-    }
+const drawPolyLine = (grid, pts, val, closed = false) => {
+  val = ensureShader2D(val);
+  const n = pts.length;
+  let [i, j] = closed ? [0, n - 1] : [1, 0];
+  for (; i < n; j = i, i++) {
+    const a = pts[j];
+    const b = pts[i];
+    drawLine(grid, a[0], a[1], b[0], b[1], val);
+  }
+};
+export {
+  drawPolyLine
 };

package/rect.js

@@ -4,41 +4,57 @@ import { rows2d } from "@thi.ng/grid-iterators/rows";
 import { concat } from "@thi.ng/transducers/concat";
 import { ensureShader2D } from "./checks.js";
 import { __draw2D } from "./draw.js";
-export const drawRect = (grid, x, y, w, h, val, fill = false) => {
-    x |= 0;
-    y |= 0;
-    w |= 0;
-    h |= 0;
-    const { data, offset, size: [width, height], stride: [sx, sy], } = grid;
-    if (fill) {
-        if (x < 0) {
-            w += x;
-            x = 0;
-        }
-        if (y < 0) {
-            h += y;
-            y = 0;
-        }
-        const pts = rows2d({
-            cols: Math.min(w, width - x),
-            rows: Math.min(h, height - y),
-        });
-        const shader = ensureShader2D(val);
-        if (isPrimitive(val)) {
-            for (let { 0: xx, 1: yy } of pts) {
-                xx += x;
-                yy += y;
-                data[offset + xx * sx + yy * sy] = shader(grid, xx, yy);
-            }
-        }
-        else {
-            for (let { 0: xx, 1: yy } of pts) {
-                xx += x;
-                yy += y;
-                grid.setAtUnsafe(xx, yy, shader(grid, xx, yy));
-            }
-        }
-        return grid;
+const drawRect = (grid, x, y, w, h, val, fill = false) => {
+  x |= 0;
+  y |= 0;
+  w |= 0;
+  h |= 0;
+  const {
+    data,
+    offset,
+    size: [width, height],
+    stride: [sx, sy]
+  } = grid;
+  if (fill) {
+    if (x < 0) {
+      w += x;
+      x = 0;
     }
-    return __draw2D(concat(hlineClipped(x, y, w, 0, 0, width, height), vlineClipped(x, y + 1, h - 2, 0, 0, width, height), hlineClipped(x, y + h - 1, w, 0, 0, width, height), vlineClipped(x + w - 1, y + 1, h - 2, 0, 0, width, height)), grid, val);
+    if (y < 0) {
+      h += y;
+      y = 0;
+    }
+    const pts = rows2d({
+      cols: Math.min(w, width - x),
+      rows: Math.min(h, height - y)
+    });
+    const shader = ensureShader2D(val);
+    if (isPrimitive(val)) {
+      for (let { 0: xx, 1: yy } of pts) {
+        xx += x;
+        yy += y;
+        data[offset + xx * sx + yy * sy] = shader(grid, xx, yy);
+      }
+    } else {
+      for (let { 0: xx, 1: yy } of pts) {
+        xx += x;
+        yy += y;
+        grid.setAtUnsafe(xx, yy, shader(grid, xx, yy));
+      }
+    }
+    return grid;
+  }
+  return __draw2D(
+    concat(
+      hlineClipped(x, y, w, 0, 0, width, height),
+      vlineClipped(x, y + 1, h - 2, 0, 0, width, height),
+      hlineClipped(x, y + h - 1, w, 0, 0, width, height),
+      vlineClipped(x + w - 1, y + 1, h - 2, 0, 0, width, height)
+    ),
+    grid,
+    val
+  );
+};
+export {
+  drawRect
 };

package/shader.js

@@ -1,68 +1,48 @@
 import { isFunction } from "@thi.ng/checks/is-function";
-import { porterDuffP, porterDuffPInt, SRC_OVER_F, SRC_OVER_I, } from "@thi.ng/porter-duff/porter-duff";
+import {
+  porterDuffP,
+  porterDuffPInt,
+  SRC_OVER_F,
+  SRC_OVER_I
+} from "@thi.ng/porter-duff/porter-duff";
 import { SYSTEM } from "@thi.ng/random/system";
-export const defPattern = (pattern) => {
-    const [w, h] = pattern.size;
-    return (_, x, y) => pattern.getAtUnsafe(x % w, y % h);
+const defPattern = (pattern) => {
+  const [w, h] = pattern.size;
+  return (_, x, y) => pattern.getAtUnsafe(x % w, y % h);
 };
-export const defStripes = ({ dir, size, sizeA, a, b, }) => dir === "h"
-    ? (_, x) => (x % size < sizeA ? a : b)
-    : dir === "v"
-        ? (_, __, y) => (y % size < sizeA ? a : b)
-        : (_, x, y) => ((x + y) % size < sizeA ? a : b);
-export const defNoise = (opts) => {
-    const { probability, rnd, a, b } = {
-        probability: 0.5,
-        rnd: SYSTEM,
-        ...opts,
-    };
-    return () => (rnd.probability(probability) ? a : b);
+const defStripes = ({
+  dir,
+  size,
+  sizeA,
+  a,
+  b
+}) => dir === "h" ? (_, x) => x % size < sizeA ? a : b : dir === "v" ? (_, __, y) => y % size < sizeA ? a : b : (_, x, y) => (x + y) % size < sizeA ? a : b;
+const defNoise = (opts) => {
+  const { probability, rnd, a, b } = {
+    probability: 0.5,
+    rnd: SYSTEM,
+    ...opts
+  };
+  return () => rnd.probability(probability) ? a : b;
 };
-/**
- * Defines a shader (for floating point target buffers) which blends given color
- * (or another shader) with a Porter-Duff operator. Unless `isPremultiplied` is
- * true, both the given color and existing pixel values in the target buffer are
- * considered non-premultiplied.
- *
- * @remarks
- * The default PD blend op is `SRC_OVER_I`. See
- * [@thi.ng/porter-duff](https://thi.ng/porter-duff) for more info.
- *
- * See {@link defBlendI} for integer based buffers.
- *
- * @param col
- * @param blend
- * @param isPremultiplied
- */
-export const defBlendF = (col, blend = SRC_OVER_F, isPremultiplied = false) => {
-    blend = isPremultiplied ? blend : porterDuffP(blend);
-    return isFunction(col)
-        ? (buf, x, y) => {
-            const dest = buf.getAtUnsafe(x, y);
-            return blend(dest, col(buf, x, y), dest);
-        }
-        : (buf, x, y) => {
-            const dest = buf.getAtUnsafe(x, y);
-            return blend(dest, col, dest);
-        };
+const defBlendF = (col, blend = SRC_OVER_F, isPremultiplied = false) => {
+  blend = isPremultiplied ? blend : porterDuffP(blend);
+  return isFunction(col) ? (buf, x, y) => {
+    const dest = buf.getAtUnsafe(x, y);
+    return blend(dest, col(buf, x, y), dest);
+  } : (buf, x, y) => {
+    const dest = buf.getAtUnsafe(x, y);
+    return blend(dest, col, dest);
+  };
 };
-/**
- * Similar to {@link defBlendF}, but for integer based target buffers. Defines a
- * shader which blends given color (or another shader) with a Porter-Duff
- * operator. Unless `isPremultiplied` is true, both the given color and existing
- * pixel values in the target buffer are considered non-premultiplied.
- *
- * @remarks
- * The default PD blend op is `SRC_OVER_I`. See
- * [@thi.ng/porter-duff](https://thi.ng/porter-duff) for more info.
- *
- * @param col
- * @param blend
- * @param isPremultiplied
- */
-export const defBlendI = (col, blend = SRC_OVER_I, isPremultiplied = false) => {
-    blend = isPremultiplied ? blend : porterDuffPInt(blend);
-    return isFunction(col)
-        ? (buf, x, y) => blend(col(buf, x, y), buf.getAtUnsafe(x, y))
-        : (buf, x, y) => blend(col, buf.getAtUnsafe(x, y));
+const defBlendI = (col, blend = SRC_OVER_I, isPremultiplied = false) => {
+  blend = isPremultiplied ? blend : porterDuffPInt(blend);
+  return isFunction(col) ? (buf, x, y) => blend(col(buf, x, y), buf.getAtUnsafe(x, y)) : (buf, x, y) => blend(col, buf.getAtUnsafe(x, y));
+};
+export {
+  defBlendF,
+  defBlendI,
+  defNoise,
+  defPattern,
+  defStripes
 };