@thi.ng/geom-clip-line 2.3.49 → 2.3.51

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

@@ -65,7 +65,7 @@ For Node.js REPL:
 const geomClipLine = await import("@thi.ng/geom-clip-line");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 755 bytes
+Package sizes (brotli'd, pre-treeshake): ESM: 761 bytes
 
 ## Dependencies
 

package/clip-poly.js

@@ -2,91 +2,70 @@ import { intersectLinePolylineAll } from "@thi.ng/geom-isec/line-poly";
 import { pointInPolygon2 } from "@thi.ng/geom-isec/point";
 import { intersectRayPolylineAll } from "@thi.ng/geom-isec/ray-poly";
 import { direction2 } from "@thi.ng/vectors/direction";
-/**
- * Computes all intersection points of the **infinite** line defined by `a`, `b`
- * with the given polygon. Returns an array of segments where the line is inside
- * the polygon.
- *
- * @remarks
- * "Infinite" here means the line extends indefinitely on either side and
- * intersections are found also outside the segment a..b. If only intra-segment
- * intersections are desired, use {@link clipLineSegmentPoly} instead.
- *
- * @param a
- * @param b
- * @param poly
- */
-export const clipLinePoly = (a, b, poly) => {
-    const isecs = intersectRayPolylineAll(a, direction2([], a, b), poly, true).isec;
-    return isecs ? collectSegments(isecs) : undefined;
+const clipLinePoly = (a, b, poly) => {
+  const isecs = intersectRayPolylineAll(
+    a,
+    direction2([], a, b),
+    poly,
+    true
+  ).isec;
+  return isecs ? collectSegments(isecs) : void 0;
 };
-/**
- * Similar to {@link clipLinePoly}, but only considers intersections within the
- * given line segment.
- *
- * @param a
- * @param b
- * @param poly
- */
-export const clipLineSegmentPoly = (a, b, poly) => {
-    const isecs = intersectLinePolylineAll(a, b, poly, true).isec;
-    const isAInside = pointInPolygon2(a, poly);
+const clipLineSegmentPoly = (a, b, poly) => {
+  const isecs = intersectLinePolylineAll(a, b, poly, true).isec;
+  const isAInside = pointInPolygon2(a, poly);
+  const isBInside = pointInPolygon2(b, poly);
+  if (!isecs) {
+    return isAInside && isBInside ? [[a, b]] : void 0;
+  }
+  isAInside && isecs.unshift(a);
+  isBInside && isecs.push(b);
+  return collectSegments(isecs);
+};
+const clipPolylinePoly = (pts, poly) => {
+  let res = [];
+  if (pts.length < 2)
+    return res;
+  let isAInside = pointInPolygon2(pts[0], poly);
+  for (let i = 0, n = pts.length - 1; i < n; i++) {
+    const a = pts[i];
+    const b = pts[i + 1];
     const isBInside = pointInPolygon2(b, poly);
+    const isecs = intersectLinePolylineAll(a, b, poly, true).isec;
     if (!isecs) {
-        return isAInside && isBInside ? [[a, b]] : undefined;
+      if (isAInside && isBInside) {
+        if (res.length)
+          res[res.length - 1].push(b);
+        else
+          res.push([a, b]);
+      }
+    } else {
+      isAInside && isecs.unshift(a);
+      isBInside && isecs.push(b);
+      const [first, ...segments] = collectSegments(isecs);
+      if (isAInside) {
+        if (res.length)
+          res[res.length - 1].push(first[1]);
+        else
+          res.push(first);
+      } else {
+        res.push(first);
+      }
+      res.push(...segments);
     }
-    isAInside && isecs.unshift(a);
-    isBInside && isecs.push(b);
-    return collectSegments(isecs);
-};
-/**
- * Similar to {@link clipLineSegmentPoly}, but for polylines. Returns array of
- * new vertex chunks where the given polyline is inside the given bounding poly.
- *
- * @param pts
- * @param poly
- */
-export const clipPolylinePoly = (pts, poly) => {
-    let res = [];
-    if (pts.length < 2)
-        return res;
-    let isAInside = pointInPolygon2(pts[0], poly);
-    for (let i = 0, n = pts.length - 1; i < n; i++) {
-        const a = pts[i];
-        const b = pts[i + 1];
-        const isBInside = pointInPolygon2(b, poly);
-        const isecs = intersectLinePolylineAll(a, b, poly, true).isec;
-        if (!isecs) {
-            if (isAInside && isBInside) {
-                if (res.length)
-                    res[res.length - 1].push(b);
-                else
-                    res.push([a, b]);
-            }
-        }
-        else {
-            isAInside && isecs.unshift(a);
-            isBInside && isecs.push(b);
-            const [first, ...segments] = collectSegments(isecs);
-            if (isAInside) {
-                if (res.length)
-                    res[res.length - 1].push(first[1]);
-                else
-                    res.push(first);
-            }
-            else {
-                res.push(first);
-            }
-            res.push(...segments);
-        }
-        isAInside = isBInside;
-    }
-    return res;
+    isAInside = isBInside;
+  }
+  return res;
 };
 const collectSegments = (isecs) => {
-    const segments = [];
-    for (let i = 0, n = isecs.length - 1; i < n; i += 2) {
-        segments.push([isecs[i], isecs[i + 1]]);
-    }
-    return segments;
+  const segments = [];
+  for (let i = 0, n = isecs.length - 1; i < n; i += 2) {
+    segments.push([isecs[i], isecs[i + 1]]);
+  }
+  return segments;
+};
+export {
+  clipLinePoly,
+  clipLineSegmentPoly,
+  clipPolylinePoly
 };

package/clip-with.js

@@ -1,68 +1,31 @@
-/**
- * Segments given polyline based on given predicate and `step` size. Returns
- * array of segmented vertex chunks.
- *
- * @remarks
- * Vertices are processed pairwise using given `step` size (default: 1). As long
- * as the predicate is true, vertices are collected into the current chunk. If
- * the predicate returns false, the current chunk is terminated and depending on
- * `keepLast`, the current vertex (i.e. for which the predicate failed) is still
- * added or not. If `keepLast` is false and the current chunk only included one
- * other vertex, that entire chunk will be discarded.
- *
- * @example
- * ```ts
- * const pts = [[0, 0], [1, 0], [1, 1], [2, 1], [3, 1], [4, 0], [5, 0]];
- *
- * // isolate horizontal chunks
- * clipPolylineWith((a, b) => a[1] == b[1], pts)
- * // [
- * //   [[0, 0], [1, 0]],
- * //   [[1, 1], [2, 1], [3, 1]],
- * //   [[4, 0], [5, 0]]
- * // ]
- *
- * // isolate sloped chunks
- * clipPolylineWith((a, b) => a[1] != b[1], pts)
- * // [
- * //   [[1, 0], [1, 1]],
- * //   [[3, 1], [4, 0]]
- * // ]
- * ```
- *
- * @param pred
- * @param pts
- * @param step
- * @param keepLast
- */
-export const clipPolylineWith = (pred, pts, step = 1, keepLast = true) => {
-    const segs = [];
-    let last = -1;
-    const $terminate = (i) => {
-        if (last !== -1) {
-            if (keepLast) {
-                segs[segs.length - 1].push(pts[i]);
-            }
-            else if (segs[segs.length - 1].length < 2) {
-                segs.pop();
-            }
-        }
-        last = -1;
-    };
-    for (let i = 0, n = pts.length - step; i < n; i++) {
-        if (pred(pts[i], pts[i + step])) {
-            if (last === -1) {
-                segs.push([pts[i]]);
-                last = i;
-            }
-            else {
-                segs[segs.length - 1].push(pts[i]);
-            }
-        }
-        else {
-            $terminate(i);
-        }
+const clipPolylineWith = (pred, pts, step = 1, keepLast = true) => {
+  const segs = [];
+  let last = -1;
+  const $terminate = (i) => {
+    if (last !== -1) {
+      if (keepLast) {
+        segs[segs.length - 1].push(pts[i]);
+      } else if (segs[segs.length - 1].length < 2) {
+        segs.pop();
+      }
     }
-    $terminate(pts.length - step);
-    return segs;
+    last = -1;
+  };
+  for (let i = 0, n = pts.length - step; i < n; i++) {
+    if (pred(pts[i], pts[i + step])) {
+      if (last === -1) {
+        segs.push([pts[i]]);
+        last = i;
+      } else {
+        segs[segs.length - 1].push(pts[i]);
+      }
+    } else {
+      $terminate(i);
+    }
+  }
+  $terminate(pts.length - step);
+  return segs;
+};
+export {
+  clipPolylineWith
 };

package/liang-barsky.js

@@ -1,84 +1,59 @@
-/**
- * Performs Liang-Barsky clipping of the line segment with endpoints `a`, `b`
- * against the clipping rect defined by `min` and `max`. The optional `ca` and
- * `cb` vectors can be given to store the result (clipped points). If omitted
- * creates new vectors. Returns a tuple of `[ca, cb, a, b]`, where the latter
- * two values represent the normalized distances of the clipped points relative
- * to original given line segment. Returns `undefined` iff the line lies
- * completely outside the rect.
- *
- * - https://en.wikipedia.org/wiki/Liang%E2%80%93Barsky_algorithm
- * - https://github.com/thi-ng/c-thing/blob/develop/src/geom/clip/liangbarsky.c
- *
- * @param a - line endpoint
- * @param b - line endpoint
- * @param min - bbox min
- * @param max - bbox max
- * @param ca - result A
- * @param cb - result B
- */
-export const liangBarsky2 = (a, b, min, max, ca = [], cb = []) => {
-    const res = liangBarsky2Raw(a[0], a[1], b[0], b[1], min[0], min[1], max[0], max[1]);
-    if (!res)
-        return;
-    ca[0] = res[0];
-    ca[1] = res[1];
-    cb[0] = res[2];
-    cb[1] = res[3];
-    return [ca, cb, res[4], res[5]];
+const liangBarsky2 = (a, b, min, max, ca = [], cb = []) => {
+  const res = liangBarsky2Raw(
+    a[0],
+    a[1],
+    b[0],
+    b[1],
+    min[0],
+    min[1],
+    max[0],
+    max[1]
+  );
+  if (!res)
+    return;
+  ca[0] = res[0];
+  ca[1] = res[1];
+  cb[0] = res[2];
+  cb[1] = res[3];
+  return [ca, cb, res[4], res[5]];
 };
-/**
- * Same as {@link liangBarsky2} but for non-vector arguments.
- *
- * @param ax -
- * @param ay -
- * @param bx -
- * @param by -
- * @param minx -
- * @param miny -
- * @param maxx -
- * @param maxy -
- */
-export const liangBarsky2Raw = (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;
-            }
-            if (r > alpha) {
-                alpha = r;
-            }
-        }
-        else if (p > 0) {
-            const r = q / p;
-            if (r < alpha) {
-                return false;
-            }
-            if (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,
-            alpha,
-            beta,
-        ]
-        : undefined;
+const liangBarsky2Raw = (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;
+      }
+      if (r > alpha) {
+        alpha = r;
+      }
+    } else if (p > 0) {
+      const r = q / p;
+      if (r < alpha) {
+        return false;
+      }
+      if (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,
+    alpha,
+    beta
+  ] : void 0;
+};
+export {
+  liangBarsky2,
+  liangBarsky2Raw
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-clip-line",
-  "version": "2.3.49",
+  "version": "2.3.51",
   "description": "2D line clipping (Liang-Barsky)",
   "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,12 +35,13 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.11",
-    "@thi.ng/geom-isec": "^2.1.91",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/geom-isec": "^2.1.93",
+    "@thi.ng/vectors": "^7.8.10"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -85,5 +88,5 @@
     ],
     "year": 2013
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "22e36fa838e5431d40165384918b395603bbd92f\n"
 }