@weasel-js/geom 1.9.2 → 1.9.4

package/dist/index.d.ts

@@ -13,6 +13,8 @@ export { PORT_REACH } from './nd/index.js';
  */
 /** Base relative epsilon, sized for Float32 storage (~1 part in 1e-6). */
 declare const EPS = 0.000001;
+/** `v` held to `lo`..`hi`. `lo` wins when the bounds cross; `NaN` passes through. */
+declare function clamp(v: number, lo: number, hi: number): number;
 /** 2D cross (wedge) product of vectors (ax,ay) and (bx,by). */
 declare function cross(ax: number, ay: number, bx: number, by: number): number;
 /** 2D dot product. */
@@ -37,6 +39,38 @@ declare function sign(n: number): -1 | 0 | 1;
  */
 declare function approxEq(a: number, b: number, eps?: number): boolean;
 
+/**
+ * Viewport state. `(view.x, view.y)` is the world point currently rendered at
+ * the canvas top-left; `view.scale.x` / `view.scale.y` is pixels per world
+ * unit on each axis.
+ *
+ * A `View` names no orientation, so a kernel with a camera cannot express its
+ * viewport as one.
+ */
+interface View {
+    x: number;
+    y: number;
+    scale: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * The smallest zoom magnitude a view can hold, in `View.scale` units.
+ *
+ * A view's zoom is always finite and at least this far from 0. Nothing can be
+ * drawn or picked through a zoom of 0, and every screen↔world conversion
+ * divides by it, so it is ruled out where views are made rather than handled
+ * by each conversion.
+ */
+declare const ZOOM_FLOOR = 1e-9;
+/**
+ * The one rule for a zoom magnitude: a finite number no smaller than
+ * {@link ZOOM_FLOOR}. Anything else (0, negative, NaN, ±Infinity) becomes the
+ * floor.
+ */
+declare function normalizeZoom(zoom: number): number;
+
 /** `[a, b, c, d, e, f]`: `x' = a·x + c·y + e`, `y' = b·x + d·y + f`. */
 type Mat3 = readonly [number, number, number, number, number, number];
 /** The transform that leaves a point where it is. */
@@ -150,10 +184,14 @@ declare function pathCommandCoordCount(cmd: number): number;
  * returns it to the subpath's opening `M`, so a command following a `Z`
  * without an intervening `M` starts where SVG says it does.
  *
+ * Such a command opens a new subpath at the pen, as does a drawing command
+ * no `M` precedes at all. The visitor is told with `opensSubpath`, and has to
+ * start its contour at `(penX, penY)` then: there is no `M` to do it.
+ *
  * A code `PATH_COMMANDS` does not declare throws once the visitor has seen it,
  * since the walker cannot tell how many coords it consumes.
  */
-declare function forEachSegment(commands: ArrayLike<number>, coords: ArrayLike<number>, visit: (cmd: number, coordIndex: number, penX: number, penY: number, commandIndex: number) => void | boolean): void;
+declare function forEachSegment(commands: ArrayLike<number>, coords: ArrayLike<number>, visit: (cmd: number, coordIndex: number, penX: number, penY: number, commandIndex: number, opensSubpath: boolean) => void | boolean): void;
 
 /** Cubic Bezier point at parameter t (de Casteljau / Bernstein form). */
 declare function cubicEvalAt(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, t: number): [number, number];
@@ -440,7 +478,7 @@ declare function scalePathToBounds(path: Path, target: RectPath): Path;
 
 /** Apply an affine `Mat3` to a path's geometry.
  *
- * Axis-aligned maps (no rotation/shear, i.e. `m[1] === 0 && m[2] === 0`) keep a
+ * Axis-aligned maps (no rotation/shear: `m[1]` and `m[2]` within 1e-9 of 0) keep a
  * `RectPath` a rect — the four corners stay axis-aligned, so we transform the
  * two diagonal corners and normalize negative extent (mirror). Rotation or
  * shear promotes the rect's four corners to a `PolygonPath`. Polygon paths map
@@ -537,7 +575,9 @@ declare function reversePath(path: PolygonPath): PolygonPath;
 /**
  * Build a weasel `PolygonPath` from an SVG path-data (`d`) string. Unknown
  * command letters are skipped (and reported via `onWarn` when provided); the
- * builder still returns whatever valid commands preceded them.
+ * builder still returns whatever valid commands preceded them. Data that does
+ * not begin with a moveto builds an empty path, and a command with the wrong
+ * number of arguments ends the path before it, as SVG renders both.
  */
 declare function pathFromD(d: string, onWarn?: (message: string) => void): ReturnType<PathBuilder['build']>;
 
@@ -867,4 +907,4 @@ declare function cubicBezierEasing(x1: number, y1: number, x2: number, y2: numbe
 /** Resolve a spec to the function that shapes progress. `undefined` is linear. */
 declare function resolveEasing(spec?: EasingSpec): EasingFn;
 
-export { type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type LineCoords, type Mat3, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathNearest, type PathStation, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, PolygonPath, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, applyToPoint, approxEq, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, clampRectWithin, composePath, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, elevateQuadraticToCubic, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, identity, invert, len2, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, segmentsCross, sign, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, starPath, strokeHitTest, sub, transformCoords, transformPath, translate, translatePath, unionBoundsPath, unionBox };
+export { type BezierEasing, type Box, type CubicCoords, type CurveNearest, DEFAULT_FLATTEN_TOLERANCE, EASINGS, EPS, type EasingFn, type EasingName, type EasingSpec, type LineCoords, type Mat3, PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, Path, PathBuilder, type PathCommandCode, type PathCommandName, PathFillRule, type PathNearest, type PathStation, type PlaceRectOptions, type PlacedRect, type Placement, type PlacementAlign, type PlacementSide, Point, type PointAlongPathOptions, type PointInPathOptions, PolygonPath, type QuadraticCoords, type Rect, RectPath, SPRING_PRESETS, type SpringPreset, type SpringPresetName, type StrokeHitTestOptions, type View, ZOOM_FLOOR, applyToPoint, approxEq, boundsOfCoords, boundsOfPath, boxContainsBox, boxContainsPoint, boxToBox, clamp, clampRectWithin, composePath, cross, cubicBezierEasing, cubicBounds, cubicEvalAt, decomposePath, dot, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, elevateQuadraticToCubic, ellipsePath, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, forEachSegment, identity, invert, len2, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, normalizeZoom, pathCommandCoordCount, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, pointInPolygon, pointSegmentDist2, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls, portCurvePoints, quadraticEvalAt, rectPath, rectToContour, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, segmentsCross, sign, splitCubicAt, splitLineAt, splitQuadraticAt, splitSubpaths, starPath, strokeHitTest, sub, transformCoords, transformPath, translate, translatePath, unionBoundsPath, unionBox };

package/dist/index.js

@@ -4,14 +4,20 @@ import { cubicPointAt } from './chunk-HPVINMOM.js';
 export { cubicPointAt, fitCubicThroughDeletion, splitCubicAtT } from './chunk-HPVINMOM.js';
 import { cubicEvalAt, elevateQuadraticToCubic, cubicBounds } from './chunk-URQMDR6Q.js';
 export { cubicBounds, cubicEvalAt, elevateQuadraticToCubic, quadraticEvalAt, splitCubicAt, splitLineAt, splitQuadraticAt } from './chunk-URQMDR6Q.js';
-import { extractPolylines } from './chunk-6T5I3PR5.js';
-export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-6T5I3PR5.js';
-import { DEFAULT_FLATTEN_TOLERANCE, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, segmentsCross } from './chunk-RQYCDPU5.js';
-export { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross } from './chunk-RQYCDPU5.js';
-import { SINGULAR_RATIO } from './chunk-7ROQRYOA.js';
-export { EPS, approxEq, cross, dot, len2, sign, sub } from './chunk-7ROQRYOA.js';
-import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-HEZTRG2M.js';
-export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-HEZTRG2M.js';
+import { extractPolylines } from './chunk-NL423YYZ.js';
+export { boundsOfCoords, boxContainsBox, boxContainsPoint, rectToContour, unionBox } from './chunk-NL423YYZ.js';
+import { DEFAULT_FLATTEN_TOLERANCE, pointInPolygon, pointSegmentDist2, flattenQuadratic, flattenCubic, segmentsCross } from './chunk-X6GJRIQD.js';
+export { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, flattenCubicWithArcLen, flattenQuadratic, flattenQuadraticWithArcLen, pointInPolygon, pointSegmentDist2, segmentsCross } from './chunk-X6GJRIQD.js';
+import { SINGULAR_RATIO } from './chunk-N5SYTHMR.js';
+export { EPS, approxEq, clamp, cross, dot, len2, sign, sub } from './chunk-N5SYTHMR.js';
+import { forEachSegment, PATH_M, PATH_L, PATH_Q, PATH_C, PATH_Z, pathCommandCoordCount } from './chunk-E4TJRGJD.js';
+export { PATH_C, PATH_CMD_LENGTHS, PATH_COMMANDS, PATH_L, PATH_M, PATH_Q, PATH_Z, forEachSegment, pathCommandCoordCount } from './chunk-E4TJRGJD.js';
+
+// src/view.ts
+var ZOOM_FLOOR = 1e-9;
+function normalizeZoom(zoom) {
+  return zoom >= ZOOM_FLOOR && zoom < Infinity ? zoom : ZOOM_FLOOR;
+}
 
 // src/mat3.ts
 function identity() {
@@ -404,10 +410,11 @@ function transformCoords(coords, m) {
 }
 
 // src/paths/transformPath.ts
+var AXIS_ALIGNED_EPSILON = 1e-9;
 function transformPath(path, m) {
   const [a, b, c, d, e, f] = m;
   if (path.kind === "rect") {
-    if (b === 0 && c === 0) {
+    if (Math.abs(b) < AXIS_ALIGNED_EPSILON && Math.abs(c) < AXIS_ALIGNED_EPSILON) {
       const x0 = a * path.x + e;
       const y0 = d * path.y + f;
       const x1 = a * (path.x + path.width) + e;
@@ -470,16 +477,8 @@ function decomposePath(parent, world) {
   return translatePath(world, -origin.x, -origin.y);
 }
 function pathOrigin(path) {
-  if (path.kind === "rect") return { x: path.x, y: path.y };
-  let minX = Infinity;
-  let minY = Infinity;
-  const { coords } = path;
-  for (let i = 0; i < coords.length; i += 2) {
-    if (coords[i] < minX) minX = coords[i];
-    if (coords[i + 1] < minY) minY = coords[i + 1];
-  }
-  if (minX === Infinity) return { x: 0, y: 0 };
-  return { x: minX, y: minY };
+  const { x, y } = boundsOfPath(path);
+  return { x, y };
 }
 
 // src/paths/splitSubpaths.ts
@@ -724,6 +723,7 @@ function pathFromD(d, onWarn) {
     lastCubicCtrl: null,
     lastQuadCtrl: null
   };
+  let started = false;
   for (const { cmd, args } of tokens) {
     const upper = cmd.toUpperCase();
     const relative = cmd !== upper;
@@ -732,6 +732,10 @@ function pathFromD(d, onWarn) {
       onWarn?.(`unknown path command: ${cmd}`);
       continue;
     }
+    if (!started && upper !== "M") {
+      onWarn?.(`path data does not begin with a moveto ("${cmd}" comes first); nothing is drawn`);
+      break;
+    }
     if (upper === "Z") {
       b.close();
       st.x = st.startX;
@@ -740,11 +744,16 @@ function pathFromD(d, onWarn) {
       st.lastQuadCtrl = null;
       continue;
     }
-    const groups = argCount === 0 ? 1 : Math.floor(args.length / argCount);
+    const groups = Math.floor(args.length / argCount);
     for (let g = 0; g < groups; g++) {
       const a = args.slice(g * argCount, (g + 1) * argCount);
       const effectiveUpper = upper === "M" && g > 0 ? "L" : upper;
       runCommand(effectiveUpper, relative, a, st, b);
+      started = true;
+    }
+    if (groups === 0 || args.length % argCount !== 0) {
+      onWarn?.(`path command "${cmd}" takes ${argCount} arguments at a time and has ${args.length}; the path ends before it`);
+      break;
     }
   }
   return b.build();
@@ -1042,8 +1051,7 @@ function measureError(samples, fit) {
   let worstError = 0;
   const a = samples[0];
   for (let i = 1; i < samples.length - 1; i++) {
-    const t = i / (samples.length - 1);
-    const q = cubicPointAt(a, fit.cp1, fit.cp2, fit.end, t);
+    const q = cubicPointAt(a, fit.cp1, fit.cp2, fit.end, fit.ts[i]);
     const dx = samples[i].x - q.x;
     const dy = samples[i].y - q.y;
     const sq = dx * dx + dy * dy;
@@ -1061,7 +1069,7 @@ function fitOneCubic(samples) {
   const tStart = unit(sub2(samples[1], a));
   const tEnd = unit(sub2(samples[n - 2], e));
   const ts = chordLengthParam(samples);
-  if (ts === null) return { cp1: { ...a }, cp2: { ...e }, end: e };
+  if (ts === null) return { cp1: { ...a }, cp2: { ...e }, end: e, ts: samples.map(() => 0) };
   let fit = solveLS(samples, ts, a, e, tStart, tEnd);
   for (let pass = 0; pass < 4; pass++) {
     reparameterize(samples, ts, a, e, fit);
@@ -1121,7 +1129,8 @@ function solveLS(samples, ts, a, e, tStart, tEnd) {
   return {
     cp1: { x: a.x + tStart.x * alpha1, y: a.y + tStart.y * alpha1 },
     cp2: { x: e.x + tEnd.x * alpha2, y: e.y + tEnd.y * alpha2 },
-    end: e
+    end: e,
+    ts
   };
 }
 function reparameterize(samples, ts, a, e, fit) {
@@ -1273,7 +1282,8 @@ function flatSubpaths(path, tolerance) {
   const closed = [];
   const open = [];
   let sub3 = [];
-  forEachSegment(commands, coords, (cmd, ci, curX, curY) => {
+  forEachSegment(commands, coords, (cmd, ci, curX, curY, _i, opensSubpath) => {
+    if (opensSubpath) sub3 = [curX, curY];
     switch (cmd) {
       case PATH_M:
         if (sub3.length >= 2) open.push(sub3);
@@ -1349,6 +1359,7 @@ function strokeHitTest(path, x, y, threshold, opts = {}) {
     const [a, b, c, d] = slop.transform;
     const m = { a, b, c, d };
     const st = stretchOf(m);
+    if (st.s1 === 0) return false;
     if (isSimilarity(st)) {
       return strokeHitTest(path, x, y, threshold + slop.px / st.s1, { tolerance: opts.tolerance });
     }
@@ -1764,6 +1775,7 @@ function cubicBezierEasing(x1, y1, x2, y2) {
   };
 }
 var bezierCache = /* @__PURE__ */ new Map();
+var BEZIER_CACHE_LIMIT = 256;
 function isBezier(spec) {
   return typeof spec === "object" && spec !== null && "bezier" in spec;
 }
@@ -1781,6 +1793,7 @@ function resolveEasing(spec) {
     let fn = bezierCache.get(key);
     if (!fn) {
       fn = cubicBezierEasing(x1, y1, x2, y2);
+      if (bezierCache.size >= BEZIER_CACHE_LIMIT) bezierCache.delete(bezierCache.keys().next().value);
       bezierCache.set(key, fn);
     }
     return fn;
@@ -1788,6 +1801,6 @@ function resolveEasing(spec) {
   throw new Error("resolveEasing: unrecognized easing spec");
 }
 
-export { EASINGS, PathBuilder, SPRING_PRESETS, applyToPoint, boundsOfPath, boxToBox, clampRectWithin, composePath, cubicBezierEasing, decomposePath, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, ellipsePath, identity, invert, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints2 as portCurvePoints, rectPath, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, splitSubpaths, starPath, strokeHitTest, transformCoords, transformPath, translate, translatePath, unionBoundsPath };
+export { EASINGS, PathBuilder, SPRING_PRESETS, ZOOM_FLOOR, applyToPoint, boundsOfPath, boxToBox, clampRectWithin, composePath, cubicBezierEasing, decomposePath, easeIn, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOut, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOut, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, ellipsePath, identity, invert, linePath, linear, multiply, nearestOnCubic, nearestOnLine, nearestOnPath, nearestOnQuadratic, normalizeZoom, pathContainsPoint, pathContainsPolygon, pathContainsRect, pathDistanceToPoint, pathFromD, pathIntersectsPolygon, pathIntersectsRect, pathSignedArea, placeRect, pointAlongPath, pointInPath, polygonContainsPath, polygonFromPoints, polygonIntersectsPath, polylineFromPoints, portControls2 as portControls, portCurvePoints2 as portCurvePoints, rectPath, regularPolygonPath, resolveEasing, reversePath, rotate, rotateAboutPoint, scale, scalePathToBounds, schneiderFit, splitSubpaths, starPath, strokeHitTest, transformCoords, transformPath, translate, translatePath, unionBoundsPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map