@weasel-js/geom 1.9.4 → 1.10.0

package/dist/3d/index.js

@@ -1,6 +1,6 @@
 import { PORT_REACH, portControls, portCurvePoints, cubicAt } from '../chunk-YQADYJJ7.js';
 export { PORT_REACH } from '../chunk-YQADYJJ7.js';
-import { SINGULAR_RATIO } from '../chunk-N5SYTHMR.js';
+import { SINGULAR_RATIO } from '../chunk-755Y4YZS.js';
 
 // src/3d/vec3.ts
 function add(a, b) {

package/dist/booleans/index.d.ts

@@ -1,5 +1,5 @@
-import { P as Path, a as PolygonPath } from '../path-D0CoudGM.js';
-import { P as Point } from '../cubicMath-CpCvuEl8.js';
+import { P as PolygonPath, a as Path } from '../path-Bf9KeVxC.js';
+import { P as Point } from '../cubicMath-CFXbq6vp.js';
 
 /** Union of N paths. Commutative. Returns an empty path if all inputs are empty. */
 declare function pathUnion(...paths: Path[]): PolygonPath;
@@ -9,30 +9,48 @@ declare function pathIntersect(...paths: Path[]): PolygonPath;
 declare function pathSubtract(a: Path, b: Path): PolygonPath;
 /** Symmetric difference (XOR) of N paths. Commutative. */
 declare function pathExclude(...paths: Path[]): PolygonPath;
+/** One path of a result that keeps its pieces apart, and the inputs it came
+ *  from: their indices in the call, ascending, so the last is the topmost of
+ *  inputs given back to front. */
+interface BooleanPiece {
+    path: PolygonPath;
+    sources: number[];
+}
+/** {@link pathDividePieces} as bare paths. */
+declare function pathDivide(...paths: Path[]): PolygonPath[];
+/** {@link pathCropPieces} as bare paths. */
+declare function pathCrop(...paths: Path[]): PolygonPath[];
 /**
  * Fracture N paths along every intersection into the maximal set of
- * non-overlapping regions. Returns one polygon path per region.
+ * non-overlapping regions. Returns one piece per region, naming every input
+ * that covers it. For N=2 these are the three Illustrator "Divide" outputs
+ * (A−B, B−A, A∩B).
  *
- * Algorithm: for every non-empty subset S ⊆ {A1..AN}, emit the region
- * `(∩ S) − (∪ complement)` — points covered by exactly the members of S
- * and no others. By construction the emitted regions are pairwise disjoint
- * and their union equals `pathUnion(A1..AN)`.
- *
- * For N=2 this collapses to the three Illustrator "Divide" outputs
- * (A−B, B−A, A∩B). For N=3 up to 7 regions are emitted. The 2^N − 1
- * subset count limits this to small N in practice; passing more than ~8
- * inputs is a misuse — the polygon-clipping kernel dominates anyway.
+ * One region per non-empty subset of the inputs, so the 2^N − 1 subset count
+ * limits this to small N; passing more than ~8 inputs is a misuse.
  */
-declare function pathDivide(...paths: Path[]): PolygonPath[];
+declare function pathDividePieces(...paths: Path[]): BooleanPiece[];
 /**
- * Clip each non-topmost path to the topmost path (Illustrator "Crop").
- * Returns `N - 1` results, one per source-below-top, in input order.
- * Discards the topmost path itself — it acts purely as the clipping mask.
- *
- * Empty results (a source that lies entirely outside the mask) are
- * filtered. With `<2` inputs the result is empty.
+ * Remove from each path what the paths after it cover (Illustrator "Trim"):
+ * given back to front, every piece is the part of its input left showing.
+ * One piece per input in input order, less the inputs wholly hidden.
  */
-declare function pathCrop(...paths: Path[]): PolygonPath[];
+declare function pathTrim(...paths: Path[]): BooleanPiece[];
+/**
+ * {@link pathTrim}, then unite the pieces of the inputs `keyOf` gives the same
+ * key (Illustrator "Merge", keyed by paint). Keys compare with `===`. A piece
+ * names every input left showing in it, and the pieces are ordered by their
+ * topmost one. Pieces that share a key and do not touch come back as one path
+ * of several contours.
+ */
+declare function pathMerge(paths: readonly Path[], keyOf: (index: number) => unknown): BooleanPiece[];
+/**
+ * Clip each non-topmost path to the topmost path (Illustrator "Crop"), which
+ * acts purely as the mask and is discarded. Returns up to `N - 1` pieces in
+ * input order, each naming the one input it was clipped from; a source
+ * entirely outside the mask is dropped.
+ */
+declare function pathCropPieces(...paths: Path[]): BooleanPiece[];
 
 /**
  * Union the triangles of an indexed mesh (`vertices` as x, y pairs; `indices`
@@ -74,16 +92,13 @@ interface SplitBySegmentOptions {
  */
 declare function splitPathBySegment(path: Path, a: Point, b: Point, opts?: SplitBySegmentOptions): Path[] | null;
 /**
- * Split `path` along the open polyline `cut` into closed pieces (Knife). A
- * freehand cut is a polyline through its samples.
+ * Split `path` along the open polyline `cut` into closed pieces (Knife).
  *
  * Only chords the cut crosses end to end are cut: a stretch of the cut that
  * starts or stops inside the fill cuts nothing, and nothing beyond the cut's
- * ends is touched, so a concave shape splits exactly where the stroke crosses
- * it. Curves are split at the crossing parameters by de Casteljau
- * subdivision, so every piece traces the original boundary exactly and keeps
- * its quadratic and cubic segments; the new edges follow the cut as straight
- * lines, bends included.
+ * ends is touched. Curves are split at the crossing parameters by de Casteljau
+ * subdivision, so every piece keeps its quadratic and cubic segments; the new
+ * edges follow the cut as straight lines, bends included.
  *
  * A loop the cut draws inside the fill, where it crosses its own track, cuts
  * out the region it encloses: that region is returned as its own piece, with
@@ -91,7 +106,7 @@ declare function splitPathBySegment(path: Path, a: Point, b: Point, opts?: Split
  * running through a loop leaves the loop uncut. A closed cut (its last point
  * equal to its first) is one such loop or, where it crosses the boundary, is
  * cut as the chords it makes. Chords that cross each other are cut one after
- * another, so a cross-hatch yields every piece.
+ * another.
  *
  * Each connected piece the cut produces is returned as its own path, holes
  * included. Contours the cut misses entirely are returned together as one
@@ -122,4 +137,4 @@ declare function splitPathByPolyline(path: Path, cut: readonly Point[], opts?: S
  */
 declare function snipPathByPolyline(path: Path, cut: readonly Point[]): Path[] | null;
 
-export { type MultiPolygon, type Pair, type PathToMultiPolygonOptions, type Polygon, type Ring, type SplitBySegmentOptions, multiPolygonToPath, pathCrop, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };
+export { type BooleanPiece, type MultiPolygon, type Pair, type PathToMultiPolygonOptions, type Polygon, type Ring, type SplitBySegmentOptions, multiPolygonToPath, pathCrop, pathCropPieces, pathDivide, pathDividePieces, pathExclude, pathIntersect, pathMerge, pathSubtract, pathToMultiPolygon, pathTrim, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };

package/dist/booleans/index.js

@@ -1,7 +1,7 @@
 import { elevateQuadraticToCubic, splitQuadraticAt, splitCubicAt } from '../chunk-URQMDR6Q.js';
-import { DEFAULT_FLATTEN_TOLERANCE, flattenCubic, segmentsCross, pointInPolygon } from '../chunk-X6GJRIQD.js';
-import { EPS } from '../chunk-N5SYTHMR.js';
-import { PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M } from '../chunk-E4TJRGJD.js';
+import { DEFAULT_FLATTEN_TOLERANCE, fillsOpenSubpaths, flattenCubic, segmentsCross, pointInPolygon } from '../chunk-WQMYOCFB.js';
+import { EPS } from '../chunk-755Y4YZS.js';
+import { PATH_Z, PATH_Q, PATH_C, PATH_L, PATH_M } from '../chunk-OXH3NOXC.js';
 import polygonClipping from 'polygon-clipping';
 
 // src/booleans/adapter.ts
@@ -24,7 +24,9 @@ function pathToMultiPolygon(path, opts = {}) {
   let startX = 0, startY = 0;
   let ci = 0;
   const { commands, coords } = path;
-  const finalizeCurrent = () => {
+  const fillsOpen = fillsOpenSubpaths(path);
+  const finalizeCurrent = (closed = fillsOpen) => {
+    if (!closed) current = null;
     if (!current || current.length === 0) return;
     const first = current[0];
     const last = current[current.length - 1];
@@ -82,7 +84,7 @@ function pathToMultiPolygon(path, opts = {}) {
         break;
       }
       case PATH_Z: {
-        finalizeCurrent();
+        finalizeCurrent(true);
         cx = startX;
         cy = startY;
         break;
@@ -235,9 +237,15 @@ function pathExclude(...paths) {
   return multiPolygonToPath(polygonClipping.xor(head, ...rest));
 }
 function pathDivide(...paths) {
+  return pathDividePieces(...paths).map((p) => p.path);
+}
+function pathCrop(...paths) {
+  return pathCropPieces(...paths).map((p) => p.path);
+}
+function pathDividePieces(...paths) {
   if (paths.length === 0) return [];
   if (paths.length === 1) {
-    return [multiPolygonToPath(pathToMultiPolygon(paths[0]))];
+    return [{ path: multiPolygonToPath(pathToMultiPolygon(paths[0])), sources: [0] }];
   }
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const n = mps.length;
@@ -248,7 +256,9 @@ function pathDivide(...paths) {
   for (const mask of subsets) {
     const inside = [];
     const outside = [];
+    const sources = [];
     for (let i = 0; i < n; i++) {
+      if (mask & 1 << i) sources.push(i);
       (mask & 1 << i ? inside : outside).push(mps[i]);
     }
     const [insideHead, ...insideRest] = inside;
@@ -260,10 +270,35 @@ function pathDivide(...paths) {
       region = polygonClipping.difference(region, outsideUnion);
       if (region.length === 0) continue;
     }
-    out.push(multiPolygonToPath(region));
+    out.push({ path: multiPolygonToPath(region), sources });
+  }
+  return out;
+}
+function pathTrim(...paths) {
+  const mps = paths.map((p) => pathToMultiPolygon(p));
+  const out = [];
+  let cover = null;
+  for (let i = mps.length - 1; i >= 0; i--) {
+    const shown = cover ? polygonClipping.difference(mps[i], cover) : mps[i];
+    if (shown.length > 0) out.unshift({ path: multiPolygonToPath(shown), sources: [i] });
+    cover = cover ? polygonClipping.union(cover, mps[i]) : mps[i];
   }
   return out;
 }
+function pathMerge(paths, keyOf) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const piece of pathTrim(...paths)) {
+    const key = keyOf(piece.sources[0]);
+    const group = groups.get(key);
+    if (group) group.push(piece);
+    else groups.set(key, [piece]);
+  }
+  const top = (p) => p.sources[p.sources.length - 1];
+  return [...groups.values()].map((g) => g.length === 1 ? g[0] : {
+    path: pathUnion(...g.map((p) => p.path)),
+    sources: g.map((p) => p.sources[0])
+  }).sort((a, b) => top(a) - top(b));
+}
 function popcount(n) {
   let c = 0;
   while (n) {
@@ -272,14 +307,14 @@ function popcount(n) {
   }
   return c;
 }
-function pathCrop(...paths) {
+function pathCropPieces(...paths) {
   if (paths.length < 2) return [];
   const mps = paths.map((p) => pathToMultiPolygon(p));
   const mask = mps[mps.length - 1];
   const out = [];
   for (let i = 0; i < mps.length - 1; i++) {
     const clipped = polygonClipping.intersection(mps[i], mask);
-    if (clipped.length > 0) out.push(multiPolygonToPath(clipped));
+    if (clipped.length > 0) out.push({ path: multiPolygonToPath(clipped), sources: [i] });
   }
   return out;
 }
@@ -475,7 +510,8 @@ function crossingsOnSegment(boundaries, cut, k, out) {
 
 // src/booleans/contours.ts
 function parseContours(path) {
-  return parseSubpaths(path).map((s) => s.segs);
+  const fillsOpen = path.kind === "rect" || fillsOpenSubpaths(path);
+  return parseSubpaths(path).filter((s) => s.closed || fillsOpen).map((s) => s.segs);
 }
 function parseSubpaths(path, implicitClose = true) {
   if (path.kind === "rect") {
@@ -958,6 +994,6 @@ function snipStations(sub, cut) {
   return groups.filter((g) => g.length % 2 === 1).map((g) => g[0]).filter((st) => sub.closed || !same(st.pt, first) && !same(st.pt, end));
 }
 
-export { multiPolygonToPath, pathCrop, pathDivide, pathExclude, pathIntersect, pathSubtract, pathToMultiPolygon, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };
+export { multiPolygonToPath, pathCrop, pathCropPieces, pathDivide, pathDividePieces, pathExclude, pathIntersect, pathMerge, pathSubtract, pathToMultiPolygon, pathTrim, pathUnion, snipPathByPolyline, splitPathByPolyline, splitPathBySegment, trianglesToPath };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map