@gem-sdk/core 1.14.0-next.91 → 1.14.0

package/dist/cjs/contexts/BuilderContext.js

@@ -1 +1,35 @@
-"use strict";var jsxRuntime=require("react/jsx-runtime"),react=require("react"),zustand=require("zustand");const BuilderContext=react.createContext(null),createBuilderProvider=e=>zustand.createStore((r,t)=>({state:e,getItem:e=>t().state[e]})),BuilderProvider=({children:e,state:r,lazy:t,priority:u,...i})=>{let d=t?react.Suspense:react.Fragment,s=createBuilderProvider(r);return jsxRuntime.jsx(d,{children:jsxRuntime.jsx(BuilderContext.Provider,{...i,value:s,children:e})})},useBuilderStore=(e,r)=>{let t=react.useContext(BuilderContext);if(!t)throw Error("useBuilderStore must be used within a BuilderProvider");return zustand.useStore(t,e,r)};exports.BuilderProvider=BuilderProvider,exports.useBuilderStore=useBuilderStore;
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var zustand = require('zustand');
+
+const BuilderContext = /*#__PURE__*/ react.createContext(null);
+const createBuilderProvider = (data)=>zustand.createStore((_, get)=>({
+            state: data,
+            getItem: (id)=>{
+                return get().state[id];
+            }
+        }));
+const BuilderProvider = ({ children, state, lazy, priority, ...passProps })=>{
+    const Component = lazy ? react.Suspense : react.Fragment;
+    const store = createBuilderProvider(state);
+    return /*#__PURE__*/ jsxRuntime.jsx(Component, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(BuilderContext.Provider, {
+            ...passProps,
+            value: store,
+            children: children
+        })
+    });
+};
+// export const useBuilderStore = useStore;
+const useBuilderStore = (selector, equalityFn)=>{
+    const store = react.useContext(BuilderContext);
+    if (!store) {
+        throw new Error('useBuilderStore must be used within a BuilderProvider');
+    }
+    return zustand.useStore(store, selector, equalityFn);
+};
+
+exports.BuilderProvider = BuilderProvider;
+exports.useBuilderStore = useBuilderStore;

package/dist/cjs/contexts/BuilderPreviewContext.js

