@pixerate/editor 0.119.0 → 0.121.0

package/dist/{chunk-TDQDMBUR.js → chunk-WAI6ATHC.js}

@@ -18,7 +18,7 @@ import {
   unionBounds,
   vectorGradientPoints,
   widthProfileAt
-} from "./chunk-CSHEI3YT.js";
+} from "./chunk-WORWH5K5.js";
 import {
   segmentLength,
   segmentParamAtLength,
@@ -750,4 +750,4 @@ export {
   interpolateVectorPaths,
   evaluateVectorPathKeyframes
 };
-//# sourceMappingURL=chunk-TDQDMBUR.js.map
+//# sourceMappingURL=chunk-WAI6ATHC.js.map

package/dist/{chunk-CSHEI3YT.js → chunk-WORWH5K5.js}

@@ -122,7 +122,7 @@ var VECTOR_TOOLS = [
 ];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
 var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
-var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope", "contour"];
+var VECTOR_EFFECT_TYPES = ["trim", "roundCorners", "puckerBloat", "twist", "zigzag", "wiggle", "offset", "merge", "repeater", "envelope", "contour", "blockShadow"];
 var VECTOR_MERGE_MODES = ["merge", "add", "subtract", "intersect", "exclude"];
 var VECTOR_FILTER_TYPES = ["dropShadow", "innerShadow", "outerGlow", "innerGlow", "layerBlur", "feather"];
 
@@ -2829,6 +2829,24 @@ function offsetPaths(paths, amount, join = "miter", miterLimit = 4, copies = 1,
     return out;
   });
 }
