@varianta/sdk 0.1.8 → 0.1.9

package/dist/react.esm.js

@@ -1,322 +1,321 @@
-import { jsx as O } from "react/jsx-runtime";
-import { forwardRef as j, useRef as D, useEffect as p, useImperativeHandle as H, useState as l, useCallback as c } from "react";
-import { initCustomizer as J } from "./index.esm.js";
-const K = j(
-  (b, T) => {
+import { jsx as M } from "react/jsx-runtime";
+import { forwardRef as B, useRef as A, useEffect as v, useImperativeHandle as j, useState as d, useCallback as a } from "react";
+import { initCustomizer as H, CustomizerError as u } from "./index.esm.js";
+const J = B(
+  (U, S) => {
     const {
-      templateId: g,
-      productId: w,
-      apiUrl: r,
-      theme: s = "light",
-      mode: z = "edit",
-      debug: F = !1,
-      className: U,
-      style: k,
-      initialDesign: h,
-      showCloseButton: V,
-      showSaveButton: A,
-      onReady: d,
+      templateId: w,
+      productId: L,
+      apiUrl: t,
+      theme: l = "light",
+      mode: g = "edit",
+      debug: O = !1,
+      className: _,
+      style: V,
+      initialDesign: z,
+      showCloseButton: Z,
+      showSaveButton: p,
+      onReady: f,
       onChange: y,
-      onLayerSelect: f,
+      onLayerSelect: I,
       onLayerAdd: m,
-      onLayerRemove: E,
-      onLayerUpdate: L,
-      onError: R,
-      onFinalize: C,
-      onViewChange: a,
-      onClose: v,
-      onSave: S
-    } = b, I = D(null), e = D(null), i = D({
-      onReady: d,
+      onLayerRemove: h,
+      onLayerUpdate: T,
+      onError: E,
+      onFinalize: R,
+      onViewChange: s,
+      onClose: N,
+      onSave: C
+    } = U, D = A(null), e = A(null), c = A({
+      onReady: f,
       onChange: y,
-      onLayerSelect: f,
+      onLayerSelect: I,
       onLayerAdd: m,
-      onLayerRemove: E,
-      onLayerUpdate: L,
-      onError: R,
-      onFinalize: C,
-      onViewChange: a,
-      onClose: v,
-      onSave: S
+      onLayerRemove: h,
+      onLayerUpdate: T,
+      onError: E,
+      onFinalize: R,
+      onViewChange: s,
+      onClose: N,
+      onSave: C
     });
-    return p(() => {
-      i.current = {
-        onReady: d,
+    return v(() => {
+      c.current = {
+        onReady: f,
         onChange: y,
-        onLayerSelect: f,
+        onLayerSelect: I,
         onLayerAdd: m,
-        onLayerRemove: E,
-        onLayerUpdate: L,
-        onError: R,
-        onFinalize: C,
-        onViewChange: a,
-        onClose: v,
-        onSave: S
+        onLayerRemove: h,
+        onLayerUpdate: T,
+        onError: E,
+        onFinalize: R,
+        onViewChange: s,
+        onClose: N,
+        onSave: C
       };
-    }, [d, y, f, m, E, L, R, C, a, v, S]), p(() => {
-      if (!I.current) return;
-      const o = {
-        templateId: g,
-        productId: w,
-        apiUrl: r,
-        theme: s,
-        mode: z,
-        debug: F,
-        initialDesign: h,
-        showCloseButton: V,
-        showSaveButton: A,
+    }, [f, y, I, m, h, T, E, R, s, N, C]), v(() => {
+      if (!D.current) return;
+      const n = {
+        templateId: w,
+        productId: L,
+        apiUrl: t,
+        theme: l,
+        mode: g,
+        debug: O,
+        initialDesign: z,
+        showCloseButton: Z,
+        showSaveButton: p,
         // Use callback refs to always get latest callbacks
-        onReady: () => i.current.onReady?.(),
-        onChange: (t) => i.current.onChange?.(t),
-        onLayerSelect: (t) => i.current.onLayerSelect?.(t),
-        onLayerAdd: (t) => i.current.onLayerAdd?.(t),
-        onLayerRemove: (t) => i.current.onLayerRemove?.(t),
-        onLayerUpdate: (t) => i.current.onLayerUpdate?.(t),
-        onError: (t) => i.current.onError?.(t),
-        onFinalize: (t) => i.current.onFinalize?.(t),
-        onViewChange: (t) => i.current.onViewChange?.(t),
-        onClose: () => i.current.onClose?.(),
-        onSave: (t) => i.current.onSave?.(t)
+        onReady: () => c.current.onReady?.(),
+        onChange: (r) => c.current.onChange?.(r),
+        onLayerSelect: (r) => c.current.onLayerSelect?.(r),
+        onLayerAdd: (r) => c.current.onLayerAdd?.(r),
+        onLayerRemove: (r) => c.current.onLayerRemove?.(r),
+        onLayerUpdate: (r) => c.current.onLayerUpdate?.(r),
+        onError: (r) => c.current.onError?.(r),
+        onFinalize: (r) => c.current.onFinalize?.(r),
+        onViewChange: (r) => c.current.onViewChange?.(r),
+        onClose: () => c.current.onClose?.(),
+        onSave: (r) => c.current.onSave?.(r)
       };
       try {
-        const t = J(I.current, o);
-        e.current = t;
-      } catch (t) {
-        console.error("[Customizer React] Failed to initialize:", t), i.current.onError?.({
-          code: "INIT_ERROR",
-          message: t instanceof Error ? t.message : "Unknown error",
-          details: t
-        });
+        const r = H(D.current, n);
+        e.current = r;
+      } catch (r) {
+        console.error("[Customizer React] Failed to initialize:", r);
+        const x = r instanceof u ? r : new u("INIT_ERROR", r instanceof Error ? r.message : "Unknown error", r);
+        c.current.onError?.(x);
       }
       return () => {
         e.current && (e.current.destroy(), e.current = null);
       };
-    }, [g, w, r, F, h, V, A]), p(() => {
-      e.current && e.current.setTheme(s);
-    }, [s]), p(() => {
-      e.current && e.current.setMode(z);
-    }, [z]), H(
-      T,
+    }, [w, L, t, O, z, Z, p]), v(() => {
+      e.current && e.current.setTheme(l);
+    }, [l]), v(() => {
+      e.current && e.current.setMode(g);
+    }, [g]), j(
+      S,
       () => ({
         getDesign: () => {
           if (!e.current)
-            throw new Error("Editor not initialized");
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
           return e.current.getDesign();
         },
-        setDesign: (o) => {
+        setDesign: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.setDesign(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.setDesign(n);
         },
         undo: () => {
           if (!e.current)
-            throw new Error("Editor not initialized");
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
           e.current.undo();
         },
         redo: () => {
           if (!e.current)
-            throw new Error("Editor not initialized");
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
           e.current.redo();
         },
         canUndo: () => e.current ? e.current.canUndo() : !1,
         canRedo: () => e.current ? e.current.canRedo() : !1,
-        finalize: async () => {
+        finalize: async (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          return e.current.finalize();
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          return e.current.finalize(n);
         },
-        waitForResult: async (o, t) => {
+        waitForResult: async (n, r) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          return e.current.waitForResult(o, t);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          return e.current.waitForResult(n, r);
         },
-        addTextLayer: (o) => {
+        addTextLayer: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.addTextLayer(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.addTextLayer(n);
         },
-        addImageLayer: async (o) => {
+        addImageLayer: async (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          return e.current.addImageLayer(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          return e.current.addImageLayer(n);
         },
-        removeLayer: (o) => {
+        removeLayer: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.removeLayer(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.removeLayer(n);
         },
-        selectLayer: (o) => {
+        selectLayer: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.selectLayer(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.selectLayer(n);
         },
         getSelectedLayerId: () => e.current ? e.current.getSelectedLayerId() : null,
         getActiveView: () => e.current ? e.current.getActiveView() : null,
         getViews: () => e.current ? e.current.getViews() : [],
-        setActiveView: (o) => {
+        setActiveView: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.setActiveView(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.setActiveView(n);
         },
-        setTheme: (o) => {
+        setTheme: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.setTheme(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.setTheme(n);
         },
-        setMode: (o) => {
+        setMode: (n) => {
           if (!e.current)
-            throw new Error("Editor not initialized");
-          e.current.setMode(o);
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
+          e.current.setMode(n);
         },
         destroy: () => {
           e.current && (e.current.destroy(), e.current = null);
         },
         getElement: () => {
           if (!e.current)
-            throw new Error("Editor not initialized");
+            throw new u("NOT_INITIALIZED", "Editor not initialized");
           return e.current.getElement();
         }
       }),
       []
       // Empty deps is OK - we always read from instanceRef.current
-    ), /* @__PURE__ */ O(
+    ), /* @__PURE__ */ M(
       "div",
       {
-        ref: I,
-        className: U,
+        ref: D,
+        className: _,
         style: {
           width: "100%",
           height: "100%",
-          ...k
+          ...V
         }
       }
     );
   }
 );
-K.displayName = "Customizer";
-function P(b = {}) {
+J.displayName = "Customizer";
+function P(U = {}) {
   const {
-    autoSave: T = !1,
-    autoSaveKey: g = "customizer-design",
-    autoSaveDebounce: w = 1e3
-  } = b, r = D(null), [s, z] = l(null), [F, U] = l(!1), [k, h] = l(!1), [V, A] = l(null), [d, y] = l(!1), [f, m] = l(!1), [E, L] = l(
+    autoSave: S = !1,
+    autoSaveKey: w = "customizer-design",
+    autoSaveDebounce: L = 1e3
+  } = U, t = A(null), [l, g] = d(null), [O, _] = d(!1), [V, z] = d(!1), [Z, p] = d(null), [f, y] = d(!1), [I, m] = d(!1), [h, T] = d(
     null
-  ), [R, C] = l(null), a = D(void 0);
-  p(() => {
-    if (!(!T || !s))
-      return a.current && clearTimeout(a.current), a.current = setTimeout(() => {
+  ), [E, R] = d(null), s = A(void 0);
+  v(() => {
+    if (!(!S || !l))
+      return s.current && clearTimeout(s.current), s.current = setTimeout(() => {
         try {
-          localStorage.setItem(g, JSON.stringify(s));
-        } catch (n) {
-          console.error("[useCustomizer] Auto-save failed:", n);
+          localStorage.setItem(w, JSON.stringify(l));
+        } catch (o) {
+          console.error("[useCustomizer] Auto-save failed:", o);
         }
-      }, w), () => {
-        a.current && clearTimeout(a.current);
+      }, L), () => {
+        s.current && clearTimeout(s.current);
       };
-  }, [s, T, g, w]);
-  const v = c(() => {
-    if (!r.current) return null;
+  }, [l, S, w, L]);
+  const N = a(() => {
+    if (!t.current) return null;
     try {
-      return r.current.getDesign();
-    } catch (n) {
-      return console.error("[useCustomizer] getDesign failed:", n), null;
+      return t.current.getDesign();
+    } catch (o) {
+      return console.error("[useCustomizer] getDesign failed:", o), null;
     }
-  }, []), S = c((n) => {
-    if (r.current)
+  }, []), C = a((o) => {
+    if (t.current)
       try {
-        r.current.setDesign(n), z(n);
-      } catch (u) {
-        console.error("[useCustomizer] setDesign failed:", u);
+        t.current.setDesign(o), g(o);
+      } catch (i) {
+        console.error("[useCustomizer] setDesign failed:", i);
       }
-  }, []), I = c(() => {
-    if (r.current)
+  }, []), D = a(() => {
+    if (t.current)
       try {
-        r.current.undo(), U(r.current.canUndo()), h(r.current.canRedo());
-      } catch (n) {
-        console.error("[useCustomizer] undo failed:", n);
+        t.current.undo(), _(t.current.canUndo()), z(t.current.canRedo());
+      } catch (o) {
+        console.error("[useCustomizer] undo failed:", o);
       }
-  }, []), e = c(() => {
-    if (r.current)
+  }, []), e = a(() => {
+    if (t.current)
       try {
-        r.current.redo(), U(r.current.canUndo()), h(r.current.canRedo());
-      } catch (n) {
-        console.error("[useCustomizer] redo failed:", n);
+        t.current.redo(), _(t.current.canUndo()), z(t.current.canRedo());
+      } catch (o) {
+        console.error("[useCustomizer] redo failed:", o);
       }
-  }, []), i = c(async () => {
-    if (!r.current || d) return null;
+  }, []), c = a(async (o) => {
+    if (!t.current || f) return null;
     y(!0);
     try {
-      const n = await r.current.finalize();
-      return L(n), n;
-    } catch (n) {
-      return console.error("[useCustomizer] finalize failed:", n), null;
+      const i = await t.current.finalize(o);
+      return T(i), i;
+    } catch (i) {
+      return console.error("[useCustomizer] finalize failed:", i), null;
     } finally {
       y(!1);
     }
-  }, [d]), o = c(async (n, u) => {
-    if (!r.current || f) return null;
+  }, [f]), n = a(async (o, i) => {
+    if (!t.current || I) return null;
     m(!0);
     try {
-      const x = await r.current.waitForResult(n, u);
-      return C(x), x;
-    } catch (x) {
-      return console.error("[useCustomizer] waitForResult failed:", x), null;
+      const F = await t.current.waitForResult(o, i);
+      return R(F), F;
+    } catch (F) {
+      return console.error("[useCustomizer] waitForResult failed:", F), null;
     } finally {
       m(!1);
     }
-  }, [f]), t = c((n) => {
-    if (r.current)
+  }, [I]), r = a((o) => {
+    if (t.current)
       try {
-        r.current.addTextLayer(n);
-      } catch (u) {
-        console.error("[useCustomizer] addTextLayer failed:", u);
+        t.current.addTextLayer(o);
+      } catch (i) {
+        console.error("[useCustomizer] addTextLayer failed:", i);
       }
-  }, []), N = c(async (n) => {
-    if (r.current)
+  }, []), x = a(async (o) => {
+    if (t.current)
       try {
-        await r.current.addImageLayer(n);
-      } catch (u) {
-        console.error("[useCustomizer] addImageLayer failed:", u);
+        await t.current.addImageLayer(o);
+      } catch (i) {
+        console.error("[useCustomizer] addImageLayer failed:", i);
       }
-  }, []), M = c((n) => {
-    if (r.current)
+  }, []), b = a((o) => {
+    if (t.current)
       try {
-        r.current.removeLayer(n);
-      } catch (u) {
-        console.error("[useCustomizer] removeLayer failed:", u);
+        t.current.removeLayer(o);
+      } catch (i) {
+        console.error("[useCustomizer] removeLayer failed:", i);
       }
-  }, []), B = c((n) => {
-    if (r.current)
+  }, []), k = a((o) => {
+    if (t.current)
       try {
-        r.current.selectLayer(n), A(n);
-      } catch (u) {
-        console.error("[useCustomizer] selectLayer failed:", u);
+        t.current.selectLayer(o), p(o);
+      } catch (i) {
+        console.error("[useCustomizer] selectLayer failed:", i);
       }
   }, []);
   return {
-    customizerRef: r,
-    design: s,
-    canUndo: F,
-    canRedo: k,
-    selectedLayerId: V,
-    isFinalizing: d,
-    isRendering: f,
-    finalizeResult: E,
-    renderResult: R,
-    getDesign: v,
-    setDesign: S,
-    undo: I,
+    customizerRef: t,
+    design: l,
+    canUndo: O,
+    canRedo: V,
+    selectedLayerId: Z,
+    isFinalizing: f,
+    isRendering: I,
+    finalizeResult: h,
+    renderResult: E,
+    getDesign: N,
+    setDesign: C,
+    undo: D,
     redo: e,
-    finalize: i,
-    waitForResult: o,
-    addTextLayer: t,
-    addImageLayer: N,
-    removeLayer: M,
-    selectLayer: B
+    finalize: c,
+    waitForResult: n,
+    addTextLayer: r,
+    addImageLayer: x,
+    removeLayer: b,
+    selectLayer: k
   };
 }
 export {
-  K as Customizer,
+  J as Customizer,
+  u as CustomizerError,
   P as useCustomizer
 };
 //# sourceMappingURL=react.esm.js.map