@@ -1 +1,370 @@
-"use strict";var jsxRuntime=require("react/jsx-runtime"),react=require("react"),zustand=require("zustand"),cloneDeep=require("../helpers/clone-deep.js"),normalizeBuilderData=require("../helpers/normalize-builder-data.js");function moveByIndex(e,t,i){let r=e.splice(t,1)[0];void 0!==r&&e.splice(i,0,r)}function removeByKey(e,t){let i=t[e];i&&(delete t[e],"section"!==i.type&&i.childrens?.map(e=>removeByKey(e,t)))}const BuilderPreviewContext=react.createContext(null),root={uid:"ROOT",tag:"Root",label:"Root",childrens:[]},createBuilderPreviewProvider=e=>zustand.createStore((t,i)=>({state:e,loaded:!1,addItem:e=>{let{position:r,data:l}=e,d=i().state,n=Date.now();if("section"===e.type){if(!Array.isArray(l)){let e=l.uid,i=d.ROOT;i.childrens?i.childrens.splice(r??0,0,e):i.childrens=[e],i.dateModified=n,t({state:{...d,[e]:{uid:e,type:"section",label:l.label},ROOT:cloneDeep.cloneDeep(i)}})}}else{let{id:i,data:l}=e,s=i?d[i]??d.ROOT:d.ROOT;if("section"===s.type)return;if(Array.isArray(l)){let e=l.map(e=>e.uid),i=l.reduceRight((e,t)=>{let i=normalizeBuilderData.normalizeBuilderData(t);return{...e,...i}},{});s.dateModified=n,s.childrens=s.childrens??[],s.childrens.splice(r??0,0,...e),t({state:{...d,...i,[s.uid]:cloneDeep.cloneDeep(s)}})}else{let e=normalizeBuilderData.normalizeBuilderData(l);s.dateModified=n,s.childrens=s.childrens??[],s.childrens.splice(r??0,0,l.uid),t({state:{...d,...e,[s.uid]:cloneDeep.cloneDeep(s)}})}}},changeItemProp:(e,r,l)=>{if(!l||!["setting","style","advanced"].includes(l))return;let d=i().state,n=d[e];if(n?.type!=="section"&&n){let i=Date.now();switch(n.dateModified=i,l){case"setting":t({state:{...d,[e]:{...n,settings:{...n.settings,...r}}}});break;case"style":t({state:{...d,[e]:{...n,styles:{...n.styles,...r}}}});break;case"advanced":t({state:{...d,[e]:{...n,advanced:{...n.advanced,...r}}}})}}},changeItemPropByKey:({id:e,key:r,data:l,group:d})=>{if(!d||!["setting","style","advanced"].includes(d))return;let n=i().state,s=n[e];if(s?.type!=="section"&&s){let i={style:s.styles??{},advanced:s.advanced??{},setting:s.settings??{}};void 0===l?(console.warn("Data is undefined"),delete i[d][r]):i[d][r]=l,t({state:{...n,[e]:{...s,settings:{...i.setting},styles:{...i.style},advanced:{...i.advanced}}}})}},getItem:e=>i().state[e],removeItem:e=>{if("ROOT"===e)t({state:{ROOT:root}});else{let r=i().state;removeByKey(e,r);let l=Object.entries(r).find(([,t])=>"section"!==t.type&&t.childrens?.includes(e));if(l){let i=Date.now(),[d,n]=l;if("section"===n.type)return;n.childrens=n.childrens?.filter(t=>t!==e),n.dateModified=i,t({state:{...r,[d]:cloneDeep.cloneDeep(n)}})}}},moveItem:(e,r,l)=>{let d=i().state,n=d[e],s=d[r];if(n&&s&&"section"!==s.type){if("section"===n.type){let i=d.ROOT;if(!i.childrens)return;let r=i.childrens.findIndex(t=>t===e);moveByIndex(i.childrens,r,l??0),t({state:{...d,ROOT:cloneDeep.cloneDeep(i)}})}else{let i=Object.entries(d).find(([,t])=>"section"!==t.type&&t.childrens?.includes(e));if(n&&i){let a=Date.now(),[,c]=i;if("section"===c.type)return;if(c.dateModified=a,r===c.uid&&c.childrens){let i=c.childrens.findIndex(t=>t===e);c.childrens&&i!==l&&(moveByIndex(c.childrens,i,l??0),t({state:{...d,[c.uid]:cloneDeep.cloneDeep(c)}}))}else c.childrens=c.childrens?.filter(t=>t!==e),s&&(s.dateModified=a,s.childrens=s.childrens??[],s.childrens.splice(l??0,0,n.uid),t({state:{...d,[s.uid]:cloneDeep.cloneDeep(s),[c.uid]:cloneDeep.cloneDeep(c)}}))}}}},forceChangeState:e=>{t({state:e,loaded:!0})},initState:e=>{if(Array.isArray(e)){let i=e.map(e=>e.uid),r=e.reduceRight((e,t)=>{let i=normalizeBuilderData.normalizeBuilderData(t);return{...e,...i}},{});t({loaded:!0,state:{ROOT:{...root,childrens:i},...r}})}else{let i=normalizeBuilderData.normalizeBuilderData(e);t({loaded:!0,state:{ROOT:{...root,childrens:[e.uid]},...i}})}},addSection:(e,r)=>{let l=i().state,d=l.ROOT;d.childrens||(d.childrens=[]),d.childrens.splice(r??0,0,e.uid),t({state:{...l,ROOT:cloneDeep.cloneDeep(d)}})}})),BuilderPreviewProvider=({children:e,state:t,lazy:i,...r})=>{let l=i?react.Suspense:react.Fragment,d=react.useMemo(()=>createBuilderPreviewProvider(t),[t]);return jsxRuntime.jsx(l,{children:jsxRuntime.jsx(BuilderPreviewContext.Provider,{...r,value:d,children:e})})},useBuilderPreviewStore=(e,t)=>{let i=react.useContext(BuilderPreviewContext);if(!i)throw Error("useBuilderPreviewStore must be used within a BuilderPreviewProvider");return zustand.useStore(i,e,t)};exports.BuilderPreviewProvider=BuilderPreviewProvider,exports.useBuilderPreviewStore=useBuilderPreviewStore;
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var zustand = require('zustand');
+var cloneDeep = require('../helpers/clone-deep.js');
+var normalizeBuilderData = require('../helpers/normalize-builder-data.js');
+
+function moveByIndex(input, from, to) {
+    const elm = input.splice(from, 1)[0];
+    if (elm !== undefined) {
+        input.splice(to, 0, elm);
+    }
+}
+function removeByKey(id, data) {
+    const item = data[id];
+    if (item) {
+        delete data[id];
+        if (item.type !== 'section') {
+            item.childrens?.map((child)=>removeByKey(child, data));
+        }
+    }
+}
+const BuilderPreviewContext = /*#__PURE__*/ react.createContext(null);
+const root = {
+    uid: 'ROOT',
+    tag: 'Root',
+    label: 'Root',
+    childrens: []
+};
+const createBuilderPreviewProvider = (args)=>zustand.createStore((set, get)=>({
+            state: args,
+            loaded: false,
+            addItem: (args)=>{
+                const { position, data } = args;
+                const state = get().state;
+                const dateModified = Date.now();
+                if (args.type === 'section') {
+                    if (!Array.isArray(data)) {
+                        const sectionId = data.uid;
+                        // Section only add to ROOT
+                        const ROOT = state.ROOT;
+                        if (!ROOT.childrens) {
+                            ROOT.childrens = [
+                                sectionId
+                            ];
+                        } else {
+                            ROOT.childrens.splice(position ?? 0, 0, sectionId);
+                        }
+                        ROOT.dateModified = dateModified;
+                        set({
+                            state: {
+                                ...state,
+                                [sectionId]: {
+                                    uid: sectionId,
+                                    type: 'section',
+                                    label: data.label
+                                },
+                                ROOT: cloneDeep.cloneDeep(ROOT)
+                            }
+                        });
+                    }
+                } else {
+                    const { id, data } = args;
+                    const parent = id ? state[id] ?? state.ROOT : state.ROOT;
+                    // Can't add item to section
+                    if (parent.type === 'section') return;
+                    if (Array.isArray(data)) {
+                        const childrens = data.map((v)=>v.uid);
+                        const newState = data.reduceRight((prev, current)=>{
+                            const item = normalizeBuilderData.normalizeBuilderData(current);
+                            return {
+                                ...prev,
+                                ...item
+                            };
+                        }, {});
+                        parent.dateModified = dateModified;
+                        parent.childrens = parent.childrens ?? [];
+                        parent.childrens.splice(position ?? 0, 0, ...childrens);
+                        set({
+                            state: {
+                                ...state,
+                                ...newState,
+                                [parent.uid]: cloneDeep.cloneDeep(parent)
+                            }
+                        });
+                    } else {
+                        const item = normalizeBuilderData.normalizeBuilderData(data);
+                        parent.dateModified = dateModified;
+                        parent.childrens = parent.childrens ?? [];
+                        parent.childrens.splice(position ?? 0, 0, data.uid);
+                        set({
+                            state: {
+                                ...state,
+                                ...item,
+                                [parent.uid]: cloneDeep.cloneDeep(parent)
+                            }
+                        });
+                    }
+                }
+            },
+            changeItemProp: (id, data, group)=>{
+                if (!group || ![
+                    'setting',
+                    'style',
+                    'advanced'
+                ].includes(group)) return;
+                const state = get().state;
+                const item = state[id];
+                // Ignore section
+                if (item?.type === 'section') return;
+                if (item) {
+                    const dateModified = Date.now();
+                    item.dateModified = dateModified;
+                    switch(group){
+                        case 'setting':
+                            set({
+                                state: {
+                                    ...state,
+                                    [id]: {
+                                        ...item,
+                                        settings: {
+                                            ...item.settings,
+                                            ...data
+                                        }
+                                    }
+                                }
+                            });
+                            break;
+                        case 'style':
+                            set({
+                                state: {
+                                    ...state,
+                                    [id]: {
+                                        ...item,
+                                        styles: {
+                                            ...item.styles,
+                                            ...data
+                                        }
+                                    }
+                                }
+                            });
+                            break;
+                        case 'advanced':
+                            set({
+                                state: {
+                                    ...state,
+                                    [id]: {
+                                        ...item,
+                                        advanced: {
+                                            ...item.advanced,
+                                            ...data
+                                        }
+                                    }
+                                }
+                            });
+                            break;
+                    }
+                }
+            },
+            changeItemPropByKey: ({ id, key, data, group })=>{
+                if (!group || ![
+                    'setting',
+                    'style',
+                    'advanced'
+                ].includes(group)) return;
+                const state = get().state;
+                const item = state[id];
+                // Ignore section
+                if (item?.type === 'section') return;
+                if (item) {
+                    const itemSetting = {
+                        style: item.styles ?? {},
+                        advanced: item.advanced ?? {},
+                        setting: item.settings ?? {}
+                    };
+                    if (data === undefined) {
+                        console.warn('Data is undefined');
+                        delete itemSetting[group][key];
+                    } else {
+                        itemSetting[group][key] = data;
+                    }
+                    set({
+                        state: {
+                            ...state,
+                            [id]: {
+                                ...item,
+                                settings: {
+                                    ...itemSetting.setting
+                                },
+                                styles: {
+                                    ...itemSetting.style
+                                },
+                                advanced: {
+                                    ...itemSetting.advanced
+                                }
+                            }
+                        }
+                    });
+                }
+            },
+            getItem: (id)=>{
+                return get().state[id];
+            },
+            removeItem: (id)=>{
+                if (id === 'ROOT') {
+                    set({
+                        state: {
+                            ROOT: root
+                        }
+                    });
+                } else {
+                    const state = get().state;
+                    removeByKey(id, state);
+                    // Get parent node by id
+                    const parent = Object.entries(state).find(([, value])=>value.type !== 'section' && value.childrens?.includes(id));
+                    if (parent) {
+                        const dateModified = Date.now();
+                        const [parentId, parentValue] = parent;
+                        if (parentValue.type === 'section') return;
+                        parentValue.childrens = parentValue.childrens?.filter((child)=>child !== id);
+                        parentValue.dateModified = dateModified;
+                        set({
+                            state: {
+                                ...state,
+                                [parentId]: cloneDeep.cloneDeep(parentValue)
+                            }
+                        });
+                    }
+                }
+            },
+            moveItem: (id, toId, position)=>{
+                const state = get().state;
+                const item = state[id];
+                const moveTo = state[toId];
+                // Ignore section
+                if (!item || !moveTo || moveTo.type === 'section') return;
+                if (item.type === 'section') {
+                    // Section only add to ROOT
+                    const ROOT = state.ROOT;
+                    if (!ROOT.childrens) return;
+                    const currentIndex = ROOT.childrens.findIndex((uid)=>uid === id);
+                    moveByIndex(ROOT.childrens, currentIndex, position ?? 0);
+                    set({
+                        state: {
+                            ...state,
+                            ROOT: cloneDeep.cloneDeep(ROOT)
+                        }
+                    });
+                } else {
+                    const parent = Object.entries(state).find(([, value])=>value.type !== 'section' && value.childrens?.includes(id));
+                    if (item && parent) {
+                        const dateModified = Date.now();
+                        const [, parentItem] = parent;
+                        // Ignore section
+                        if (parentItem.type === 'section') return;
+                        parentItem.dateModified = dateModified;
+                        if (toId === parentItem.uid && parentItem.childrens) {
+                            // Move item to the same parent
+                            const currentIndex = parentItem.childrens.findIndex((uid)=>uid === id);
+                            if (parentItem.childrens && currentIndex !== position) {
+                                moveByIndex(parentItem.childrens, currentIndex, position ?? 0);
+                                set({
+                                    state: {
+                                        ...state,
+                                        [parentItem.uid]: cloneDeep.cloneDeep(parentItem)
+                                    }
+                                });
+                            }
+                        } else {
+                            // Move item to another parent
+                            // Remove item from parent node
+                            parentItem.childrens = parentItem.childrens?.filter((uid)=>uid !== id);
+                            if (moveTo) {
+                                moveTo.dateModified = dateModified;
+                                moveTo.childrens = moveTo.childrens ?? [];
+                                moveTo.childrens.splice(position ?? 0, 0, item.uid);
+                                set({
+                                    state: {
+                                        ...state,
+                                        [moveTo.uid]: cloneDeep.cloneDeep(moveTo),
+                                        [parentItem.uid]: cloneDeep.cloneDeep(parentItem)
+                                    }
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+            forceChangeState: (data)=>{
+                set({
+                    state: data,
+                    loaded: true
+                });
+            },
+            initState: (data)=>{
+                if (Array.isArray(data)) {
+                    const childrens = data.map((v)=>v.uid);
+                    const newState = data.reduceRight((prev, current)=>{
+                        const item = normalizeBuilderData.normalizeBuilderData(current);
+                        return {
+                            ...prev,
+                            ...item
+                        };
+                    }, {});
+                    set({
+                        loaded: true,
+                        state: {
+                            ROOT: {
+                                ...root,
+                                childrens
+                            },
+                            ...newState
+                        }
+                    });
+                } else {
+                    const newState = normalizeBuilderData.normalizeBuilderData(data);
+                    set({
+                        loaded: true,
+                        state: {
+                            ROOT: {
+                                ...root,
+                                childrens: [
+                                    data.uid
+                                ]
+                            },
+                            ...newState
+                        }
+                    });
+                }
+            },
+            addSection: (data, position)=>{
+                const state = get().state;
+                const ROOT = state.ROOT;
+                if (!ROOT.childrens) ROOT.childrens = [];
+                ROOT.childrens.splice(position ?? 0, 0, data.uid);
+                set({
+                    state: {
+                        ...state,
+                        ROOT: cloneDeep.cloneDeep(ROOT)
+                    }
+                });
+            }
+        }));
+const BuilderPreviewProvider = ({ children, state, lazy, ...passProps })=>{
+    const Component = lazy ? react.Suspense : react.Fragment;
+    const value = react.useMemo(()=>{
+        return createBuilderPreviewProvider(state);
+    }, [
+        state
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(Component, {
+        children: /*#__PURE__*/ jsxRuntime.jsx(BuilderPreviewContext.Provider, {
+            ...passProps,
+            value: value,
+            children: children
+        })
+    });
+};
+// export const useBuilderPreviewStore = useStore;
+const useBuilderPreviewStore = (selector, equalityFn)=>{
+    const store = react.useContext(BuilderPreviewContext);
+    if (!store) {
+        throw new Error('useBuilderPreviewStore must be used within a BuilderPreviewProvider');
+    }
+    return zustand.useStore(store, selector, equalityFn);
+};
+
+exports.BuilderPreviewProvider = BuilderPreviewProvider;
+exports.useBuilderPreviewStore = useBuilderPreviewStore;

package/dist/cjs/contexts/CartLineContext.js

@@ -1 +1,29 @@
-"use strict";var jsxRuntime=require("react/jsx-runtime"),zustand=require("zustand"),react=require("react");const CartLineContext=react.createContext(null),createCartLineStore=e=>zustand.createStore(()=>({...e})),CartLineProvider=({children:e,line:t})=>jsxRuntime.jsx(CartLineContext.Provider,{value:createCartLineStore({line:t}),children:e},`${t.id}-${t.quantity}`),useCartLineStore=(e,t)=>{let r=react.useContext(CartLineContext);if(!r)throw Error("useCartLineStore must be used within a CartLineProvider");return zustand.useStore(r,e,t)};exports.CartLineProvider=CartLineProvider,exports.useCartLineStore=useCartLineStore;
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var zustand = require('zustand');
+var react = require('react');
+
+const CartLineContext = /*#__PURE__*/ react.createContext(null);
+const createCartLineStore = (data)=>zustand.createStore(()=>({
+            ...data
+        }));
+const CartLineProvider = ({ children, line })=>{
+    return /*#__PURE__*/ jsxRuntime.jsx(CartLineContext.Provider, {
+        value: createCartLineStore({
+            line
+        }),
+        children: children
+    }, `${line.id}-${line.quantity}`);
+};
+// export const useCartLineStore = useStore;
+const useCartLineStore = (selector, equalityFn)=>{
+    const store = react.useContext(CartLineContext);
+    if (!store) {
+        throw new Error('useCartLineStore must be used within a CartLineProvider');
+    }
+    return zustand.useStore(store, selector, equalityFn);
+};
+
+exports.CartLineProvider = CartLineProvider;
+exports.useCartLineStore = useCartLineStore;

package/dist/cjs/contexts/CollectionContext.js

@@ -1 +1,38 @@
-"use strict";var jsxRuntime=require("react/jsx-runtime"),react=require("react"),zustand=require("zustand");const CollectionContext=react.createContext(null),createCollectionProvider=e=>zustand.createStore(t=>({...e,changeCollectionStore:({collection:e})=>{t({collection:e})}})),CollectionProvider=({collection:e,children:t})=>{let o=react.useMemo(()=>createCollectionProvider({collection:e}),[e]);return jsxRuntime.jsx(CollectionContext.Provider,{value:o,children:t},e?.id)},useCollectionStore=(e,t)=>{let o=react.useContext(CollectionContext);if(!o)throw Error("useCollectionStore must be used within a useCollectionStore");return zustand.useStore(o,e,t)};exports.CollectionProvider=CollectionProvider,exports.useCollectionStore=useCollectionStore;
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var zustand = require('zustand');
+
+const CollectionContext = /*#__PURE__*/ react.createContext(null);
+const createCollectionProvider = (data)=>zustand.createStore((set)=>({
+            ...data,
+            changeCollectionStore: ({ collection })=>{
+                set({
+                    collection: collection
+                });
+            }
+        }));
+const CollectionProvider = ({ collection, children })=>{
+    const store = react.useMemo(()=>{
+        return createCollectionProvider({
+            collection
+        });
+    }, [
+        collection
+    ]);
+    return /*#__PURE__*/ jsxRuntime.jsx(CollectionContext.Provider, {
+        value: store,
+        children: children
+    }, collection?.id);
+};
+const useCollectionStore = (selector, equalityFn)=>{
+    const store = react.useContext(CollectionContext);
+    if (!store) {
+        throw new Error('useCollectionStore must be used within a useCollectionStore');
+    }
+    return zustand.useStore(store, selector, equalityFn);
+};
+
+exports.CollectionProvider = CollectionProvider;
+exports.useCollectionStore = useCollectionStore;

package/dist/cjs/contexts/ModalContext.js

@@ -1 +1,47 @@
-"use strict";var jsxRuntime=require("react/jsx-runtime"),react=require("react"),zustand=require("zustand");const ModalContext=react.createContext(null),createModalProvider=e=>zustand.createStore(t=>({activeId:e,setModalActive:e=>{window?.parent?.postMessage?.(JSON.stringify({type:"active-element",uid:e}),"*"),t({activeId:e})},clearModal:()=>{window?.parent?.postMessage?.(JSON.stringify({type:"active-element",uid:null}),"*"),t({activeId:void 0})}})),ModalProvider=({children:e,activeId:t,...r})=>{let o=createModalProvider(t);return jsxRuntime.jsx(ModalContext.Provider,{...r,value:o,children:e})},useModalStore=(e,t)=>{let r=react.useContext(ModalContext);if(!r)throw Error("useModalStore must be used within a ModalProvider");return zustand.useStore(r,e,t)};exports.ModalProvider=ModalProvider,exports.useModalStore=useModalStore;
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var zustand = require('zustand');
+
+const ModalContext = /*#__PURE__*/ react.createContext(null);
+const createModalProvider = (data)=>zustand.createStore((set)=>({
+            activeId: data,
+            setModalActive: (id)=>{
+                window?.parent?.postMessage?.(JSON.stringify({
+                    type: 'active-element',
+                    uid: id
+                }), '*');
+                set({
+                    activeId: id
+                });
+            },
+            clearModal: ()=>{
+                window?.parent?.postMessage?.(JSON.stringify({
+                    type: 'active-element',
+                    uid: null
+                }), '*');
+                set({
+                    activeId: undefined
+                });
+            }
+        }));
+const ModalProvider = ({ children, activeId, ...passProps })=>{
+    const store = createModalProvider(activeId);
+    return /*#__PURE__*/ jsxRuntime.jsx(ModalContext.Provider, {
+        ...passProps,
+        value: store,
+        children: children
+    });
+};
+// export const useBuilderStore = useStore;
+const useModalStore = (selector, equalityFn)=>{
+    const store = react.useContext(ModalContext);
+    if (!store) {
+        throw new Error('useModalStore must be used within a ModalProvider');
+    }
+    return zustand.useStore(store, selector, equalityFn);
+};
+
+exports.ModalProvider = ModalProvider;
+exports.useModalStore = useModalStore;