@thi.ng/geom-closest-point 2.1.87 → 2.1.89

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

@@ -59,7 +59,7 @@ For Node.js REPL:
 const geomClosestPoint = await import("@thi.ng/geom-closest-point");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 1.05 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 1.06 KB
 
 ## Dependencies
 

package/box.js

@@ -1,32 +1,45 @@
 import { clamp } from "@thi.ng/math/interval";
 import { setC2, setC3 } from "@thi.ng/vectors/setc";
-export const closestPointRect = (p, bmin, bmax, out = []) => {
-    const [minID, minW] = closestBoxEdge(p, bmin, bmax, 4);
-    return minID === 0
-        ? setC2(out, minW, clamp(p[1], bmin[1], bmax[1]))
-        : setC2(out, clamp(p[0], bmin[0], bmax[0]), minW);
+const closestPointRect = (p, bmin, bmax, out = []) => {
+  const [minID, minW] = closestBoxEdge(p, bmin, bmax, 4);
+  return minID === 0 ? setC2(out, minW, clamp(p[1], bmin[1], bmax[1])) : setC2(out, clamp(p[0], bmin[0], bmax[0]), minW);
 };
-export const closestPointAABB = (p, bmin, bmax, out = []) => {
-    const [minID, minW] = closestBoxEdge(p, bmin, bmax, 6);
-    return minID === 0
-        ? setC3(out, minW, clamp(p[1], bmin[1], bmax[1]), clamp(p[2], bmin[2], bmax[2]))
-        : minID === 1
-            ? setC3(out, clamp(p[0], bmin[0], bmax[0]), minW, clamp(p[2], bmin[2], bmax[2]))
-            : setC3(out, clamp(p[0], bmin[0], bmax[0]), clamp(p[1], bmin[1], bmax[1]), minW);
+const closestPointAABB = (p, bmin, bmax, out = []) => {
+  const [minID, minW] = closestBoxEdge(p, bmin, bmax, 6);
+  return minID === 0 ? setC3(
+    out,
+    minW,
+    clamp(p[1], bmin[1], bmax[1]),
+    clamp(p[2], bmin[2], bmax[2])
+  ) : minID === 1 ? setC3(
+    out,
+    clamp(p[0], bmin[0], bmax[0]),
+    minW,
+    clamp(p[2], bmin[2], bmax[2])
+  ) : setC3(
+    out,
+    clamp(p[0], bmin[0], bmax[0]),
+    clamp(p[1], bmin[1], bmax[1]),
+    minW
+  );
 };
 const closestBoxEdge = (p, bmin, bmax, n) => {
-    let minD = Infinity;
-    let minID;
-    let minW;
-    for (let i = 0; i < n; i++) {
-        const j = i >> 1;
-        const w = (i & 1 ? bmax : bmin)[j];
-        const d = Math.abs(p[j] - w);
-        if (d < minD) {
-            minD = d;
-            minID = j;
-            minW = w;
-        }
+  let minD = Infinity;
+  let minID;
+  let minW;
+  for (let i = 0; i < n; i++) {
+    const j = i >> 1;
+    const w = (i & 1 ? bmax : bmin)[j];
+    const d = Math.abs(p[j] - w);
+    if (d < minD) {
+      minD = d;
+      minID = j;
+      minW = w;
     }
-    return [minID, minW];
+  }
+  return [minID, minW];
+};
+export {
+  closestPointAABB,
+  closestPointRect
 };

package/circle.js

@@ -1,15 +1,8 @@
 import { add } from "@thi.ng/vectors/add";
 import { direction } from "@thi.ng/vectors/direction";
-/**
- * Returns closest point to `p` on circle defined by origin `c` and radius `r`.
- *
- * @param p -
- * @param c -
- * @param r -
- * @param out -
- */
-export const closestPointCircle = (p, c, r, out = []) => add(out, c, direction(out, c, p, r));
-/**
- * Same as {@link closestPointCircle}.
- */
-export const closestPointSphere = closestPointCircle;
+const closestPointCircle = (p, c, r, out = []) => add(out, c, direction(out, c, p, r));
+const closestPointSphere = closestPointCircle;
+export {
+  closestPointCircle,
+  closestPointSphere
+};

package/ellipse.js

@@ -1,38 +1,26 @@
 import { SQRT2_2 } from "@thi.ng/math/api";
 import { clamp01 } from "@thi.ng/math/interval";
-/**
- * @remarks
- * Based on iterative solution by Luc Maisonobe:
- *
- * - https://www.spaceroots.org/documents/distance/distance-to-ellipse.pdf
- * - https://gist.github.com/JohannesMP/777bdc8e84df6ddfeaa4f0ddb1c7adb3
- *
- * Further optimizations: constant folding, avoiding duplicate calculations in
- * loop
- *
- * @param p - query point
- * @param eo - ellipse center/origin
- * @param er - ellipse radii
- * @param n - number of iterations
- */
-export const closestPointEllipse = ([px, py], [ex, ey], [rx, ry], n = 3) => {
-    const apx = Math.abs(px - ex);
-    const apy = Math.abs(py - ey);
-    const ab = (rx * rx - ry * ry) / rx;
-    const ba = (ry * ry - rx * rx) / ry;
-    let tx = SQRT2_2;
-    let ty = tx;
-    for (; n-- > 0;) {
-        const _ex = ab * tx * tx * tx;
-        const _ey = ba * ty * ty * ty;
-        const qx = apx - _ex;
-        const qy = apy - _ey;
-        const q = Math.hypot(rx * tx - _ex, ry * ty - _ey) / Math.hypot(qx, qy);
-        tx = clamp01((qx * q + _ex) / rx);
-        ty = clamp01((qy * q + _ey) / ry);
-        const t = Math.hypot(tx, ty);
-        tx /= t;
-        ty /= t;
-    }
-    return [rx * (px < ex ? -tx : tx) + ex, ry * (py < ey ? -ty : ty) + ey];
+const closestPointEllipse = ([px, py], [ex, ey], [rx, ry], n = 3) => {
+  const apx = Math.abs(px - ex);
+  const apy = Math.abs(py - ey);
+  const ab = (rx * rx - ry * ry) / rx;
+  const ba = (ry * ry - rx * rx) / ry;
+  let tx = SQRT2_2;
+  let ty = tx;
+  for (; n-- > 0; ) {
+    const _ex = ab * tx * tx * tx;
+    const _ey = ba * ty * ty * ty;
+    const qx = apx - _ex;
+    const qy = apy - _ey;
+    const q = Math.hypot(rx * tx - _ex, ry * ty - _ey) / Math.hypot(qx, qy);
+    tx = clamp01((qx * q + _ex) / rx);
+    ty = clamp01((qy * q + _ey) / ry);
+    const t = Math.hypot(tx, ty);
+    tx /= t;
+    ty /= t;
+  }
+  return [rx * (px < ex ? -tx : tx) + ex, ry * (py < ey ? -ty : ty) + ey];
+};
+export {
+  closestPointEllipse
 };

package/line.js

@@ -6,143 +6,65 @@ import { magSq } from "@thi.ng/vectors/magsq";
 import { mixN } from "@thi.ng/vectors/mixn";
 import { set } from "@thi.ng/vectors/set";
 import { sub } from "@thi.ng/vectors/sub";
-/**
- * Computes the parametric distance `t` of point `p` projected onto line
- * `a` -> `b`, relative to `a`. I.e. the projection of `p` can then be
- * computed like so:
- *
- * @example
- * ```ts
- * mixN([], a, b, closestT(p, a, b))
- * ```
- *
- * If the return value is outside the closed [0,1] interval, the
- * projected point lies outside the line segment. Returns `undefined` if
- * `a` and `b` are coincident.
- *
- * - {@link closestPointLine}
- * - {@link closestPointSegment}
- *
- * @param p - query point
- * @param a - line point A
- * @param b - line point B
- */
-export const closestT = (p, a, b) => {
-    const d = sub([], b, a);
-    const l = magSq(d);
-    return l > 1e-6 ? dot(sub([], p, a), d) / l : undefined;
+const closestT = (p, a, b) => {
+  const d = sub([], b, a);
+  const l = magSq(d);
+  return l > 1e-6 ? dot(sub([], p, a), d) / l : void 0;
 };
-/**
- * Returns closest point to `p` on infinite line defined by points `a`
- * and `b`. Use {@link closestPointSegment} to only consider the actual line
- * segment between these two points.
- *
- * {@link closestPointSegment}
- *
- * @param p - query point
- * @param a - line point A
- * @param b - line point B
- */
-export const closestPointLine = (p, a, b) => mixN([], a, b, closestT(p, a, b) || 0);
-/**
- * Returns distance from `p` to closest point to infinite line `a` ->
- * `b`. Use {@link distToSegment} to only consider the actual line segment
- * between these two points.
- *
- * {@link distToSegment}
- *
- * @param p - query point
- * @param a - line point A
- * @param b - line point B
- */
-export const distToLine = (p, a, b) => dist(p, closestPointLine(p, a, b) || a);
-/**
- * Returns closest point to `p` on line segment `a` -> `b`. By default,
- * if the result point lies outside the segment, returns a copy of the
- * closest end point. The result is written to the optional `out` vector
- * (or if omitted, a new one is created).
- *
- * If `insideOnly` is true, only returns the closest point iff it
- * actually is inside the segment. The behavior of this configurable via
- * the optional `eps` arg and by default includes both end points. This
- * function uses {@link closestT} to compute the parametric position of the
- * result point and determine if it lies within the line segment. If
- * `eps > 0`, the end points `a` and `b` will be excluded from the
- * match, effectively shortening the valid line segment from both ends,
- * i.e. the valid interval of the parametric position will be
- * [eps,1-eps]. If the result lies outside this interval, the function
- * returns `undefined`. Likewise, if `a` and `b` are coincident.
- *
- * @param p - query point
- * @param a - line point A
- * @param b - line point B
- * @param out - result
- * @param eps - epsilon value
- */
-export const closestPointSegment = (p, a, b, out, insideOnly = false, eps = 0) => {
-    const t = closestT(p, a, b);
-    if (t !== undefined && (!insideOnly || (t >= eps && t <= 1 - eps))) {
-        out = out || empty(p);
-        return t <= 0 ? set(out, a) : t >= 1 ? set(out, b) : mixN(out, a, b, t);
-    }
+const closestPointLine = (p, a, b) => mixN([], a, b, closestT(p, a, b) || 0);
+const distToLine = (p, a, b) => dist(p, closestPointLine(p, a, b) || a);
+const closestPointSegment = (p, a, b, out, insideOnly = false, eps = 0) => {
+  const t = closestT(p, a, b);
+  if (t !== void 0 && (!insideOnly || t >= eps && t <= 1 - eps)) {
+    out = out || empty(p);
+    return t <= 0 ? set(out, a) : t >= 1 ? set(out, b) : mixN(out, a, b, t);
+  }
 };
-/**
- * Returns distance from `p` to closest point on line segment `a` ->
- * `b`.
- *
- * @param p - query point
- * @param a - line point A
- * @param b - line point B
- */
-export const distToSegment = (p, a, b) => dist(p, closestPointSegment(p, a, b) || a);
-export const closestPointPolyline = (p, pts, closed = false, out = []) => {
-    if (!pts.length)
-        return;
-    const tmp = [];
-    const n = pts.length - 1;
-    let minD = Infinity, i, j;
-    if (closed) {
-        i = n;
-        j = 0;
-    }
-    else {
-        i = 0;
-        j = 1;
+const distToSegment = (p, a, b) => dist(p, closestPointSegment(p, a, b) || a);
+const closestPointPolyline = (p, pts, closed = false, out = []) => {
+  if (!pts.length)
+    return;
+  const tmp = [];
+  const n = pts.length - 1;
+  let minD = Infinity, i, j;
+  if (closed) {
+    i = n;
+    j = 0;
+  } else {
+    i = 0;
+    j = 1;
+  }
+  for (; j <= n; i = j, j++) {
+    if (closestPointSegment(p, pts[i], pts[j], tmp)) {
+      const d = distSq(p, tmp);
+      if (d < minD) {
+        minD = d;
+        set(out, tmp);
+      }
     }
-    for (; j <= n; i = j, j++) {
-        if (closestPointSegment(p, pts[i], pts[j], tmp)) {
-            const d = distSq(p, tmp);
-            if (d < minD) {
-                minD = d;
-                set(out, tmp);
-            }
-        }
-    }
-    return minD < Infinity ? out : undefined;
+  }
+  return minD < Infinity ? out : void 0;
 };
-/**
- * Returns the index of the start point containing the segment in the
- * polyline array `points` farthest away from `p` with regards to the
- * line segment `a` to `b`. `points` is only checked between indices
- * `from` and `to` (not including the latter).
- *
- * @param a - line point A
- * @param b - line point B
- * @param points - points
- * @param from - start search index
- * @param to - end search index
- */
-export const farthestPointSegment = (a, b, points, from = 0, to = points.length) => {
-    let maxD = -1;
-    let maxIdx = -1;
-    const tmp = empty(a);
-    for (let i = from; i < to; i++) {
-        const p = points[i];
-        const d = distSq(p, closestPointSegment(p, a, b, tmp) || a);
-        if (d > maxD) {
-            maxD = d;
-            maxIdx = i;
-        }
+const farthestPointSegment = (a, b, points, from = 0, to = points.length) => {
+  let maxD = -1;
+  let maxIdx = -1;
+  const tmp = empty(a);
+  for (let i = from; i < to; i++) {
+    const p = points[i];
+    const d = distSq(p, closestPointSegment(p, a, b, tmp) || a);
+    if (d > maxD) {
+      maxD = d;
+      maxIdx = i;
     }
-    return [maxIdx, Math.sqrt(maxD)];
+  }
+  return [maxIdx, Math.sqrt(maxD)];
+};
+export {
+  closestPointLine,
+  closestPointPolyline,
+  closestPointSegment,
+  closestT,
+  distToLine,
+  distToSegment,
+  farthestPointSegment
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/geom-closest-point",
-  "version": "2.1.87",
+  "version": "2.1.89",
   "description": "2D / 3D closest point / proximity helpers",
   "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/math": "^5.7.6",
-    "@thi.ng/vectors": "^7.8.8"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/math": "^5.7.7",
+    "@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",
@@ -101,5 +104,5 @@
     ],
     "year": 2018
   },
-  "gitHead": "25f2ac8ff795a432a930119661b364d4d93b59a0\n"
+  "gitHead": "22e36fa838e5431d40165384918b395603bbd92f\n"
 }

package/plane.js

@@ -1,26 +1,9 @@
 import { dot } from "@thi.ng/vectors/dot";
 import { normalize } from "@thi.ng/vectors/normalize";
 import { sub } from "@thi.ng/vectors/sub";
-/**
- * Returns signed distance between point `p` and plane defined by normal `n` and
- * `w`. In 2D this also works for lines.
- *
- * @remarks
- * If result is > 0 the point lies "above" the plane, if < 0 below the plane or
- * if zero on the plane.
- *
- * @param p -
- * @param n -
- * @param w -
- */
-export const distToPlane = (p, n, w) => dot(n, p) - w;
-/**
- * Returns closest point to `p` on the plane defined by normal `n` and `w`. In
- * 2D this also works for lines.
- *
- * @param p -
- * @param normal -
- * @param w -
- * @param out -
- */
-export const closestPointPlane = (p, normal, w, out = []) => sub(out, p, normalize(out, normal, distToPlane(p, normal, w)));
+const distToPlane = (p, n, w) => dot(n, p) - w;
+const closestPointPlane = (p, normal, w, out = []) => sub(out, p, normalize(out, normal, distToPlane(p, normal, w)));
+export {
+  closestPointPlane,
+  distToPlane
+};

package/points.js

@@ -1,24 +1,17 @@
 import { distSq } from "@thi.ng/vectors/distsq";
 import { set } from "@thi.ng/vectors/set";
-/**
- * Returns closest point to `p` in given point array, optionally using custom
- * distance function `dist` (default:
- * [`distSq()`](https://docs.thi.ng/umbrella/vectors/functions/distSq.html)).
- *
- * @param p -
- * @param pts -
- * @param out -
- * @param dist -
- */
-export const closestPointArray = (p, pts, out = [], dist = distSq) => {
-    let minD = Infinity;
-    let closest;
-    for (let i = pts.length; i-- > 0;) {
-        const d = dist(pts[i], p);
-        if (d < minD) {
-            minD = d;
-            closest = pts[i];
-        }
+const closestPointArray = (p, pts, out = [], dist = distSq) => {
+  let minD = Infinity;
+  let closest;
+  for (let i = pts.length; i-- > 0; ) {
+    const d = dist(pts[i], p);
+    if (d < minD) {
+      minD = d;
+      closest = pts[i];
     }
-    return closest ? set(out, closest) : undefined;
+  }
+  return closest ? set(out, closest) : void 0;
+};
+export {
+  closestPointArray
 };