+function sweepPath(path, dx, dy, fillRule = "nonzero", tolerance = 0.25) {
+  if (!path.length) return [];
+  if (!Number.isFinite(dx) || !Number.isFinite(dy) || Math.hypot(dx, dy) < 1e-9) return path.slice();
+  const bands = [];
+  for (const contour of pathToContours(path)) {
+    const ring = flattenChain(closeContour(contour, true), Math.max(1e-3, tolerance));
+    for (let i = 0; i < ring.length; i++) {
+      let p = ring[i];
+      let q = ring[(i + 1) % ring.length];
+      const turn2 = (q[0] - p[0]) * dy - (q[1] - p[1]) * dx;
+      if (Math.abs(turn2) < 1e-9) continue;
+      if (turn2 < 0) [p, q] = [q, p];
+      bands.push({ type: "M", x: p[0], y: p[1] }, { type: "L", x: q[0], y: q[1] }, { type: "L", x: q[0] + dx, y: q[1] + dy }, { type: "L", x: p[0] + dx, y: p[1] + dy }, { type: "Z" });
+    }
+  }
+  const moved = transformBezierPath(path, [1, 0, 0, 1, dx, dy]);
+  return pathBoolean("union", [{ path, fillRule }, { path: moved, fillRule }, ...bands.length ? [{ path: bands, fillRule: "nonzero" }] : []]).path;
+}
 function twistPaths(paths, angle, center) {
   let rmax = 0;
   for (const p of paths) for (const c of p) if (c.type !== "Z") rmax = Math.max(rmax, Math.hypot(c.x - center.x, c.y - center.y));
@@ -6248,7 +6266,8 @@ var VECTOR_EFFECT_DEFAULTS = {
     composite: "below"
   },
   envelope: { style: "arc", bend: 50, horizontal: 0, vertical: 0, orientation: "horizontal", rows: 2, columns: 2, mesh: null },
-  contour: { direction: "inside", steps: 4, offset: 6, join: "round", miterLimit: 4, fillColor: "#ffffff", strokeColor: null, acceleration: 0 }
+  contour: { direction: "inside", steps: 4, offset: 6, join: "round", miterLimit: 4, fillColor: "#ffffff", strokeColor: null, acceleration: 0 },
+  blockShadow: { angle: 45, distance: 20, color: "#1e293b", opacity: 100, endOpacity: 100 }
 };
 var VECTOR_EFFECT_LABELS = {
   trim: "Trim Paths",
@@ -6261,7 +6280,8 @@ var VECTOR_EFFECT_LABELS = {
   merge: "Merge Paths",
   repeater: "Repeater",
   envelope: "Envelope",
-  contour: "Contour"
+  contour: "Contour",
+  blockShadow: "Block Shadow"
 };
 var VECTOR_EFFECT_PARAM_SPECS = {
   trim: [
@@ -6356,6 +6376,13 @@ var VECTOR_EFFECT_PARAM_SPECS = {
       ]
     }
   ],
+  blockShadow: [
+    { key: "angle", label: "Angle \xB0", kind: "number", min: -360, max: 360, step: 1, slider: true },
+    { key: "distance", label: "Distance", kind: "number", min: 0, max: 2e3, step: 1, slider: true },
+    { key: "color", label: "Colour", kind: "color" },
+    { key: "opacity", label: "Opacity %", kind: "number", min: 0, max: 100, step: 1, slider: true },
+    { key: "endOpacity", label: "End opacity %", kind: "number", min: 0, max: 100, step: 1, slider: true }
+  ],
   repeater: [
     { key: "copies", label: "Copies", kind: "number", min: 0, max: 50, step: 0.1, slider: true },
     { key: "offset", label: "Offset", kind: "number", min: -10, max: 10, step: 0.1, slider: true },
@@ -6636,6 +6663,42 @@ function contourShapes(shapes, c) {
   }
   return out;
 }
+function blockShadowShapes(shapes, b) {
+  const rad2 = b.angle * Math.PI / 180;
+  const u = { x: Math.cos(rad2), y: Math.sin(rad2) };
+  const distance = Math.max(0, b.distance);
+  const shadows = [];
+  for (const s of shapes) {
+    const color2 = b.color ?? (typeof s.source.fill === "string" && s.source.fill !== "none" ? s.source.fill : "#000000");
+    const path = sweepPath(s.path, u.x * distance, u.y * distance, s.source.fillRule === "evenodd" ? "evenodd" : "nonzero");
+    const box = bezierPathBounds(s.path);
+    if (!path.length || !box) continue;
+    let fill = color2;
+    const near3 = Math.min(100, Math.max(0, b.opacity));
+    const far = Math.min(100, Math.max(0, b.endOpacity));
+    const top = Math.max(near3, far);
+    if (near3 !== far && distance > 0) {
+      const along2 = [box.minX * u.x + box.minY * u.y, box.maxX * u.x + box.minY * u.y, box.minX * u.x + box.maxY * u.y, box.maxX * u.x + box.maxY * u.y];
+      const t0 = Math.min(...along2);
+      const t1 = Math.max(...along2) + distance;
+      const c = { x: (box.minX + box.maxX) / 2, y: (box.minY + box.maxY) / 2 };
+      const k = c.x * u.x + c.y * u.y;
+      fill = {
+        type: "linear",
+        units: "userSpaceOnUse",
+        start: { x: c.x + u.x * (t0 - k), y: c.y + u.y * (t0 - k) },
+        end: { x: c.x + u.x * (t1 - k), y: c.y + u.y * (t1 - k) },
+        stops: [
+          { offset: 0, color: color2, opacity: near3 / top },
+          { offset: 1, color: color2, opacity: far / top }
+        ]
+      };
+    }
+    const source = { ...s.source, fill, stroke: null, fills: void 0, strokes: void 0, fillRule: "nonzero" };
+    shadows.push({ source, path, opacity: s.opacity * top / 100, order: [0, ...s.order] });
+  }
+  return [...shadows, ...shapes.map((s) => ({ ...s, order: [1, ...s.order] }))];
+}
 function applyVectorEffects(shapes, effects) {
   let list = shapes.slice();
   for (const e of effects ?? []) {
@@ -6679,6 +6742,9 @@ function applyVectorEffects(shapes, effects) {
       case "contour":
         list = contourShapes(list, e.params);
         break;
+      case "blockShadow":
+        list = blockShadowShapes(list, e.params);
+        break;
       case "repeater": {
         const r = e.params;
         const copies = repeatPaths(
@@ -9712,6 +9778,7 @@ export {
   puckerBloatPaths,
   roundCornerPaths,
   offsetPaths,
+  sweepPath,
   twistPaths,
   zigzagPaths,
   wigglePaths,
@@ -9968,4 +10035,4 @@ export {
   lineSubpath,
   roundSubpaths
 };
-//# sourceMappingURL=chunk-CSHEI3YT.js.map
+//# sourceMappingURL=chunk-WORWH5K5.js.map