pattapatta 0.3.0 → 0.4.0

package/dist/conversion/index.d.ts

@@ -1,6 +1,5 @@
-import { P as Path } from '../path-0RjhYjJs.js';
-import { G as Group, c as cloneGroup, g as group } from '../group-BNjVVYSQ.js';
-import '../vec2-CWyXN1Wj.js';
+import { P as Path } from '../path-Boeshk9L.js';
+import { G as Group, c as cloneGroup, g as group } from '../group-YVmSJuGo.js';
 
 /** Deep copy of a path. */
 declare function copy(p: Path): Path;

package/dist/{group-BNjVVYSQ.d.ts → group-YVmSJuGo.d.ts}

@@ -1,4 +1,4 @@
-import { P as Path } from './path-0RjhYjJs.js';
+import { P as Path } from './path-Boeshk9L.js';
 
 /**
  * Ordered collection of paths. Later entries are “on top” for occlusion-style ops.

package/dist/hatch/index.d.ts

@@ -1,6 +1,6 @@
-import { S as Segment } from '../segment-BKuIFMKD.js';
-import { P as Path } from '../path-0RjhYjJs.js';
-import '../vec2-CWyXN1Wj.js';
+import { S as Segment } from '../segment-CpLILSd7.js';
+import { P as Path } from '../path-Boeshk9L.js';
+import { SegmentLengthFn } from '../segmentSet/index.js';
 
 type ParallelHatchOptions = {
     /** Hatch angle in radians (segment direction). Default `Math.PI / 4`. */
@@ -23,6 +23,48 @@ type ParallelHatchOptions = {
         y: number;
     };
 };
+type WeaveHatchOptions = {
+    /** Grid cell size. Default: ~1/12 of the shorter AABB side. */
+    cellSize?: number;
+    /** Weft (horizontal on-top) run length in cells. Default `1`. */
+    A?: number;
+    /** Warp (vertical on-top) run length in cells. Default `1`. */
+    B?: number;
+    /** Row phase shift in cells. Default `1`. */
+    C?: number;
+    swapColors?: boolean;
+    cellFraction?: number;
+    extendSingletonsToEdge?: boolean;
+};
+type StochasticHatchOptions = {
+    /** Number of segments before clipping. Default `40`. */
+    count?: number;
+    /** Fixed segment length (overrides min/max). */
+    length?: number;
+    /** Minimum segment length. Default `1`. */
+    minLength?: number;
+    /** Maximum segment length (exclusive when ≠ min). Default: min(AABB w,h). */
+    maxLength?: number;
+    /** PRNG seed. Default `1`. */
+    seed?: number;
+};
+type PerpendicularHatchOptions = {
+    /** Arc-length spacing between ticks. Default `0.15`. */
+    spacing?: number;
+    /** Tick length, or a per-sample length function. Default `0.2`. */
+    length?: number | SegmentLengthFn;
+    /** Fractional phase along each ring in `[0,1)`. Default `0`. */
+    startOffset?: number;
+};
+type ConcentricHatchOptions = {
+    /** Inward offset step between shells. Default `0.15`. */
+    spacing?: number;
+    /**
+     * Max number of shells. Default: enough to erode until empty
+     * (capped by AABB diagonal / spacing).
+     */
+    count?: number;
+};
 /**
  * Fill a closed path with parallel hatch strokes (plotter-safe).
  * Composes `parallelSegments` + clip-to-path (PGS dysonHatching recipe).
@@ -33,9 +75,33 @@ type ParallelHatchOptions = {
 declare function parallel(path: Path, options?: ParallelHatchOptions): Segment[];
 /** Cross-hatch: two perpendicular parallel passes. */
 declare function cross(path: Path, options?: ParallelHatchOptions): Segment[];
+/**
+ * Weave fill: ABC fabric segments over the path AABB, clipped to the path
+ * (PGS `weaveSegments` recipe).
+ */
+declare function weave(path: Path, options?: WeaveHatchOptions): Segment[];
+/**
+ * Stochastic fill: random non-intersecting segments in the path AABB, clipped
+ * to the path (PGS `stochasticSegments` recipe).
+ */
+declare function stochastic(path: Path, options?: StochasticHatchOptions): Segment[];
+/**
+ * Perimeter ticks: perpendicular segments centered on the path boundary
+ * (PGS `perpendicularPathSegments`). Outline texture, not an area fill.
+ */
+declare function perpendicular(path: Path, options?: PerpendicularHatchOptions): Segment[];
+/**
+ * Concentric shells: repeated inward offsets as closed stroke paths.
+ * Plotter-safe nested contours (not SVG paint).
+ */
+declare function concentric(path: Path, options?: ConcentricHatchOptions): Path[];
 declare const hatch: {
     parallel: typeof parallel;
     cross: typeof cross;
+    weave: typeof weave;
+    stochastic: typeof stochastic;
+    perpendicular: typeof perpendicular;
+    concentric: typeof concentric;
 };
 
