@varianta/sdk 0.1.7 → 0.1.9

package/dist/react.esm.js

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