@overtone-art/canvas-editor-core 0.2.8 → 0.3.1

package/dist/index.mjs

@@ -6,11 +6,12 @@ import {
   exportIsolatedPNG,
   exportMockup,
   exportPNG,
+  exportPrintArea,
   exportSVG
-} from "./chunk-ORZZ6MGQ.mjs";
+} from "./chunk-MCBRZQ4M.mjs";
 
 // src/editor.ts
-import { Canvas, FabricImage as FabricImage3, Group, Textbox, filters, loadSVGFromString, util as util3 } from "fabric";
+import { Canvas, FabricImage as FabricImage4, Group, Textbox, filters, loadSVGFromString, util as util3 } from "fabric";
 
 // src/events.ts
 var EventEmitter = class {
@@ -230,6 +231,38 @@ var LayerManager = class {
     this.emitChanged();
     this.onPropertyChanged?.();
   }
+  /**
+   * Patch a layer's host metadata. A key whose value is `undefined` is removed.
+   *
+   * `meta` is part of `LayerData` and is serialized, so a host that assigns
+   * `layer.meta.x` directly gets neither of the two things every other setter
+   * here provides: `layers:changed` (so `useLayers()` keeps returning the old
+   * meta) and the history checkpoint (so an undo silently reverts the write —
+   * the state IS versioned, it was just never committed at the moment it
+   * changed). Going through this method is what makes metadata behave like
+   * every other layer property.
+   */
+  setMeta(id, patch) {
+    const layer = this.get(id);
+    if (!layer) return;
+    const next = { ...layer.meta };
+    let changed = false;
+    for (const [key, value] of Object.entries(patch)) {
+      if (value === void 0) {
+        if (key in next) {
+          delete next[key];
+          changed = true;
+        }
+        continue;
+      }
+      if (next[key] !== value) changed = true;
+      next[key] = value;
+    }
+    if (!changed) return;
+    layer.meta = next;
+    this.emitChanged();
+    this.onPropertyChanged?.();
+  }
   clear() {
     for (const layer of this.layers) {
       this.canvas.remove(layer.fabricObject);
@@ -1088,6 +1121,521 @@ function mod2(n) {
   return (n % 2 + 2) % 2;
 }
 
+// src/text-curve.ts
+import { Path } from "fabric";
+var DEFAULT_TEXT_CURVE = { arc: 0, wave: 0 };
+var MIN_ARC = 0.5;
+var FULL_CIRCLE_ARC = 99.5;
+var MIN_SWEEP = 0.12;
+var WAVE_PERIOD_EM = 4.1;
+var WAVE_AMPLITUDE_EM = 0.9;
+var WAVE_STEP = 6;
+var MEASURE_WIDTH = 1e5;
+var PATH_SLACK = 0.06;
+function isCurvable(object) {
+  return !!object && typeof object.text === "string";
+}
+function measureText(text) {
+  const authored = text.width;
+  try {
+    text.set({ width: MEASURE_WIDTH });
+    text.initDimensions?.();
+    return Math.max(1, text.calcTextWidth?.() ?? text.width ?? 1);
+  } finally {
+    if (authored !== void 0) text.set({ width: authored });
+    text.initDimensions?.();
+  }
+}
+function arcPathData(width, arc) {
+  const magnitude = Math.min(100, Math.abs(arc));
+  const direction = arc < 0 ? -1 : 1;
+  const full = magnitude >= FULL_CIRCLE_ARC;
+  const sweep = full ? Math.PI * 2 : Math.max(MIN_SWEEP, magnitude / 100 * Math.PI);
+  const radius = width / sweep;
+  const centerX = width / 2;
+  const point = (angle) => [
+    centerX + radius * Math.sin(angle),
+    direction * radius * (1 - Math.cos(angle))
+  ];
+  const sweepFlag = direction > 0 ? 1 : 0;
+  const format = ([x, y]) => `${round(x)} ${round(y)}`;
+  if (full) {
+    const start2 = point(-Math.PI);
+    const top = point(0);
+    return {
+      data: [
+        `M ${format(start2)}`,
+        `A ${round(radius)} ${round(radius)} 0 0 ${sweepFlag} ${format(top)}`,
+        `A ${round(radius)} ${round(radius)} 0 0 ${sweepFlag} ${format(start2)}`
+      ].join(" "),
+      length: width
+    };
+  }
+  const start = point(-sweep / 2);
+  const end = point(sweep / 2);
+  const largeArc = sweep > Math.PI ? 1 : 0;
+  return {
+    data: `M ${format(start)} A ${round(radius)} ${round(radius)} 0 ${largeArc} ${sweepFlag} ${format(end)}`,
+    // radius = width / sweep, so the arc is exactly `width` long.
+    length: width
+  };
+}
+function wavePathData(width, fontSize, wave) {
+  const amplitude = clamp(wave, 0, 100) / 100 * fontSize * WAVE_AMPLITUDE_EM;
+  const period = Math.max(1, fontSize * WAVE_PERIOD_EM);
+  const steps = Math.max(2, Math.ceil(width / WAVE_STEP));
+  const commands = [];
+  let length = 0;
+  let previous = null;
+  for (let index = 0; index <= steps; index++) {
+    const x = width * index / steps;
+    const y = amplitude * Math.sin(x / period * Math.PI * 2);
+    if (previous) length += Math.hypot(x - previous[0], y - previous[1]);
+    previous = [x, y];
+    commands.push(`${index === 0 ? "M" : "L"} ${round(x)} ${round(y)}`);
+  }
+  return { data: commands.join(" "), length };
+}
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function buildCurvePathData(config, width, fontSize) {
+  if (Math.abs(config.arc) >= MIN_ARC) return arcPathData(width, config.arc);
+  if (config.wave > 0) return wavePathData(width, fontSize, config.wave);
+  return null;
+}
+function normalize(config) {
+  const arc = clamp(config.arc ?? 0, -100, 100);
+  return { arc, wave: Math.abs(arc) >= MIN_ARC ? 0 : clamp(config.wave ?? 0, 0, 100) };
+}
+var TextCurveManager = class {
+  constructor(canvas, layers, history, events) {
+    this.canvas = canvas;
+    this.layers = layers;
+    this.history = history;
+    this.events = events;
+  }
+  canvas;
+  layers;
+  history;
+  events;
+  /** Curve parameters for a layer, or null when it is not curved text. */
+  get(layerId) {
+    const layer = this.layers.get(layerId);
+    if (!layer || !isCurvable(layer.fabricObject)) return null;
+    return layer.meta.curve ?? { ...DEFAULT_TEXT_CURVE };
+  }
+  isCurved(layerId) {
+    const curve = this.get(layerId);
+    return !!curve && (Math.abs(curve.arc) >= MIN_ARC || curve.wave > 0);
+  }
+  /** Apply (or update) the curve on a text layer. Zeroed config clears it. */
+  apply(layerId, config, save = true) {
+    const layer = this.layers.get(layerId);
+    if (!layer || !isCurvable(layer.fabricObject)) return false;
+    const next = normalize(config);
+    const text = layer.fabricObject;
+    const run = measureText(text);
+    const curve = buildCurvePathData(next, run * (1 + PATH_SLACK), text.fontSize);
+    if (!curve) {
+      this.detach(text, layer.meta.curveWidth);
+      delete layer.meta.curve;
+      delete layer.meta.curveWidth;
+    } else {
+      if (layer.meta.curveWidth === void 0) layer.meta.curveWidth = text.width ?? 0;
+      text.set({ width: Math.max(layer.meta.curveWidth, run + 2) });
+      text.set({
+        path: new Path(curve.data, { visible: false, objectCaching: false }),
+        pathAlign: "center",
+        pathSide: "left",
+        pathStartOffset: Math.max(0, (curve.length - run) / 2)
+      });
+      layer.meta.curve = next;
+    }
+    text.initDimensions?.();
+    text.setCoords();
+    text.dirty = true;
+    this.canvas.requestRenderAll();
+    this.events.emit("layer:modified", { layerId });
+    if (save) this.history.save();
+    return true;
+  }
+  /** Remove the curve, restoring the authored text box width. */
+  clear(layerId, save = true) {
+    return this.apply(layerId, DEFAULT_TEXT_CURVE, save);
+  }
+  /**
+   * Rebuild the path from the stored parameters. Text content, font family and
+   * font size all change the run's width, and the path is sized to that width —
+   * without this the curve keeps the geometry of the text it was created from.
+   */
+  refresh(layerId, save = false) {
+    const curve = this.layers.get(layerId)?.meta.curve;
+    if (!curve) return false;
+    return this.apply(layerId, curve, save);
+  }
+  /** Rebuild every curved layer — used after a state restore. */
+  refreshAll() {
+    for (const layer of this.layers.getAll()) {
+      if (layer.meta.curve) this.refresh(layer.id);
+    }
+  }
+  detach(text, authoredWidth) {
+    text.set({ path: null, pathStartOffset: 0 });
+    if (authoredWidth !== void 0 && authoredWidth > 0) text.set({ width: authoredWidth });
+  }
+};
+
+// src/mask-presets/manager.ts
+import { FabricImage as FabricImage2, Path as Path2 } from "fabric";
+
+// src/mask-presets/shapes.ts
+var SHAPE_MASK_IDS = [
+  "circle",
+  "square",
+  "triangle",
+  "star",
+  "heart",
+  "octagram",
+  "arch",
+  "zigzag"
+];
+function isShapeMaskId(value) {
+  return typeof value === "string" && SHAPE_MASK_IDS.includes(value);
+}
+function starPoints(points, outer, inner, start = -Math.PI / 2) {
+  const step = Math.PI / points;
+  const coordinates = [];
+  for (let index = 0; index < points * 2; index++) {
+    const radius = index % 2 === 0 ? outer : inner;
+    const angle = start + index * step;
+    const x = 50 + Math.cos(angle) * radius;
+    const y = 50 + Math.sin(angle) * radius;
+    coordinates.push(`${index === 0 ? "M" : "L"} ${round3(x)} ${round3(y)}`);
+  }
+  return `${coordinates.join(" ")} Z`;
+}
+function round3(value) {
+  return Math.round(value * 100) / 100;
+}
+var SHAPE_PATHS = {
+  circle: "M 96 50 A 46 46 0 1 1 4 50 A 46 46 0 1 1 96 50 Z",
+  square: "M 4 4 H 96 V 96 H 4 Z",
+  triangle: "M 50 4 L 96 96 L 4 96 Z",
+  star: starPoints(5, 46, 22),
+  heart: "M 50 96 C -8 55 12 4 50 28 C 88 4 108 55 50 96 Z",
+  octagram: starPoints(8, 46, 27),
+  arch: "M 4 96 V 50 A 46 46 0 0 1 96 50 V 96 Z",
+  zigzag: starPoints(16, 46, 39)
+};
+function shapeMaskPathData(id) {
+  return SHAPE_PATHS[id];
+}
+var SHAPE_MASK_BOX = 100;
+
+// src/mask-presets/textures.ts
+var TEXTURE_MASK_IDS = [
+  "vignette",
+  "halftone",
+  "spray",
+  "grunge",
+  "torn",
+  "band"
+];
+function isTextureMaskId(value) {
+  return typeof value === "string" && TEXTURE_MASK_IDS.includes(value);
+}
+var TEXTURE_MASK_SIZE = 320;
+var cache = /* @__PURE__ */ new Map();
+function seeded(seed) {
+  let state = seed;
+  return () => {
+    state = state * 16807 % 2147483647;
+    return (state - 1) / 2147483646;
+  };
+}
+function traceRoughEdge(context, random, jitter, inset) {
+  const size = TEXTURE_MASK_SIZE;
+  const corners = [
+    [inset, inset],
+    [size - inset, inset],
+    [size - inset, size - inset],
+    [inset, size - inset]
+  ];
+  context.beginPath();
+  for (let corner = 0; corner < corners.length; corner++) {
+    const [fromX, fromY] = corners[corner];
+    const [toX, toY] = corners[(corner + 1) % corners.length];
+    for (let step = 0; step <= 26; step++) {
+      const ratio = step / 26;
+      const x = fromX + (toX - fromX) * ratio + (random() - 0.5) * jitter;
+      const y = fromY + (toY - fromY) * ratio + (random() - 0.5) * jitter;
+      if (corner === 0 && step === 0) context.moveTo(x, y);
+      else context.lineTo(x, y);
+    }
+  }
+  context.closePath();
+  context.fill();
+}
+function paint(id, context) {
+  const size = TEXTURE_MASK_SIZE;
+  const center = size / 2;
+  context.fillStyle = "#ffffff";
+  switch (id) {
+    case "vignette": {
+      const gradient = context.createRadialGradient(
+        center,
+        center,
+        size * 0.18,
+        center,
+        center,
+        size * 0.52
+      );
+      gradient.addColorStop(0, "rgba(255,255,255,1)");
+      gradient.addColorStop(1, "rgba(255,255,255,0)");
+      context.fillStyle = gradient;
+      context.fillRect(0, 0, size, size);
+      return;
+    }
+    case "band": {
+      const gradient = context.createLinearGradient(0, 0, 0, size);
+      gradient.addColorStop(0, "rgba(255,255,255,0)");
+      gradient.addColorStop(0.25, "rgba(255,255,255,1)");
+      gradient.addColorStop(0.75, "rgba(255,255,255,1)");
+      gradient.addColorStop(1, "rgba(255,255,255,0)");
+      context.fillStyle = gradient;
+      context.fillRect(0, 0, size, size);
+      return;
+    }
+    case "halftone": {
+      const pitch = 16;
+      for (let y = pitch / 2; y < size; y += pitch) {
+        for (let x = pitch / 2; x < size; x += pitch) {
+          const distance = Math.hypot(x - center, y - center) / (size * 0.52);
+          const radius = Math.max(0, pitch / 2 * (1 - distance) * 1.15);
+          if (radius < 0.4) continue;
+          context.beginPath();
+          context.arc(x, y, radius, 0, Math.PI * 2);
+          context.fill();
+        }
+      }
+      return;
+    }
+    case "spray": {
+      const random = seeded(42);
+      const core = context.createRadialGradient(center, center, 10, center, center, size * 0.42);
+      core.addColorStop(0, "rgba(255,255,255,1)");
+      core.addColorStop(1, "rgba(255,255,255,0.85)");
+      context.fillStyle = core;
+      context.beginPath();
+      context.arc(center, center, size * 0.42, 0, Math.PI * 2);
+      context.fill();
+      context.fillStyle = "rgba(255,255,255,0.9)";
+      for (let dot = 0; dot < 900; dot++) {
+        const angle = random() * Math.PI * 2;
+        const distance = size * (0.3 + random() * 0.24);
+        const x = center + Math.cos(angle) * distance;
+        const y = center + Math.sin(angle) * distance;
+        context.globalAlpha = 1 - (distance / size - 0.3) / 0.24;
+        context.beginPath();
+        context.arc(x, y, random() * 2.4, 0, Math.PI * 2);
+        context.fill();
+      }
+      context.globalAlpha = 1;
+      return;
+    }
+    case "grunge": {
+      const random = seeded(7);
+      traceRoughEdge(context, random, 14, size * 0.06);
+      context.globalCompositeOperation = "destination-out";
+      for (let speckle = 0; speckle < 240; speckle++) {
+        const x = random() * size;
+        const y = random() * size;
+        const nearEdge = Math.min(x, y, size - x, size - y) < size * 0.12;
+        if (!nearEdge && random() >= 0.12) continue;
+        context.beginPath();
+        context.arc(x, y, random() * 6 + 1, 0, Math.PI * 2);
+        context.fill();
+      }
+      context.globalCompositeOperation = "source-over";
+      return;
+    }
+    case "torn": {
+      traceRoughEdge(context, seeded(99), 10, size * 0.08);
+      return;
+    }
+  }
+}
+function renderTextureMask(id) {
+  const cached = cache.get(id);
+  if (cached) return cached;
+  if (typeof document === "undefined") {
+    throw new Error("Texture masks require a DOM canvas");
+  }
+  const canvas = document.createElement("canvas");
+  canvas.width = TEXTURE_MASK_SIZE;
+  canvas.height = TEXTURE_MASK_SIZE;
+  const context = canvas.getContext("2d");
+  if (!context) throw new Error("Texture masks require a 2D canvas context");
+  paint(id, context);
+  cache.set(id, canvas);
+  return canvas;
+}
+function clearTextureMaskCache() {
+  cache.clear();
+}
+
+// src/mask-presets/manager.ts
+function isMaskPresetId(value) {
+  return isShapeMaskId(value) || isTextureMaskId(value);
+}
+var MaskPresetManager = class {
+  constructor(canvas, layers, history, events) {
+    this.canvas = canvas;
+    this.layers = layers;
+    this.history = history;
+    this.events = events;
+  }
+  canvas;
+  layers;
+  history;
+  events;
+  get(layerId) {
+    return this.layers.get(layerId)?.meta.maskPreset ?? null;
+  }
+  /** Clip the layer to `id`. Passing null (or an unknown id) clears the clip. */
+  apply(layerId, id, save = true) {
+    const layer = this.layers.get(layerId);
+    if (!layer) return false;
+    const object = layer.fabricObject;
+    if (id === null) {
+      if (!layer.meta.maskPreset) return false;
+      object.clipPath = void 0;
+      delete layer.meta.maskPreset;
+    } else {
+      if (!isMaskPresetId(id)) return false;
+      object.clipPath = this.buildClip(id, object);
+      layer.meta.maskPreset = id;
+    }
+    object.dirty = true;
+    object.setCoords();
+    this.canvas.requestRenderAll();
+    this.events.emit("layer:modified", { layerId });
+    if (save) this.history.save();
+    return true;
+  }
+  clear(layerId, save = true) {
+    return this.apply(layerId, null, save);
+  }
+  /**
+   * Re-fit the clip to the layer's current size. The clip is built for the
+   * object's dimensions at the time it was applied; editing text or replacing an
+   * image changes them, and a stale clip would crop the wrong region.
+   */
+  refresh(layerId, save = false) {
+    const id = this.get(layerId);
+    if (!id) return false;
+    return this.apply(layerId, id, save);
+  }
+  /** Re-fit every masked layer — used after a state restore. */
+  refreshAll() {
+    for (const layer of this.layers.getAll()) {
+      if (layer.meta.maskPreset) this.refresh(layer.id);
+    }
+  }
+  buildClip(id, object) {
+    const width = Math.max(1, object.width ?? 1);
+    const height = Math.max(1, object.height ?? 1);
+    const shared = {
+      originX: "center",
+      originY: "center",
+      left: 0,
+      top: 0,
+      objectCaching: false
+    };
+    if (isShapeMaskId(id)) {
+      return new Path2(shapeMaskPathData(id), {
+        ...shared,
+        scaleX: width / SHAPE_MASK_BOX,
+        scaleY: height / SHAPE_MASK_BOX
+      });
+    }
+    return new FabricImage2(renderTextureMask(id), {
+      ...shared,
+      scaleX: width / TEXTURE_MASK_SIZE,
+      scaleY: height / TEXTURE_MASK_SIZE
+    });
+  }
+};
+
+// src/shadow.ts
+import { Shadow } from "fabric";
+
+// src/utils/color.ts
+var CSS_COLOR = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\([\d.%+\-\s,/]+\)|[a-z]+)$/i;
+function isCssColor(value, allowEmpty = false) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (!trimmed) return allowEmpty;
+  return CSS_COLOR.test(trimmed);
+}
+
+// src/shadow.ts
+var DEFAULT_LAYER_SHADOW = {
+  enabled: false,
+  color: "#000000",
+  blur: 12,
+  offsetX: 6,
+  offsetY: 6
+};
+function readLayerShadow(object) {
+  const shadow = object.shadow;
+  if (!shadow || typeof shadow === "string") return { ...DEFAULT_LAYER_SHADOW };
+  return {
+    enabled: true,
+    color: typeof shadow.color === "string" ? shadow.color : DEFAULT_LAYER_SHADOW.color,
+    blur: shadow.blur ?? DEFAULT_LAYER_SHADOW.blur,
+    offsetX: shadow.offsetX ?? DEFAULT_LAYER_SHADOW.offsetX,
+    offsetY: shadow.offsetY ?? DEFAULT_LAYER_SHADOW.offsetY
+  };
+}
+function applyLayerShadow(object, config) {
+  const next = { ...readLayerShadow(object), ...config };
+  if (!next.enabled) {
+    object.set({ shadow: null });
+    return;
+  }
+  const color = isCssColor(next.color) ? next.color : DEFAULT_LAYER_SHADOW.color;
+  object.set({
+    shadow: new Shadow({
+      color,
+      blur: Math.max(0, next.blur),
+      offsetX: next.offsetX,
+      offsetY: next.offsetY
+    })
+  });
+}
+
+// src/transform.ts
+var SIDE_CONTROLS = ["ml", "mr", "mt", "mb"];
+function applyAspectLock(object, locked) {
+  for (const control of SIDE_CONTROLS) {
+    object.setControlVisible(control, !locked);
+  }
+}
+function resetTransform(object) {
+  object.set({
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    skewX: 0,
+    skewY: 0,
+    flipX: false,
+    flipY: false
+  });
+  object.setCoords();
+}
+
 // src/utils/units.ts
 var MM_PER_INCH = 25.4;
 var UnitConverter = class {
@@ -1137,17 +1685,6 @@ var UnitConverter = class {
 
 // src/serialization.ts
 import { util as util2 } from "fabric";
-
-// src/utils/color.ts
-var CSS_COLOR = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\([\d.%+\-\s,/]+\)|[a-z]+)$/i;
-function isCssColor(value, allowEmpty = false) {
-  if (typeof value !== "string") return false;
-  const trimmed = value.trim();
-  if (!trimmed) return allowEmpty;
-  return CSS_COLOR.test(trimmed);
-}
-
-// src/serialization.ts
 var VERSION = "2.0.0";
 function serializeEditor(editor) {
   return {
@@ -1226,6 +1763,7 @@ function restoreLayer(editor, serialized, fabricObject) {
   const layer = editor.layers.add(serialized.type, fabricObject, serialized.name, serialized.id);
   if (serialized.meta) {
     layer.meta = serialized.meta;
+    if (layer.meta.lockAspect) applyAspectLock(fabricObject, true);
   }
   if (!serialized.visible) {
     editor.layers.setVisibility(layer.id, false);
@@ -1553,7 +2091,7 @@ var ProjectManager = class {
 };
 
 // src/mask.ts
-import { FabricImage as FabricImage2 } from "fabric";
+import { FabricImage as FabricImage3 } from "fabric";
 var MaskRefinementError = class extends Error {
   constructor(code, message, cause) {
     super(message);
@@ -1585,7 +2123,7 @@ var MaskController = class {
       throw new Error("Mask dimensions must be positive integers");
     }
     const backing = this.makeCanvas(width, height);
-    const image = new FabricImage2(backing, {
+    const image = new FabricImage3(backing, {
       left: 0,
       top: 0,
       originX: "left",
@@ -1825,6 +2363,8 @@ var CanvasEditor = class {
   snapping;
   crop;
   patterns;
+  curves;
+  maskPresets;
   fonts;
   licensing;
   pages;
@@ -1876,6 +2416,8 @@ var CanvasEditor = class {
       this.events,
       config.patternSourceResolver
     );
+    this.curves = new TextCurveManager(this.canvas, this.layers, this.history, this.events);
+    this.maskPresets = new MaskPresetManager(this.canvas, this.layers, this.history, this.events);
     this.setupCanvasEvents();
     this.history.saveImmediate();
     this.pages = new ProjectManager(this);
@@ -1884,7 +2426,7 @@ var CanvasEditor = class {
   // ─── Layer Operations ────────────────────────────────
   async addImage(url, options) {
     try {
-      const img = await FabricImage3.fromURL(
+      const img = await FabricImage4.fromURL(
         url,
         {},
         { originX: "left", originY: "top", ...options }
@@ -1909,7 +2451,7 @@ var CanvasEditor = class {
     if (this.crop.activeLayerId() === layerId) this.crop.cancel();
     const previous = layer.fabricObject;
     try {
-      const replacement = await FabricImage3.fromURL(url, {}, { originX: "left", originY: "top" });
+      const replacement = await FabricImage4.fromURL(url, {}, { originX: "left", originY: "top" });
       replacement.set({
         left: previous.left,
         top: previous.top,
@@ -2148,7 +2690,7 @@ var CanvasEditor = class {
     const layer = this.layers.get(id);
     if (!layer) throw new Error(`Layer not found: ${id}`);
     try {
-      if (options.resolution === "source" && layer.fabricObject instanceof FabricImage3) {
+      if (options.resolution === "source" && layer.fabricObject instanceof FabricImage4) {
         const image = await layer.fabricObject.clone();
         image.set({
           left: 0,
@@ -2232,6 +2774,23 @@ var CanvasEditor = class {
   toDataURL(format = "png", multiplier = 1) {
     return this.withDesignBackground(() => exportDataURL(this.canvas, format, multiplier));
   }
+  /**
+   * Export the print file: the design cropped to the mockup's print area, on
+   * transparency. Without a print area this is the whole canvas, still
+   * transparent — a print file never carries the design background.
+   */
+  async toPrintFile(options = {}) {
+    await this.fonts.ready();
+    try {
+      const area = this.mockup?.printArea;
+      const blob = area ? await exportPrintArea(this.canvas, area, options) : await exportIsolatedPNG(this.canvas, this.canvas.getObjects(), options);
+      this.licensing.track(`export:print:${options.format ?? "png"}`);
+      return blob;
+    } catch (error) {
+      this.events.emit("error", { message: "Failed to export print file", error });
+      throw error;
+    }
+  }
   /** Export the current product-preview composite. Advanced warping is host-defined. */
   async toMockupImage(options = {}) {
     if (!this.mockup) throw new Error("No mockup is configured");
@@ -2403,7 +2962,7 @@ var CanvasEditor = class {
       return;
     }
     try {
-      const image = await FabricImage3.fromURL(
+      const image = await FabricImage4.fromURL(
         url,
         { crossOrigin: options.crossOrigin ?? null, signal: options.signal },
         { originX: "left", originY: "top" }
@@ -2578,14 +3137,89 @@ var CanvasEditor = class {
   clearPattern(layerId) {
     return this.patterns.disable(layerId);
   }
+  // ─── Text curve ─────────────────────────────────────
+  applyTextCurve(layerId, config) {
+    return this.curves.apply(layerId, config);
+  }
+  clearTextCurve(layerId) {
+    return this.curves.clear(layerId);
+  }
+  getTextCurve(layerId) {
+    return this.curves.get(layerId);
+  }
+  // ─── Mask presets ───────────────────────────────────
+  applyMaskPreset(layerId, id) {
+    return this.maskPresets.apply(layerId, id);
+  }
+  clearMaskPreset(layerId) {
+    return this.maskPresets.clear(layerId);
+  }
+  getMaskPreset(layerId) {
+    return this.maskPresets.get(layerId);
+  }
+  // ─── Layer transform ────────────────────────────────
+  /**
+   * Constrain a layer to its current proportions. Persisted on the layer so a
+   * reopened design still resizes the way it was set up to.
+   */
+  setLayerAspectLock(layerId, locked) {
+    const layer = this.layers.get(layerId);
+    if (!layer) return false;
+    applyAspectLock(layer.fabricObject, locked);
+    if (locked) layer.meta.lockAspect = true;
+    else delete layer.meta.lockAspect;
+    this.canvas.requestRenderAll();
+    this.events.emit("layer:modified", { layerId });
+    this.history.save();
+    return true;
+  }
+  getLayerAspectLock(layerId) {
+    return this.layers.get(layerId)?.meta.lockAspect === true;
+  }
+  /** Re-apply every stored aspect lock — control visibility is not serialized. */
+  restoreAspectLocks() {
+    for (const layer of this.layers.getAll()) {
+      if (layer.meta.lockAspect) applyAspectLock(layer.fabricObject, true);
+    }
+  }
+  /** Drop scale, rotation, skew and flips; the layer stays where it is. */
+  resetLayerTransform(layerId) {
+    const layer = this.layers.get(layerId);
+    if (!layer) return false;
+    resetTransform(layer.fabricObject);
+    this.canvas.requestRenderAll();
+    this.events.emit("layer:modified", { layerId });
+    this.history.save();
+    return true;
+  }
+  // ─── Shadow ─────────────────────────────────────────
+  setLayerShadow(layerId, config) {
+    const layer = this.layers.get(layerId);
+    if (!layer) return false;
+    applyLayerShadow(layer.fabricObject, config);
+    layer.fabricObject.dirty = true;
+    this.canvas.requestRenderAll();
+    this.events.emit("layer:modified", { layerId });
+    this.history.save();
+    return true;
+  }
+  getLayerShadow(layerId) {
+    const layer = this.layers.get(layerId);
+    return layer ? readLayerShadow(layer.fabricObject) : null;
+  }
   // ─── Mockup (preview-only) ──────────────────────────
-  setMockup(mockup) {
+  /**
+   * Show (or clear) the product preview. Pass `history: false` for preview-only
+   * changes such as swapping a colourway — those are not design edits and
+   * should not fill the undo stack.
+   */
+  setMockup(mockup, options = {}) {
     this.mockup = mockup;
     this.canvas.backgroundColor = mockup ? "" : this.designBackground;
     this.canvas.backgroundImage = mockup ? void 0 : this.designBackgroundImage ?? void 0;
     this.canvas.requestRenderAll();
     this.events.emit("mockup:changed", { mockup });
-    this.history.save();
+    if (options.history !== false) this.history.save();
   }
   clearMockup() {
     this.setMockup(null);
@@ -2696,7 +3330,9 @@ export {
   CANVAS_SIZE_PRESETS,
   CanvasEditor,
   CropController,
+  DEFAULT_LAYER_SHADOW,
   DEFAULT_PATTERN_CONFIG,
+  DEFAULT_TEXT_CURVE,
   EventEmitter,
   FontRegistry,
   HistoryManager,
@@ -2704,16 +3340,26 @@ export {
   LayerManager,
   LicenseManager,
   MaskController,
+  MaskPresetManager,
   MaskRefinementError,
   PatternManager,
   ProjectManager,
+  SHAPE_MASK_BOX,
+  SHAPE_MASK_IDS,
   SnapManager,
+  TEXTURE_MASK_IDS,
+  TEXTURE_MASK_SIZE,
+  TextCurveManager,
   UnitConverter,
+  applyAspectLock,
+  applyLayerShadow,
   applyPatternLocks,
+  buildCurvePathData,
   buildPatternDataURL,
   captureLocks,
   clamp,
   clearPatternImageCache,
+  clearTextureMaskCache,
   computeCoverPlacement,
   computePrintAreaClip,
   computeTilePositions,
@@ -2724,13 +3370,21 @@ export {
   exportDataURL,
   exportMockup,
   exportPNG,
+  exportPrintArea,
   exportSVG,
   generateId,
   isCssColor,
+  isMaskPresetId,
+  isShapeMaskId,
+  isTextureMaskId,
   loadPatternImage,
+  readLayerShadow,
+  renderTextureMask,
+  resetTransform,
   restoreLocks,
   round2,
   sanitizeSvg,
-  serializeEditor
+  serializeEditor,
+  shapeMaskPathData
 };
 //# sourceMappingURL=index.mjs.map