@snowcone-app/canvas 0.17.1 → 0.17.3

package/dist/EditorContext-CGkfmbgo.js

@@ -0,0 +1,1178 @@
+import { jsx as H } from "react/jsx-runtime";
+import { useContext as J, useSyncExternalStore as et, useCallback as a, createContext as q, useRef as fe, useState as b, useEffect as Ce, useMemo as M } from "react";
+import { y as Ue, N as tt, a9 as nt, aa as ot, G as Be, ab as rt, ac as it, ad as ct, ae as st, af as dt, c as _e, z as at, ag as lt, ah as ut, ai as mt, E as ft, L as He, I as At, g as pt, S as ht, aj as xt, ak as Ve } from "./FontAnalyzer-CLv7_msL.js";
+const ke = q(null), yt = () => () => {
+}, Ne = () => 0;
+function Zt() {
+  const t = J(ke), e = et(
+    t ? t.subscribe : yt,
+    t ? t.getVersion : Ne,
+    t ? t.getVersion : Ne
+  );
+  return a(
+    (r) => !!(t && r && t.getBoundLayer(r)),
+    // `version` is the reactivity key: a registry change must mint a new
+    // callback so memoized consumers re-evaluate.
+    [t, e]
+  );
+}
+class Et extends Error {
+  constructor(e, r, o = {}) {
+    super(`[Editor] ${e}: ${r}`), this.name = "EditorError", this.code = e, this.data = { code: e, ...o };
+  }
+}
+function $t(t) {
+  return t instanceof Error && t.name === "EditorError" && "code" in t;
+}
+function Gt() {
+  var t;
+  return typeof Ue < "u" && ((t = Ue.env) == null ? void 0 : t.NODE_ENV) !== "production";
+}
+const me = _e("useCommandHistory");
+function St(t, e, r, o) {
+  const i = fe(new tt(r)), n = J(ke), c = a(
+    (s, u) => {
+      const S = s == null ? void 0 : s.name;
+      if (!n || !S) return;
+      const h = n.getBoundLayer(S);
+      if (h)
+        throw new Et(
+          "E_BOUND_LAYER_MUTATION",
+          `cannot ${u} layer "${S}" — a mounted <${h.part} layer={design.layer("${S}")}> is bound to it. Unmount that field first, or keep the layer and set its text through the field / its binding instead.`,
+          { layer: S, part: h.part, operation: u, docSlug: "embed-mode" }
+        );
+    },
+    [n]
+  ), [x, V] = b({
+    canUndo: !1,
+    canRedo: !1,
+    // Per-artboard state for the active artboard
+    canUndoActiveArtboard: !1,
+    canRedoActiveArtboard: !1
+  }), d = a(() => {
+    const s = i.current, u = r.getActiveArtboardId();
+    V({
+      canUndo: s.canUndo(),
+      canRedo: s.canRedo(),
+      // Per-artboard state - only check active artboard's history
+      canUndoActiveArtboard: u ? s.canUndoArtboard(u) : !1,
+      canRedoActiveArtboard: u ? s.canRedoArtboard(u) : !1
+    });
+  }, [r]), N = a(
+    (s, u) => {
+      s && s.name !== u.name && c(s, "rename");
+      const S = new nt(
+        u.id,
+        s || null,
+        u,
+        (w) => {
+          e((B) => B.map((C) => C.id === w.id ? w : C));
+        }
+      ), h = r.getArtboardIdForElement(u.id);
+      if (h)
+        i.current.executeOnArtboard(h, S);
+      else {
+        const w = r.getActiveArtboardId();
+        w && i.current.executeOnArtboard(w, S);
+      }
+      d();
+    },
+    [e, r, d, c]
+  ), y = a(
+    (s, u, S, h) => {
+      const w = u || r.getActiveArtboardId();
+      if (!w) {
+        me.warn("No active artboard to add element to");
+        return;
+      }
+      const B = new ot(
+        s,
+        (C) => {
+          const D = C;
+          e((v) => {
+            if (h) {
+              const U = v.findIndex((P) => P.id === h);
+              if (U !== -1) {
+                const P = [...v];
+                return P.splice(U, 0, D), P;
+              }
+            }
+            if (S) {
+              const U = v.findIndex((P) => P.id === S);
+              if (U !== -1) {
+                const P = [...v];
+                return P.splice(U + 1, 0, D), P;
+              }
+              for (let P = 0; P < v.length; P++) {
+                const G = v[P];
+                if (G instanceof Be && G.children) {
+                  const X = G.children.findIndex((ee) => ee.id === S);
+                  if (X !== -1) {
+                    const ee = G.clone();
+                    ee.children.splice(X + 1, 0, D);
+                    const le = [...v];
+                    return le[P] = ee, le;
+                  }
+                }
+              }
+            }
+            return [...v, D];
+          }), r.addElementToArtboard(C.id, w);
+        },
+        (C) => {
+          e((D) => D.filter((v) => v.id !== C)), r.removeElementFromArtboard(C);
+        }
+      );
+      i.current.executeOnArtboard(w, B), d();
+    },
+    [e, r, d]
+  ), _ = a(
+    (s) => {
+      c(s, "delete");
+      const u = r.getArtboardIdForElement(s.id);
+      if (!u) {
+        me.warn("Element not found in any artboard");
+        return;
+      }
+      const S = new rt(
+        s,
+        (h) => {
+          e((w) => [...w, h]), r.addElementToArtboard(h.id, u);
+        },
+        (h) => {
+          e((w) => w.filter((B) => B.id !== h)), r.removeElementFromArtboard(h);
+        }
+      );
+      i.current.executeOnArtboard(u, S), d();
+    },
+    [e, r, d, c]
+  ), O = a(
+    (s) => {
+      const u = new it(s, r);
+      i.current.executeGlobal(u), d(), o == null || o();
+    },
+    [r, d, o]
+  ), R = a(
+    (s) => {
+      const u = new ct(s, r);
+      i.current.executeGlobal(u), d(), o == null || o();
+    },
+    [r, d, o]
+  ), p = a(
+    (s, u, S) => {
+      const h = new st(s, u, S, r);
+      i.current.executeGlobal(h), d(), o == null || o();
+    },
+    [r, d, o]
+  ), m = a(
+    (s) => {
+      if (s.length === 0)
+        return;
+      const u = r.getActiveArtboardId();
+      if (!u) {
+        me.warn("No active artboard for batch execution");
+        return;
+      }
+      const S = s.map((h) => new class extends Object {
+        execute() {
+          h.execute();
+        }
+        undo() {
+          h.undo();
+        }
+      }());
+      i.current.executeBatchOnArtboard(u, S), d();
+    },
+    [r, d]
+  ), F = a(() => {
+    i.current.undo() && (d(), o == null || o());
+  }, [d, o]), f = a(() => {
+    i.current.redo() && (d(), o == null || o());
+  }, [d, o]), E = a(() => {
+    const s = r.getActiveArtboardId();
+    s && i.current.undoArtboard(s) && (d(), o == null || o());
+  }, [r, d, o]), k = a(() => {
+    const s = r.getActiveArtboardId();
+    s && i.current.redoArtboard(s) && (d(), o == null || o());
+  }, [r, d, o]), z = a(() => {
+    i.current.clear(), d();
+  }, [d]), L = a(
+    (s) => {
+      i.current.clearArtboardHistory(s), d();
+    },
+    [d]
+  ), Q = fe(null);
+  Ce(() => {
+    const s = r.getActiveArtboardId();
+    s !== Q.current && (Q.current = s, d());
+  });
+  const ne = a(
+    (s, u, S) => {
+      const h = t.map((C) => C.id), w = r.getArtboardIdForElement(s);
+      if (!w) {
+        me.warn("Element not found in any artboard");
+        return;
+      }
+      const B = new dt(s, u, S, h, (C) => {
+        e((D) => {
+          const v = new Map(D.map((U) => [U.id, U]));
+          return C.map((U) => v.get(U)).filter(Boolean);
+        });
+      });
+      i.current.executeOnArtboard(w, B), d();
+    },
+    [t, e, r, d]
+  );
+  return {
+    // Element operations
+    executeElementUpdate: N,
+    executeAddElement: y,
+    executeRemoveElement: _,
+    executeReorderElement: ne,
+    // Batch operations
+    executeCommandBatch: m,
+    // Artboard operations
+    executeCreateArtboard: O,
+    executeDeleteArtboard: R,
+    executeUpdateArtboard: p,
+    // Undo/redo (smart - considers last operation and active artboard)
+    undo: F,
+    redo: f,
+    // Undo/redo for active artboard only (element operations)
+    undoActiveArtboard: E,
+    redoActiveArtboard: k,
+    clearHistory: z,
+    clearArtboardHistory: L,
+    // State (smart - considers last operation)
+    canUndo: x.canUndo,
+    canRedo: x.canRedo,
+    // State for active artboard only
+    canUndoActiveArtboard: x.canUndoActiveArtboard,
+    canRedoActiveArtboard: x.canRedoActiveArtboard,
+    historyManager: i.current
+  };
+}
+function te(t) {
+  return t && "fontSize" in t && "color" in t && "fontFamily" in t;
+}
+function bt(t, e) {
+  const [r, o] = b(32), [i, n] = b("#333333"), [c, x] = b("Arial"), [V, d] = b("center");
+  Ce(() => {
+    if (t && te(t)) {
+      const p = t.transformType === "circle" && "getEffectiveFontSize" in t ? Math.round(t.getEffectiveFontSize()) : Math.round(t.fontSize), m = t.color, F = t.fontFamily, f = t.textAlign;
+      o((E) => E !== p ? p : E), n((E) => E !== m ? m : E), x((E) => E !== F ? F : E), d((E) => E !== f ? f : E);
+    }
+  }, [t]);
+  const N = a(
+    (p) => {
+      if (!t || !te(t)) return;
+      const m = Math.max(lt, Math.min(ut, r + p));
+      o(m);
+      const F = t.clone();
+      F.transformType === "circle" && "setEffectiveFontSize" in F ? F.setEffectiveFontSize(m) : F.setFontSize(m), e(F);
+    },
+    [t, r, e]
+  ), y = a(
+    (p) => {
+      if (!t || !te(t)) return;
+      o(p);
+      const m = t.clone();
+      m.transformType === "circle" && "setEffectiveFontSize" in m ? m.setEffectiveFontSize(p) : m.setFontSize(p), e(m);
+    },
+    [t, e]
+  ), _ = a(
+    (p) => {
+      if (!t || !te(t)) return;
+      n(p);
+      const m = t.clone();
+      if (m.color = p, m.richText)
+        for (const F of m.richText.spans)
+          F.style.color = void 0;
+      e(m);
+    },
+    [t, e]
+  ), O = a(
+    (p) => {
+      if (!t || !te(t)) return;
+      const m = t.fontFamily;
+      m !== p && at.clearCache(m), x(p);
+      const F = t.clone();
+      F.fontFamily = p, e(F);
+    },
+    [t, e]
+  ), R = a(
+    (p) => {
+      if (!t || !te(t)) return;
+      d(p);
+      const m = t.clone();
+      m.textAlign = p, e(m);
+    },
+    [t, e]
+  );
+  return {
+    // State
+    fontSize: r,
+    fontColor: i,
+    fontFamily: c,
+    textAlign: V,
+    // State setters (for UI only)
+    setFontSize: o,
+    setFontColor: n,
+    setFontFamily: x,
+    setTextAlign: d,
+    // Update functions (update element + UI)
+    updateFontSize: N,
+    setFontSizeValue: y,
+    updateFontColor: _,
+    updateFontFamily: O,
+    updateTextAlign: R
+  };
+}
+const We = "data-preserve-selection";
+function It(t) {
+  if (!(t instanceof Element))
+    return !1;
+  let e = t;
+  const r = [];
+  for (; e; ) {
+    const o = e.id ? `#${e.id}` : "", i = e.className ? `.${String(e.className).split(" ").slice(0, 2).join(".")}` : "";
+    if (r.push(`${e.tagName.toLowerCase()}${o}${i}`), e.hasAttribute(We))
+      return !0;
+    const n = e.getAttribute("role");
+    if (n === "dialog" || n === "alertdialog" || n === "menu" || n === "listbox")
+      return !0;
+    const c = e.getAttribute("data-slot");
+    if (c && (c.includes("popover") || c.includes("dialog")) || e.hasAttribute("data-radix-popper-content-wrapper"))
+      return !0;
+    e = e.parentElement;
+  }
+  return !1;
+}
+const Xt = {
+  [We]: ""
+};
+function wt(t) {
+  const e = Ze(t);
+  return e !== null && e < 0.5;
+}
+function Yt(t) {
+  const e = Ze(t);
+  return e !== null && e >= 0.5;
+}
+function Ze(t) {
+  const e = t.trim();
+  if (e.startsWith("#")) {
+    const o = e.slice(1);
+    let i, n, c;
+    if (o.length === 3)
+      i = parseInt(o[0] + o[0], 16), n = parseInt(o[1] + o[1], 16), c = parseInt(o[2] + o[2], 16);
+    else if (o.length === 6)
+      i = parseInt(o.slice(0, 2), 16), n = parseInt(o.slice(2, 4), 16), c = parseInt(o.slice(4, 6), 16);
+    else return null;
+    return Number.isNaN(i) || Number.isNaN(n) || Number.isNaN(c) ? null : De(i, n, c);
+  }
+  const r = e.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+  return r ? De(Number(r[1]), Number(r[2]), Number(r[3])) : null;
+}
+function De(t, e, r) {
+  const o = (i) => {
+    const n = i / 255;
+    return n <= 0.03928 ? n / 12.92 : Math.pow((n + 0.055) / 1.055, 2.4);
+  };
+  return 0.2126 * o(t) + 0.7152 * o(e) + 0.0722 * o(r);
+}
+const Tt = "#333333", gt = "#f4f4f5";
+function Ft(t) {
+  return t && wt(t) ? gt : Tt;
+}
+const $e = q(null), Pt = 0.1, Rt = 4, Le = 0.25, Ct = ({
+  children: t,
+  artboardManager: e,
+  canvasRef: r,
+  viewPadding: o = 0.9
+}) => {
+  const [i, n] = b(1), [c, x] = b({ x: 0, y: 0 }), [V, d] = b(!1), [N, y] = b(1), _ = a(() => {
+    y(1), x({ x: 0, y: 0 });
+  }, []), O = a(() => {
+    n((f) => Math.min(f + Le, Rt));
+  }, []), R = a(() => {
+    n((f) => Math.max(f - Le, Pt));
+  }, []), p = a(() => {
+    const f = e.getActiveArtboard();
+    if (!f || !r.current) return;
+    let E = r.current.parentElement, k = 0, z = 0;
+    for (; E && (k = E.clientWidth, z = E.clientHeight, !(k > 0 && z > 0)); )
+      E = E.parentElement;
+    if (!k || !z) return;
+    const L = Math.min(
+      k * o / f.width,
+      z * o / f.height,
+      1
+      // Never zoom in beyond 100%
+    );
+    n(L), x({ x: 0, y: 0 });
+  }, [e, r, o]), m = a(() => {
+    n(1), x({ x: 0, y: 0 });
+  }, []), F = M(
+    () => ({
+      zoom: i,
+      panOffset: c,
+      isPanning: V,
+      zoomIn: O,
+      zoomOut: R,
+      zoomToFit: p,
+      resetView: m,
+      setZoom: n,
+      setPanOffset: x,
+      setIsPanning: d,
+      userZoom: N,
+      setUserZoom: y,
+      resetUserView: _
+    }),
+    [i, c, V, O, R, p, m, N, _]
+  );
+  return /* @__PURE__ */ H($e.Provider, { value: F, children: t });
+};
+function vt() {
+  const t = J($e);
+  if (!t)
+    throw new Error("useViewportContext must be used within a ViewportProvider (or EditorProvider)");
+  return t;
+}
+const Ge = q(null), zt = ({ children: t }) => {
+  const [e, r] = b(null), [o, i] = b([]), [n, c] = b(null), [x, V] = b(null), [d, N] = b(!1), y = a((R) => {
+    r(R);
+  }, []), _ = a((R) => {
+    c(R);
+  }, []), O = M(
+    () => ({
+      selectedId: e,
+      multiSelection: o,
+      activeChildElement: n,
+      hoveredElementId: x,
+      hideHandles: d,
+      setSelectedId: r,
+      setMultiSelection: i,
+      setHoveredElementId: V,
+      setHideHandles: N,
+      handleSelectionChange: y,
+      handleActiveChildChange: _
+    }),
+    [
+      e,
+      o,
+      n,
+      x,
+      d,
+      y,
+      _
+    ]
+  );
+  return /* @__PURE__ */ H(Ge.Provider, { value: O, children: t });
+};
+function Ot() {
+  const t = J(Ge);
+  if (!t)
+    throw new Error("useSelectionContext must be used within a SelectionProvider (or EditorProvider)");
+  return t;
+}
+const Xe = q(null), Ut = ({ children: t, value: e }) => {
+  const r = M(
+    () => ({
+      undo: e.undo,
+      redo: e.redo,
+      canUndo: e.canUndo,
+      canRedo: e.canRedo,
+      undoActiveArtboard: e.undoActiveArtboard,
+      redoActiveArtboard: e.redoActiveArtboard,
+      canUndoActiveArtboard: e.canUndoActiveArtboard,
+      canRedoActiveArtboard: e.canRedoActiveArtboard
+    }),
+    [
+      e.undo,
+      e.redo,
+      e.canUndo,
+      e.canRedo,
+      e.undoActiveArtboard,
+      e.redoActiveArtboard,
+      e.canUndoActiveArtboard,
+      e.canRedoActiveArtboard
+    ]
+  );
+  return /* @__PURE__ */ H(Xe.Provider, { value: r, children: t });
+};
+function jt() {
+  const t = J(Xe);
+  if (!t)
+    throw new Error("useHistoryContext must be used within a HistoryProvider (or EditorProvider)");
+  return t;
+}
+const Ye = q(null), Ht = ({ children: t }) => {
+  const [e, r] = b(null), [o, i] = b(!1), [n, c] = b(0), [x, V] = b(!1), [d, N] = b(!1), y = M(
+    () => ({
+      expandedPanelType: e,
+      setExpandedPanelType: r,
+      isToolbarMenuOpen: o,
+      setIsToolbarMenuOpen: i,
+      textSelectionVersion: n,
+      setTextSelectionVersion: c,
+      isCanvasReady: x,
+      setCanvasReady: V,
+      isRotating: d,
+      setIsRotating: N
+    }),
+    [e, o, n, x, d]
+  );
+  return /* @__PURE__ */ H(Ye.Provider, { value: y, children: t });
+};
+function Vt() {
+  const t = J(Ye);
+  if (!t)
+    throw new Error("useToolStateContext must be used within a ToolStateProvider (or EditorProvider)");
+  return t;
+}
+const je = q(null), Nt = ({ children: t, value: e }) => {
+  const r = M(
+    () => ({
+      elements: e.elements,
+      elementStore: e.elementStore,
+      artboards: e.artboards,
+      artboardManager: e.artboardManager,
+      artboardVersion: e.artboardVersion,
+      setElements: e.setElements,
+      refreshArtboards: e.refreshArtboards,
+      getElementById: e.getElementById,
+      handleAddElement: e.handleAddElement,
+      handleElementUpdate: e.handleElementUpdate,
+      handleLoadWorkspace: e.handleLoadWorkspace,
+      handleCopyElements: e.handleCopyElements,
+      handlePasteElements: e.handlePasteElements,
+      fontSize: e.fontSize,
+      fontColor: e.fontColor,
+      fontFamily: e.fontFamily,
+      textAlign: e.textAlign,
+      updateFontSize: e.updateFontSize,
+      setFontSizeValue: e.setFontSizeValue,
+      updateFontColor: e.updateFontColor,
+      updateFontFamily: e.updateFontFamily,
+      updateTextAlign: e.updateTextAlign,
+      canvasRef: e.canvasRef,
+      canvasEditorRef: e.canvasEditorRef
+    }),
+    [
+      e.elements,
+      e.elementStore,
+      e.artboards,
+      e.artboardManager,
+      e.artboardVersion,
+      e.setElements,
+      e.refreshArtboards,
+      e.getElementById,
+      e.handleAddElement,
+      e.handleElementUpdate,
+      e.handleLoadWorkspace,
+      e.handleCopyElements,
+      e.handlePasteElements,
+      e.fontSize,
+      e.fontColor,
+      e.fontFamily,
+      e.textAlign,
+      e.updateFontSize,
+      e.setFontSizeValue,
+      e.updateFontColor,
+      e.updateFontFamily,
+      e.updateTextAlign,
+      e.canvasRef,
+      e.canvasEditorRef
+    ]
+  );
+  return /* @__PURE__ */ H(je.Provider, { value: r, children: t });
+};
+function Jt() {
+  const t = J(je);
+  if (!t)
+    throw new Error("useElementsContext must be used within an ElementsProvider (or EditorProvider)");
+  return t;
+}
+const Je = q(null), Dt = ({ children: t, value: e }) => {
+  const r = M(
+    () => ({
+      executeElementUpdate: e.executeElementUpdate,
+      executeAddElement: e.executeAddElement,
+      executeRemoveElement: e.executeRemoveElement,
+      executeReorderElement: e.executeReorderElement,
+      executeCreateArtboard: e.executeCreateArtboard,
+      executeDeleteArtboard: e.executeDeleteArtboard,
+      executeUpdateArtboard: e.executeUpdateArtboard,
+      executeCommandBatch: e.executeCommandBatch,
+      undo: e.undo,
+      redo: e.redo,
+      canUndo: e.canUndo,
+      canRedo: e.canRedo,
+      undoActiveArtboard: e.undoActiveArtboard,
+      redoActiveArtboard: e.redoActiveArtboard,
+      canUndoActiveArtboard: e.canUndoActiveArtboard,
+      canRedoActiveArtboard: e.canRedoActiveArtboard,
+      historyManager: e.historyManager
+    }),
+    [
+      e.executeElementUpdate,
+      e.executeAddElement,
+      e.executeRemoveElement,
+      e.executeReorderElement,
+      e.executeCreateArtboard,
+      e.executeDeleteArtboard,
+      e.executeUpdateArtboard,
+      e.executeCommandBatch,
+      e.undo,
+      e.redo,
+      e.canUndo,
+      e.canRedo,
+      e.undoActiveArtboard,
+      e.redoActiveArtboard,
+      e.canUndoActiveArtboard,
+      e.canRedoActiveArtboard,
+      e.historyManager
+    ]
+  );
+  return /* @__PURE__ */ H(Je.Provider, { value: r, children: t });
+};
+function Kt() {
+  const t = J(Je);
+  if (!t)
+    throw new Error("useCommandContext must be used within a CommandProvider (or EditorProvider)");
+  return t;
+}
+const Lt = _e("EditorContext"), Ke = q(null), Bt = ({ children: t, artboardManager: e, canvasRef: r, canvasEditorRef: o }) => {
+  const i = vt(), n = Ot(), c = Vt(), [x, V] = b(
+    () => e.getAllArtboards()
+  ), [d, N] = b(0), [y, _] = b(
+    () => new He()
+  ), O = M(() => y.toArray(), [y]), R = a((l) => {
+    _((A) => {
+      const T = A.toArray(), g = typeof l == "function" ? l(T) : l;
+      return g === T ? A : He.fromArray(g);
+    });
+  }, []), p = a(
+    (l) => y.get(l),
+    [y]
+  ), [m, F] = b([]), f = n.selectedId ? y.get(n.selectedId) : void 0, E = a(() => {
+    V([...e.getAllArtboards()]), N((l) => l + 1);
+  }, [e]), {
+    historyManager: k,
+    executeElementUpdate: z,
+    executeAddElement: L,
+    executeRemoveElement: Q,
+    executeReorderElement: ne,
+    executeCommandBatch: s,
+    executeCreateArtboard: u,
+    executeDeleteArtboard: S,
+    executeUpdateArtboard: h,
+    undo: w,
+    redo: B,
+    canUndo: C,
+    canRedo: D,
+    undoActiveArtboard: v,
+    redoActiveArtboard: U,
+    canUndoActiveArtboard: P,
+    canRedoActiveArtboard: G
+  } = St(
+    O,
+    R,
+    e,
+    E
+  ), X = a(
+    (l) => {
+      const A = y.get(l.id);
+      z(A, l);
+    },
+    [y, z]
+  ), ee = a(
+    (l) => {
+      if (!f || !(f instanceof Be))
+        return;
+      const A = f.clone(), T = A.children.findIndex(
+        (g) => g.id === l.id
+      );
+      T >= 0 && (A.children[T] = l, X(A));
+    },
+    [f, X]
+  ), le = n.activeChildElement || f, Me = n.activeChildElement ? ee : X, {
+    fontSize: Ae,
+    fontColor: pe,
+    fontFamily: he,
+    textAlign: xe,
+    updateFontSize: ye,
+    setFontSizeValue: Ee,
+    updateFontColor: Se,
+    updateFontFamily: be,
+    updateTextAlign: Ie
+  } = bt(le, Me), we = a(
+    async (l, A) => {
+      var ve;
+      const T = e.getActiveArtboardId();
+      if (!T) {
+        alert("Please create or select an artboard first");
+        return;
+      }
+      const g = `element-${Date.now()}`, I = e.getActiveArtboard(), oe = I ? I.x + I.width / 2 : window.innerWidth / 2, re = I ? I.y + I.height / 2 : window.innerHeight / 2, W = ((ve = o.current) == null ? void 0 : ve.getZoom()) || i.zoom || 1;
+      if (l === "image") {
+        const ae = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==", K = 200 / W, Y = A == null ? void 0 : A.src, $ = new At({
+          id: g,
+          x: oe,
+          y: re,
+          // Defer loading `src` until after the element is in the store so a
+          // synchronously-cached image can't fire onLoadCallback too early.
+          imageUrl: Y ? "" : ae,
+          transformData: {
+            type: "image",
+            width: K,
+            height: K,
+            cropX: 0,
+            cropY: 0,
+            cropWidth: 1,
+            cropHeight: 1,
+            flipHorizontal: !1,
+            flipVertical: !1,
+            borderRadius: 0
+          }
+        });
+        Y && ($.imageLoaded = !1, $.imageElement = null, $.isCropping = !1, $.imageUrl = Y, $.preserveDimensions = !1, $.onLoadCallback = (j) => {
+          const ze = j.transformData.width, Oe = j.transformData.height, Re = Math.min(K / ze, K / Oe, 1);
+          Re < 1 && (j.transformData.width = ze * Re, j.transformData.height = Oe * Re), j.transformData.cropX = 0, j.transformData.cropY = 0, j.transformData.cropWidth = 1, j.transformData.cropHeight = 1, z($, j);
+        }), L($, T), n.setSelectedId($.id), Y && $.loadImage(Y);
+        return;
+      }
+      let ie;
+      const Z = {
+        text: "custom",
+        circle: "circle",
+        wave: "wave",
+        arch: "arch",
+        shape: "shape"
+      }[l] || "custom", se = pt(Z);
+      if (!se || !se.Component)
+        return;
+      const de = e.getActiveArtboard(), Qe = de ? Math.min(de.width, de.height) * 0.1 : 80, Pe = de ? de.width * 0.5 : 300;
+      if (l === "shape") {
+        const ae = (A == null ? void 0 : A.shapeType) ?? "rectangle";
+        let K = 200 / W, Y = 200 / W;
+        ae === "ellipse" ? (K = 150 / W, Y = 250 / W) : ae === "line" && (K = 300 / W, Y = 8 / W), ie = new ht({
+          id: g,
+          x: oe,
+          y: re,
+          transformData: {
+            type: "shape",
+            shapeType: ae,
+            width: K,
+            height: Y,
+            fillColor: "#3b82f6",
+            fillOpacity: 1
+          }
+        });
+      } else
+        ie = new se.Component({
+          id: g,
+          text: "New Text",
+          x: oe,
+          y: re,
+          fontSize: Qe,
+          fontFamily: "Poppins",
+          color: Ft(I == null ? void 0 : I.backgroundColor),
+          transformData: Z === "arch" ? {
+            type: "arch",
+            width: Pe,
+            archHeight: xt.archHeight
+          } : Z === "wave" ? {
+            type: "wave",
+            width: Pe,
+            amplitude: Ve.amplitude,
+            frequency: Ve.frequency
+          } : Z === "circle" ? {
+            type: "circle",
+            radius: Pe / 2
+          } : void 0
+        });
+      e.addElementToArtboard(g, T), L(
+        ie,
+        T,
+        n.selectedId || void 0
+      ), n.setSelectedId(g);
+    },
+    [e, L, z, n, i.zoom, o]
+  ), Te = a(() => {
+    const l = [];
+    if (n.multiSelection.length > 0) {
+      const A = O.filter(
+        (T) => n.multiSelection.includes(T.id)
+      );
+      l.push(...A);
+    } else f && l.push(f);
+    if (l.length > 0) {
+      const A = l.map((T) => T.clone());
+      F(A);
+    }
+  }, [f, n.multiSelection, O]), ge = a(() => {
+    if (m.length === 0) return;
+    const l = [], A = 30, T = 30;
+    m.forEach((g) => {
+      const I = y.get(g.id), oe = I ? I.x : g.x, re = I ? I.y : g.y, W = g.toJSON();
+      delete W.id;
+      const ie = g.constructor, ce = new ie(W);
+      ce.x = oe + A, ce.y = re + T;
+      let Z = null;
+      if (I && (Z = e.getArtboardIdForElement(
+        I.id
+      )), Z || (Z = e.getActiveArtboardId()), !Z) {
+        Lt.warn("[handlePasteElements] No artboard found for pasting");
+        return;
+      }
+      const se = I ? I.id : void 0;
+      L(ce, Z, se), l.push(ce.id);
+    }), l.length === 1 ? n.handleSelectionChange(l[0]) : l.length > 1 && n.setMultiSelection(l);
+  }, [
+    m,
+    y,
+    e,
+    L,
+    n
+  ]), ue = a(() => {
+    if (c.expandedPanelType === "crop" && (f == null ? void 0 : f.transformType) === "image") {
+      const l = f;
+      if (l.isCropping) {
+        const A = l.clone();
+        A.exitCropMode(), z(l, A);
+      }
+    }
+    c.setExpandedPanelType(null);
+  }, [
+    c.expandedPanelType,
+    c.setExpandedPanelType,
+    f,
+    z
+  ]);
+  Ce(() => {
+    const l = (A) => {
+      const T = A.target;
+      if (T.tagName === "CANVAS" || It(T))
+        return;
+      const I = document.activeElement;
+      if (I != null && I.hasAttribute("data-preserve-selection")) {
+        I.blur();
+        return;
+      }
+      if (c.expandedPanelType !== null) {
+        ue();
+        return;
+      }
+      n.setSelectedId(null), n.setMultiSelection([]);
+    };
+    return document.addEventListener("pointerdown", l), () => document.removeEventListener("pointerdown", l);
+  }, [c.expandedPanelType, ue, n]);
+  const Fe = a(
+    (l, A, T) => {
+      e.clear(), l.forEach((g) => {
+        e.createArtboard(g.toJSON());
+      }), T && e.setActiveArtboard(T), V([...e.getAllArtboards()]), N((g) => g + 1), R(A), n.setSelectedId(null);
+    },
+    [e, n, R]
+  ), qe = M(() => ({
+    // From ViewportContext
+    zoom: i.zoom,
+    panOffset: i.panOffset,
+    isPanning: i.isPanning,
+    zoomIn: i.zoomIn,
+    zoomOut: i.zoomOut,
+    zoomToFit: i.zoomToFit,
+    resetView: i.resetView,
+    setZoom: i.setZoom,
+    setPanOffset: i.setPanOffset,
+    setIsPanning: i.setIsPanning,
+    // From SelectionContext
+    selectedId: n.selectedId,
+    multiSelection: n.multiSelection,
+    activeChildElement: n.activeChildElement,
+    hoveredElementId: n.hoveredElementId,
+    hideHandles: n.hideHandles,
+    setSelectedId: n.setSelectedId,
+    setMultiSelection: n.setMultiSelection,
+    setHoveredElementId: n.setHoveredElementId,
+    setHideHandles: n.setHideHandles,
+    handleSelectionChange: n.handleSelectionChange,
+    handleActiveChildChange: n.handleActiveChildChange,
+    // From ToolStateContext
+    expandedPanelType: c.expandedPanelType,
+    setExpandedPanelType: c.setExpandedPanelType,
+    isToolbarMenuOpen: c.isToolbarMenuOpen,
+    setIsToolbarMenuOpen: c.setIsToolbarMenuOpen,
+    textSelectionVersion: c.textSelectionVersion,
+    setTextSelectionVersion: c.setTextSelectionVersion,
+    isCanvasReady: c.isCanvasReady,
+    setCanvasReady: c.setCanvasReady,
+    isRotating: c.isRotating,
+    setIsRotating: c.setIsRotating,
+    // Cross-context handler
+    clearExpandedPanel: ue,
+    // Core state (element/artboard domain)
+    artboardManager: e,
+    artboards: x,
+    elements: O,
+    elementStore: y,
+    getElementById: p,
+    // Derived state (cross-context)
+    selectedElement: f,
+    // Refs
+    canvasRef: r,
+    canvasEditorRef: o,
+    // Element setters
+    setElements: R,
+    // Artboard version counter
+    artboardVersion: d,
+    // Handlers
+    refreshArtboards: E,
+    handleElementUpdate: X,
+    handleAddElement: we,
+    handleLoadWorkspace: Fe,
+    handleCopyElements: Te,
+    handlePasteElements: ge,
+    // Command history (undo/redo actions + execute functions)
+    historyManager: k,
+    executeElementUpdate: z,
+    executeAddElement: L,
+    executeRemoveElement: Q,
+    executeReorderElement: ne,
+    executeCommandBatch: s,
+    executeCreateArtboard: u,
+    executeDeleteArtboard: S,
+    executeUpdateArtboard: h,
+    undo: w,
+    redo: B,
+    canUndo: C,
+    canRedo: D,
+    undoActiveArtboard: v,
+    redoActiveArtboard: U,
+    canUndoActiveArtboard: P,
+    canRedoActiveArtboard: G,
+    // Element properties
+    fontSize: Ae,
+    fontColor: pe,
+    fontFamily: he,
+    textAlign: xe,
+    updateFontSize: ye,
+    setFontSizeValue: Ee,
+    updateFontColor: Se,
+    updateFontFamily: be,
+    updateTextAlign: Ie
+  }), [
+    // Viewport
+    i.zoom,
+    i.panOffset,
+    i.isPanning,
+    i.zoomIn,
+    i.zoomOut,
+    i.zoomToFit,
+    i.resetView,
+    i.setZoom,
+    i.setPanOffset,
+    i.setIsPanning,
+    // Selection
+    n.selectedId,
+    n.multiSelection,
+    n.activeChildElement,
+    n.hoveredElementId,
+    n.hideHandles,
+    n.setSelectedId,
+    n.setMultiSelection,
+    n.setHoveredElementId,
+    n.setHideHandles,
+    n.handleSelectionChange,
+    n.handleActiveChildChange,
+    // Tool state
+    c.expandedPanelType,
+    c.setExpandedPanelType,
+    c.isToolbarMenuOpen,
+    c.setIsToolbarMenuOpen,
+    c.textSelectionVersion,
+    c.setTextSelectionVersion,
+    c.isCanvasReady,
+    c.setCanvasReady,
+    c.isRotating,
+    c.setIsRotating,
+    ue,
+    // Element/artboard domain
+    e,
+    x,
+    O,
+    y,
+    p,
+    f,
+    r,
+    o,
+    R,
+    d,
+    E,
+    X,
+    we,
+    Fe,
+    Te,
+    ge,
+    // Command history
+    k,
+    z,
+    L,
+    Q,
+    ne,
+    s,
+    u,
+    S,
+    h,
+    w,
+    B,
+    C,
+    D,
+    v,
+    U,
+    P,
+    G,
+    // Element properties
+    Ae,
+    pe,
+    he,
+    xe,
+    ye,
+    Ee,
+    Se,
+    be,
+    Ie
+  ]);
+  return /* @__PURE__ */ H(
+    Ut,
+    {
+      value: {
+        undo: w,
+        redo: B,
+        canUndo: C,
+        canRedo: D,
+        undoActiveArtboard: v,
+        redoActiveArtboard: U,
+        canUndoActiveArtboard: P,
+        canRedoActiveArtboard: G
+      },
+      children: /* @__PURE__ */ H(
+        Nt,
+        {
+          value: {
+            elements: O,
+            elementStore: y,
+            artboards: x,
+            artboardManager: e,
+            artboardVersion: d,
+            setElements: R,
+            refreshArtboards: E,
+            getElementById: p,
+            handleAddElement: we,
+            handleElementUpdate: X,
+            handleLoadWorkspace: Fe,
+            handleCopyElements: Te,
+            handlePasteElements: ge,
+            fontSize: Ae,
+            fontColor: pe,
+            fontFamily: he,
+            textAlign: xe,
+            updateFontSize: ye,
+            setFontSizeValue: Ee,
+            updateFontColor: Se,
+            updateFontFamily: be,
+            updateTextAlign: Ie,
+            canvasRef: r,
+            canvasEditorRef: o
+          },
+          children: /* @__PURE__ */ H(
+            Dt,
+            {
+              value: {
+                executeElementUpdate: z,
+                executeAddElement: L,
+                executeRemoveElement: Q,
+                executeReorderElement: ne,
+                executeCommandBatch: s,
+                executeCreateArtboard: u,
+                executeDeleteArtboard: S,
+                executeUpdateArtboard: h,
+                undo: w,
+                redo: B,
+                canUndo: C,
+                canRedo: D,
+                undoActiveArtboard: v,
+                redoActiveArtboard: U,
+                canUndoActiveArtboard: P,
+                canRedoActiveArtboard: G,
+                historyManager: k
+              },
+              children: /* @__PURE__ */ H(Ke.Provider, { value: qe, children: t })
+            }
+          )
+        }
+      )
+    }
+  );
+}, Mt = ({
+  children: t,
+  initialArtboardConfig: e = {},
+  viewPadding: r = 0.9
+}) => {
+  const [o] = b(() => {
+    const c = new ft(), x = {
+      name: e.name || "Artboard 1",
+      x: e.x ?? 0,
+      y: e.y ?? 0,
+      width: e.width ?? 1e3,
+      height: e.height ?? 1e3,
+      backgroundColor: e.backgroundColor || mt
+    };
+    return c.createArtboard(x), c;
+  }), i = fe(null), n = fe(null);
+  return /* @__PURE__ */ H(
+    Ct,
+    {
+      artboardManager: o,
+      canvasRef: i,
+      viewPadding: r,
+      children: /* @__PURE__ */ H(zt, { children: /* @__PURE__ */ H(Ht, { children: /* @__PURE__ */ H(
+        Bt,
+        {
+          artboardManager: o,
+          canvasRef: i,
+          canvasEditorRef: n,
+          children: t
+        }
+      ) }) })
+    }
+  );
+}, qt = () => {
+  const t = J(Ke);
+  if (!t)
+    throw new Error("useEditor must be used within EditorProvider");
+  return t;
+};
+export {
+  ke as B,
+  Mt as E,
+  We as P,
+  vt as a,
+  Kt as b,
+  Jt as c,
+  jt as d,
+  Ot as e,
+  Vt as f,
+  Et as g,
+  $t as h,
+  Gt as i,
+  Zt as j,
+  wt as k,
+  Yt as l,
+  Xt as p,
+  It as s,
+  qt as u
+};
+//# sourceMappingURL=EditorContext-CGkfmbgo.js.map