-export { type ParallelHatchOptions, cross, hatch, parallel };
+export { type ConcentricHatchOptions, type ParallelHatchOptions, type PerpendicularHatchOptions, type StochasticHatchOptions, type WeaveHatchOptions, concentric, cross, hatch, parallel, perpendicular, stochastic, weave };

package/dist/hatch/index.js

@@ -1,4 +1,4 @@
-import { FillRule, pointInPolygonD, PointInPolygonResult } from 'clipper2-ts';
+import { FillRule, JoinType, inflatePathsD, EndType, isPositiveD, pointInPolygonD, PointInPolygonResult } from 'clipper2-ts';
 
 // src/types/vec2.ts
 function vec2(x, y) {
@@ -17,6 +17,12 @@ function segment(a, b) {
 }
 
 // src/types/path.ts
+function path(rings, closed = true) {
+  return {
+    rings: rings.map((ring) => ring.map(cloneVec2)),
+    closed
+  };
+}
 function normalizeRing(ring, eps = 1e-9) {
   if (ring.length < 2) return ring.map(cloneVec2);
   const first = ring[0];
@@ -26,6 +32,17 @@ function normalizeRing(ring, eps = 1e-9) {
   }
   return ring.map(cloneVec2);
 }
+function clonePath(p) {
+  return {
+    closed: p.closed,
+    rings: p.rings.map((ring) => ring.map(cloneVec2))
+  };
+}
+
+// src/types/group.ts
+function group(paths = []) {
+  return { paths: paths.map(clonePath) };
+}
 
 // src/segmentSet/index.ts
 function f32(n) {
@@ -92,6 +109,263 @@ function parallelSegments(centerX, centerY, length, spacing, angle, n) {
   }
   return edges;
 }
+function stochasticSegments(width, height, n, minLength, maxLength, seed = 1, originX = 0, originY = 0) {
+  const minL = minLength ?? 1;
+  const maxL = maxLength ?? Math.min(width, height);
+  if (n < 1 || width <= 0 || height <= 0) return [];
+  const monoLength = minL === maxL;
+  const rng = mulberry32(seed >>> 0);
+  const edges = [];
+  const maxAttempts = Math.max(1e4, n * 500);
+  let attempts = 0;
+  while (edges.length < n && attempts < maxAttempts) {
+    attempts++;
+    const length = monoLength ? minL : minL + rng() * (maxL - minL);
+    if (!(length > 0) || length * 2 >= width || length * 2 >= height) {
+      continue;
+    }
+    const ax = originX + rng() * (width - length * 2) + length;
+    const ay = originY + rng() * (height - length * 2) + length;
+    const theta = rng() * Math.PI * 2;
+    const bx = ax + Math.cos(theta) * length;
+    const by = ay + Math.sin(theta) * length;
+    const a = vec2(ax, ay);
+    const b = vec2(bx, by);
+    let hits = false;
+    for (const s of edges) {
+      if (segmentsIntersect(a, b, s.a, s.b)) {
+        hits = true;
+        break;
+      }
+    }
+    if (!hits) edges.push(segment(a, b));
+  }
+  return edges;
+}
+function weaveSegments(width, height, cellSize, A = 1, B = 1, C = 1, options = {}) {
+  if (!(cellSize > 0)) {
+    throw new Error("weaveSegments: cellSize must be > 0");
+  }
+  if (A <= 0 || B <= 0) {
+    throw new Error("weaveSegments: A and B must be > 0");
+  }
+  const {
+    originX = 0,
+    originY = 0,
+    swapColors = false,
+    cellFraction = 1,
+    extendSingletonsToEdge = true
+  } = options;
+  if (!(cellFraction > 0)) {
+    throw new Error("weaveSegments: cellFraction must be > 0");
+  }
+  const P = A + B;
+  const f = Math.max(0, Math.min(1, cellFraction));
+  const cols = Math.max(1, Math.floor(width / cellSize));
+  const rows = Math.max(1, Math.floor(height / cellSize));
+  const gridW = cols * cellSize;
+  const gridH = rows * cellSize;
+  const dx = originX + (width - gridW) * 0.5;
+  const dy = originY + (height - gridH) * 0.5;
+  const gridLeft = dx;
+  const gridRight = dx + gridW;
+  const gridBottom = dy;
+  const gridTop = dy + gridH;
+  const weft = Array.from(
+    { length: rows },
+    () => Array.from({ length: cols }, () => false)
+  );
+  for (let r = 0; r < rows; r++) {
+    const shift = floorMod(r * C, P);
+    for (let c = 0; c < cols; c++) {
+      const idx = floorMod(c + shift, P);
+      let isWeft = idx < A;
+      if (swapColors) isWeft = !isWeft;
+      weft[r][c] = isWeft;
+    }
+  }
+  const segs = [];
+  for (let r = 0; r < rows; r++) {
+    let c = 0;
+    while (c < cols) {
+      if (!weft[r][c]) {
+        c++;
+        continue;
+      }
+      const start = c;
+      while (c + 1 < cols && weft[r][c + 1]) c++;
+      const end = c;
+      const runLen = end - start + 1;
+      const y = dy + (r + 0.5) * cellSize;
+      let x0 = dx + (start + (1 - f)) * cellSize;
+      let x1 = dx + (end + f) * cellSize;
+      if (extendSingletonsToEdge && runLen === 1) {
+        const cx = dx + (start + 0.5) * cellSize;
+        if (start === 0) {
+          x0 = gridLeft;
+          x1 = cx;
+        } else if (end === cols - 1) {
+          x0 = cx;
+          x1 = gridRight;
+        }
+      }
+      x0 = clamp(x0, gridLeft, gridRight);
+      x1 = clamp(x1, gridLeft, gridRight);
+      segs.push(segment(vec2(x0, y), vec2(x1, y)));
+      c++;
+    }
+  }
+  for (let c = 0; c < cols; c++) {
+    let r = 0;
+    while (r < rows) {
+      if (weft[r][c]) {
+        r++;
+        continue;
+      }
+      const start = r;
+      while (r + 1 < rows && !weft[r + 1][c]) r++;
+      const end = r;
+      const runLen = end - start + 1;
+      const x = dx + (c + 0.5) * cellSize;
+      let y0 = dy + (start + (1 - f)) * cellSize;
+      let y1 = dy + (end + f) * cellSize;
+      if (extendSingletonsToEdge && runLen === 1) {
+        const cy = dy + (start + 0.5) * cellSize;
+        if (start === 0) {
+          y0 = gridBottom;
+          y1 = cy;
+        } else if (end === rows - 1) {
+          y0 = cy;
+          y1 = gridTop;
+        }
+      }
+      y0 = clamp(y0, gridBottom, gridTop);
+      y1 = clamp(y1, gridBottom, gridTop);
+      segs.push(segment(vec2(x, y0), vec2(x, y1)));
+      r++;
+    }
+  }
+  return segs;
+}
+function perpendicularPathSegments(path2, interSegmentDistance, length, startOffset = 0) {
+  if (!(interSegmentDistance > 0)) return [];
+  const lengthFn = typeof length === "function" ? length : () => length;
+  const startNorm = (startOffset % 1 + 1) % 1;
+  const edges = [];
+  for (const ring of path2.rings) {
+    if (ring.length < 2) continue;
+    const closed = path2.closed;
+    let pts = ring.map((v) => vec2(v.x, v.y));
+    if (closed && shoelace(pts) > 0) {
+      pts = pts.slice().reverse();
+    }
+    const indexed = lengthIndex(pts, closed);
+    const end = indexed.total;
+    if (!(end > 0)) continue;
+    const count = Math.max(1, Math.round(end / interSegmentDistance));
+    const increment = 1 / count;
+    const eps = Math.max(
+      end * 1e-4,
+      Math.min(interSegmentDistance * 0.35, end * 0.01)
+    );
+    for (let i = 0; i < count; i++) {
+      const posFrac = (startNorm + i * increment) % 1;
+      const idx = posFrac * end;
+      const idxM = closed ? wrapIndex(idx - eps, end) : clamp(idx - eps, 0, end);
+      const idxP = closed ? wrapIndex(idx + eps, end) : clamp(idx + eps, 0, end);
+      const pm = indexed.pointAt(idxM);
+      const pp = indexed.pointAt(idxP);
+      const pc = indexed.pointAt(idx);
+      const tx = pp.x - pm.x;
+      const ty = pp.y - pm.y;
+      const tlen = Math.hypot(tx, ty);
+      if (tlen === 0) continue;
+      const nx = -ty / tlen;
+      const ny = tx / tlen;
+      const normalAngle = Math.atan2(ny, nx);
+      const L = lengthFn(pc.x, pc.y, posFrac, normalAngle);
+      if (!(L > 0)) continue;
+      const half = L * 0.5;
+      edges.push(
+        segment(
+          vec2(pc.x - nx * half, pc.y - ny * half),
+          vec2(pc.x + nx * half, pc.y + ny * half)
+        )
+      );
+    }
+  }
+  return edges;
+}
+function floorMod(n, m) {
+  return (n % m + m) % m;
+}
+function clamp(v, lo, hi) {
+  return Math.max(lo, Math.min(hi, v));
+}
+function wrapIndex(idx, end) {
+  if (end <= 0) return 0;
+  let x = idx % end;
+  if (x < 0) x += end;
+  return x;
+}
+function shoelace(ring) {
+  let sum = 0;
+  for (let i = 0; i < ring.length; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % ring.length];
+    sum += a.x * b.y - b.x * a.y;
+  }
+  return sum / 2;
+}
+function segmentsIntersect(a, b, c, d) {
+  return ccw(a, c, d) !== ccw(b, c, d) && ccw(a, b, c) !== ccw(a, b, d);
+}
+function ccw(a, b, c) {
+  return (c.y - a.y) * (b.x - a.x) > (b.y - a.y) * (c.x - a.x);
+}
+function mulberry32(seed) {
+  return function() {
+    let t = seed += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function lengthIndex(ring, closed) {
+  const n = ring.length;
+  const edgeCount = closed ? n : n - 1;
+  const lengths = [];
+  let total = 0;
+  for (let i = 0; i < edgeCount; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    const L = Math.hypot(b.x - a.x, b.y - a.y);
+    lengths.push(L);
+    total += L;
+  }
+  return {
+    total,
+    pointAt(dist) {
+      let remain = dist;
+      if (remain <= 0) return { ...ring[0] };
+      if (remain >= total) return { ...ring[closed ? 0 : n - 1] };
+      for (let i = 0; i < lengths.length; i++) {
+        const L = lengths[i];
+        if (remain <= L || i === lengths.length - 1) {
+          const t = L < 1e-12 ? 0 : remain / L;
+          const a = ring[i];
+          const b = ring[(i + 1) % n];
+          return {
+            x: a.x + (b.x - a.x) * t,
+            y: a.y + (b.y - a.y) * t
+          };
+        }
+        remain -= L;
+      }
+      return { ...ring[0] };
+    }
+  };
+}
 FillRule.NonZero;
 function ringToPathD(ring) {
   const pts = [];
@@ -100,6 +374,45 @@ function ringToPathD(ring) {
   }
   return pts;
 }
+function pathToPathsD(p) {
+  if (!p.closed || p.rings.length === 0) {
+    throw new Error("Boolean ops require a closed path with at least one ring");
+  }
+  return p.rings.map((ring) => ringToPathD(ring));
+}
+function pathsDToGroup(paths) {
+  if (paths.length === 0) return group([]);
+  const outers = [];
+  const holes = [];
+  for (const pd of paths) {
+    const ring = pathDToRing(pd);
+    if (ring.length < 3) continue;
+    if (isPositiveD(pd)) {
+      outers.push({ ring, holes: [] });
+    } else {
+      holes.push(ring);
+    }
+  }
+  for (const hole of holes) {
+    const sample = hole[0];
+    if (!sample) continue;
+    let assigned = false;
+    for (const outer of outers) {
+      if (pointInRing(sample, outer.ring)) {
+        outer.holes.push(hole);
+        assigned = true;
+        break;
+      }
+    }
+    if (!assigned) {
+      outers.push({ ring: [...hole].reverse(), holes: [] });
+    }
+  }
+  return group(outers.map((o) => path([o.ring, ...o.holes], true)));
+}
+function pathDToRing(pd) {
+  return normalizeRing(pd.map((p) => vec2(p.x, p.y)));
+}
 function pointInRing(point, ring) {
   const result = pointInPolygonD(
     { x: point.x, y: point.y, z: 0 },
@@ -177,6 +490,12 @@ function segmentIntersection(a, b, c, d) {
     p: vec2(a.x + t * rX, a.y + t * rY)
   };
 }
+function buffer(path2, delta, options = {}) {
+  const subject = pathToPathsD(path2);
+  const join = options.join === "miter" ? JoinType.Miter : options.join === "square" ? JoinType.Square : JoinType.Round;
+  const inflated = inflatePathsD(subject, delta, join, EndType.Polygon);
+  return pathsDToGroup(inflated);
+}
 
 // src/hatch/index.ts
 function parallel(path2, options = {}) {
@@ -209,6 +528,94 @@ function cross(path2, options = {}) {
   const b = parallel(path2, { ...options, angle: angle + Math.PI / 2 });
   return [...a, ...b];
 }
+function weave(path2, options = {}) {
+  if (!path2.closed || !path2.rings[0]) {
+    throw new Error("hatch.weave requires a closed path");
+  }
+  const bounds = pathBounds(path2);
+  const width = Math.max(bounds.maxX - bounds.minX, 1e-9);
+  const height = Math.max(bounds.maxY - bounds.minY, 1e-9);
+  const cellSize = options.cellSize ?? Math.max(Math.min(width, height) / 12, 1e-6);
+  const weaveOpts = {
+    originX: bounds.minX,
+    originY: bounds.minY
+  };
+  if (options.swapColors !== void 0) weaveOpts.swapColors = options.swapColors;
+  if (options.cellFraction !== void 0) {
+    weaveOpts.cellFraction = options.cellFraction;
+  }
+  if (options.extendSingletonsToEdge !== void 0) {
+    weaveOpts.extendSingletonsToEdge = options.extendSingletonsToEdge;
+  }
+  const raw = weaveSegments(
+    width,
+    height,
+    cellSize,
+    options.A ?? 1,
+    options.B ?? 1,
+    options.C ?? 1,
+    weaveOpts
+  );
+  return clipSegmentsToPath(raw, path2);
+}
+function stochastic(path2, options = {}) {
+  if (!path2.closed || !path2.rings[0]) {
+    throw new Error("hatch.stochastic requires a closed path");
+  }
+  const bounds = pathBounds(path2);
+  const width = Math.max(bounds.maxX - bounds.minX, 1e-9);
+  const height = Math.max(bounds.maxY - bounds.minY, 1e-9);
+  const count = options.count ?? 40;
+  const minLength = options.length ?? options.minLength ?? 1;
+  const maxLength = options.length ?? options.maxLength ?? Math.min(width, height);
+  const raw = stochasticSegments(
+    width,
+    height,
+    count,
+    minLength,
+    maxLength,
+    options.seed ?? 1,
+    bounds.minX,
+    bounds.minY
+  );
+  return clipSegmentsToPath(raw, path2);
+}
+function perpendicular(path2, options = {}) {
+  if (!path2.rings[0]) {
+    throw new Error("hatch.perpendicular requires a path with at least one ring");
+  }
+  const spacing = Math.max(options.spacing ?? 0.15, 1e-9);
+  const length = options.length ?? 0.2;
+  return perpendicularPathSegments(
+    path2,
+    spacing,
+    length,
+    options.startOffset ?? 0
+  );
+}
+function concentric(path2, options = {}) {
+  if (!path2.closed || !path2.rings[0]) {
+    throw new Error("hatch.concentric requires a closed path");
+  }
+  const spacing = Math.max(options.spacing ?? 0.15, 1e-9);
+  const bounds = pathBounds(path2);
+  const diag = Math.hypot(bounds.maxX - bounds.minX, bounds.maxY - bounds.minY);
+  const maxCount = options.count ?? Math.max(1, Math.floor(diag / (2 * spacing)));
+  const out = [];
+  for (let i = 1; i <= maxCount; i++) {
+    const shell = buffer(path2, -spacing * i);
+    if (shell.paths.length === 0) break;
+    for (const p of shell.paths) {
+      out.push(
+        path(
+          p.rings.map((r) => r.map((v) => ({ x: v.x, y: v.y }))),
+          true
+        )
+      );
+    }
+  }
+  return out;
+}
 function hatchLineCount(bounds, spacing, angle) {
   const nx = Math.cos(angle + Math.PI / 2);
   const ny = Math.sin(angle + Math.PI / 2);
@@ -245,9 +652,13 @@ function pathBounds(path2) {
 }
 var hatch = {
   parallel,
-  cross
+  cross,
+  weave,
+  stochastic,
+  perpendicular,
+  concentric
 };
 
-export { cross, hatch, parallel };
+export { concentric, cross, hatch, parallel, perpendicular, stochastic, weave };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map