@pixerate/editor 0.38.0 → 0.40.0

package/dist/{chunk-ZCCU3VNI.js → chunk-3LHWTGHW.js}

@@ -675,14 +675,14 @@ function turnDeg(a, b, c) {
   if (!u || !v) return 0;
   return Math.acos(Math.min(1, Math.max(-1, dot(u, v)))) * 180 / Math.PI;
 }
-function findCorners(pts, closed, cornerAngle, span) {
+function findCorners(pts, closed, cornerAngle, span2) {
   const n = pts.length;
   const at = (i) => pts[closed ? (i % n + n) % n : i];
   const reach = (i, step) => {
     for (let k = 1; k < (closed ? n : Infinity); k++) {
       const j = i + step * k;
       if (!closed && (j < 0 || j >= n)) return k > 1 ? j - step : null;
-      if (dist(at(j), pts[i]) >= span) return j;
+      if (dist(at(j), pts[i]) >= span2) return j;
     }
     return null;
   };
@@ -704,7 +704,7 @@ function findCorners(pts, closed, cornerAngle, span) {
     let sharpest = true;
     for (let j = lo; j <= hi && sharpest; j++) {
       const k = closed ? (j % n + n) % n : j;
-      if (k === i || dist(pts[k], pts[i]) >= span) continue;
+      if (k === i || dist(pts[k], pts[i]) >= span2) continue;
       if (turns[k] > turns[i] || turns[k] === turns[i] && k < i) sharpest = false;
     }
     if (sharpest) corners.push(i);
@@ -742,9 +742,9 @@ function fitCubics(points, tolerance, options = {}) {
   const tol = Math.max(tolerance, 1e-6);
   const cornerAngle = options.cornerAngleDeg ?? 30;
   const n = pts.length;
-  const span = 4 * tol;
+  const span2 = 4 * tol;
   if (!closed || n < 3) {
-    const corners2 = [0, ...n > 2 ? findCorners(pts, false, cornerAngle, span) : [], n - 1];
+    const corners2 = [0, ...n > 2 ? findCorners(pts, false, cornerAngle, span2) : [], n - 1];
     const out2 = [];
     for (let k = 1; k < corners2.length; k++) {
       const run = pts.slice(corners2[k - 1], corners2[k] + 1);
@@ -753,7 +753,7 @@ function fitCubics(points, tolerance, options = {}) {
     if (closed && n === 2) out2.push(...fitCubicRun([pts[1], pts[0]], tol));
     return out2;
   }
-  const corners = findCorners(pts, true, cornerAngle, span);
+  const corners = findCorners(pts, true, cornerAngle, span2);
   if (corners.length === 0) {
     const ring = [...pts, pts[0]];
     const t = unit(sub(pts[1], pts[n - 1])) ?? [1, 0];
@@ -3651,8 +3651,8 @@ function deepPoint(rings) {
     }
     xs.sort((p, q) => p - q);
     for (let i = 0; i + 1 < xs.length; i += 2) {
-      const span = xs[i + 1] - xs[i];
-      if (!best || span > best.span) best = { span, p: [(xs[i] + xs[i + 1]) / 2, y] };
+      const span2 = xs[i + 1] - xs[i];
+      if (!best || span2 > best.span) best = { span: span2, p: [(xs[i] + xs[i + 1]) / 2, y] };
     }
   }
   return best?.p ?? null;
@@ -4274,6 +4274,152 @@ function closeGaps(vertices, edges, gap) {
     joined.add(best);
   }
 }
+function contourEnclosesArea(contour) {
+  const segs = closeContour(contour, true);
+  if (!segs.length) return false;
+  const b = boundsOf(segs);
+  const w = b.maxX - b.minX;
+  const h = b.maxY - b.minY;
+  return Math.abs(contourSignedArea(segs)) > 1e-9 * (w * w + h * h);
+}
+function nearestU(segs, p) {
+  let best = null;
+  segs.forEach((seg, k) => {
+    const n = segmentNearest(seg, p);
+    if (!best || n.distance < best.d) best = { u: k + n.t, d: n.distance };
+  });
+  return best;
+}
+function span(segs, u0, u1) {
+  const n = segs.length;
+  if (!n || !Number.isFinite(u0) || !Number.isFinite(u1)) return [];
+  const first = Math.max(0, Math.floor(u0));
+  const last = Math.min(Math.max(0, Math.ceil(u1)), first + 2 * n);
+  const out = [];
+  for (let k = first; k < last; k++) {
+    const t0 = Math.min(1, Math.max(0, u0 - k));
+    const t1 = Math.min(1, Math.max(0, u1 - k));
+    if (t1 - t0 > 1e-12) out.push(subSegment(segs[k % n], t0, t1));
+  }
+  return out;
+}
+function snapEnds2(segs, to, tol) {
+  if (!segs.length) return segs;
+  const out = segs.map((s) => [...s]);
+  const move = (seg, end, handle) => {
+    const q = to.find((t) => dist2(t, seg[end]) <= tol);
+    if (!q) return;
+    const d = [q[0] - seg[end][0], q[1] - seg[end][1]];
+    seg[end] = q;
+    if (seg.length === 4) seg[handle] = [seg[handle][0] + d[0], seg[handle][1] + d[1]];
+  };
+  move(out[0], 0, 1);
+  const last = out[out.length - 1];
+  move(last, last.length - 1, last.length - 2);
+  return out;
+}
+function cutOutPiece(path, piece, fillCloses, tol) {
+  const segs = piece.segments;
+  if (!segs.length) return null;
+  let mid = null;
+  let longest = -1;
+  let perimeter = 0;
+  for (const seg of segs) {
+    const len2 = segmentLength(seg);
+    perimeter += len2;
+    if (len2 > longest) {
+      longest = len2;
+      mid = segmentPoint(seg, 0.5);
+    }
+  }
+  if (!mid || perimeter <= tol) return null;
+  const a = segs[0][0];
+  const lastSeg = segs[segs.length - 1];
+  const b = lastSeg[lastSeg.length - 1];
+  const whole = !!piece.closed || dist2(a, b) <= tol;
+  const contours = pathToContours(path);
+  let found = null;
+  contours.forEach((c, index2) => {
+    if (!c.segments.length) return;
+    const closed2 = c.closed || fillCloses && contourEnclosesArea(c);
+    const ring2 = closeContour(c, closed2);
+    const n = nearestU(ring2, mid);
+    if (n && n.d <= tol && (!found || n.d < found.d)) found = { index: index2, ring: ring2, closed: closed2, um: n.u, d: n.d };
+  });
+  if (!found) return null;
+  const { index, ring, closed, um } = found;
+  const len = ring.length;
+  const real = closeContour(contours[index]).length;
+  const at = (p) => {
+    const n = nearestU(ring, p);
+    return n && n.d <= tol ? n.u : null;
+  };
+  let keep = [];
+  if (!whole) {
+    const ua = at(a);
+    const ub = at(b);
+    if (ua === null || ub === null) return null;
+    if (closed) {
+      const fwd = (from, to) => ((to - from) % len + len) % len;
+      const [start, end] = fwd(ua, um) <= fwd(ua, ub) ? [ub, ua] : [ua, ub];
+      const rest = fwd(start, end);
+      if (rest > 1e-9 && len - rest > 1e-9) {
+        const parts = real >= len ? [[0, 2 * len]] : [[0, real], [len, len + real]];
+        keep = parts.map(([lo, hi]) => [Math.max(start, lo), Math.min(start + rest, hi)]).filter(([x, y]) => y - x > 1e-9);
+      }
+    } else {
+      const lo = Math.min(ua, ub);
+      const hi = Math.max(ua, ub);
+      if (um < lo - 1e-9 || um > hi + 1e-9) return null;
+      keep = [[0, lo], [hi, len]].filter(([x, y]) => y - x > 1e-9);
+    }
+  }
+  const out = contours.slice(0, index);
+  for (const [u0, u1] of keep) {
+    const run = span(ring, u0, u1);
+    if (run.length) out.push({ segments: snapEnds2(run, [a, b], tol), closed: false });
+  }
+  out.push(...contours.slice(index + 1));
+  return contoursToPath(out);
+}
+
+// src/canvas/pathops/hatch.ts
+function hatchPath(path, options = {}) {
+  const out = [];
+  const b = bezierPathBounds(path);
+  if (!b || b.maxX - b.minX <= 0 || b.maxY - b.minY <= 0) return out;
+  const want = Math.max(options.gap ?? 4, 1e-3);
+  const s = Math.SQRT1_2;
+  const rot = (p) => [(p[0] + p[1]) * s, (p[1] - p[0]) * s];
+  const unrot = (x, y) => ({ x: (x - y) * s, y: (x + y) * s });
+  const edges = [];
+  for (const contour of pathToContours(path)) {
+    const pts = flattenChain(closeContour(contour, true), want * 0.1).map(rot);
+    for (let i = 0; i < pts.length; i++) {
+      const p = pts[i];
+      const q = pts[(i + 1) % pts.length];
+      if (p[0] !== q[0] || p[1] !== q[1]) edges.push([p, q]);
+    }
+  }
+  let y0 = Infinity;
+  let y1 = -Infinity;
+  for (const [p, q] of edges) {
+    y0 = Math.min(y0, p[1], q[1]);
+    y1 = Math.max(y1, p[1], q[1]);
+  }
+  if (!(y1 > y0)) return out;
+  const gap = Math.max(want, (y1 - y0) / Math.max(1, options.maxLines ?? 400), 1e-6);
+  const xs = [];
+  for (let y = Math.floor(y0 / gap) * gap + gap / 2; y < y1; y += gap) {
+    xs.length = 0;
+    for (const [p, q] of edges) if (p[1] <= y !== q[1] <= y) xs.push(p[0] + (y - p[1]) / (q[1] - p[1]) * (q[0] - p[0]));
+    xs.sort((m, n) => m - n);
+    for (let i = 0; i + 1 < xs.length; i += 2) {
+      out.push({ type: "M", ...unrot(xs[i], y) }, { type: "L", ...unrot(xs[i + 1], y) });
+    }
+  }
+  return out;
+}
 
 // src/canvas/pathops/pathfinder.ts
 var PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
@@ -4440,7 +4586,10 @@ export {
   offsetPath,
   interiorPoint,
   PlanarMap,
+  contourEnclosesArea,
+  cutOutPiece,
+  hatchPath,
   PATHFINDER_OPERATIONS,
   pathfinder
 };
-//# sourceMappingURL=chunk-ZCCU3VNI.js.map
+//# sourceMappingURL=chunk-3LHWTGHW.js.map