@gem-sdk/core 2.0.0-dev.896 → 2.0.0

package/dist/esm/contexts/AddonContext.js

@@ -1 +1,32 @@
-import{jsx as o}from"react/jsx-runtime";import{useContext as d,useMemo as e,createContext as n}from"react";import r from"../components/Empty.js";let AddonContext=n(null),AddonProvider=({children:d,components:e,...n})=>o(AddonContext.Provider,{...n,value:{components:e},children:d}),useAddons=()=>{let o=d(AddonContext);if(!o)throw Error("useAddons must be used within an AddonProvider");return e(()=>o.components,[o.components])},useAddon=o=>{let d=useAddons();return e(()=>o?d[o]??r:r,[o,d])};export{AddonProvider,useAddon,useAddons};
+import { jsx } from 'react/jsx-runtime';
+import { useContext, useMemo, createContext } from 'react';
+import Empty from '../components/Empty.js';
+
+const AddonContext = /*#__PURE__*/ createContext(null);
+const AddonProvider = ({ children, components, ...passProps })=>{
+    return /*#__PURE__*/ jsx(AddonContext.Provider, {
+        ...passProps,
+        value: {
+            components
+        },
+        children: children
+    });
+};
+const useAddons = ()=>{
+    const context = useContext(AddonContext);
+    if (!context) {
+        throw new Error('useAddons must be used within an AddonProvider');
+    }
+    return useMemo(()=>context.components, [
+        context.components
+    ]);
+};
+const useAddon = (id)=>{
+    const addons = useAddons();
+    return useMemo(()=>id ? addons[id] ?? Empty : Empty, [
+        id,
+        addons
+    ]);
+};
+
+export { AddonProvider, useAddon, useAddons };

package/dist/esm/contexts/ArticleContext.js

@@ -1 +1,36 @@
-import{jsx as r,Fragment as e}from"react/jsx-runtime";import{useStore as t,createStore as i}from"zustand";import{useId as o,useMemo as l,useContext as c,createContext as n}from"react";let ArticleContext=n(null),createArticleStoreProvider=r=>i(()=>({...r})),ArticleProvider=({children:t,article:i})=>{let c=o(),n=l(()=>createArticleStoreProvider({article:i,uniqueId:c}),[i,c]);return r(ArticleContext.Provider,{value:n,children:r(e,{children:t})})},useArticleStore=(r,e)=>{let i=c(ArticleContext);if(!i)throw Error("Element of article must be used inside a Article");return t(i,r,e)};export{ArticleProvider,useArticleStore};
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { useStore, createStore } from 'zustand';
+import { useId, useMemo, useContext, createContext } from 'react';
+
+// const { Provider, useStore } = createContext<StoreApi<ProductContextProps>>();
+const ArticleContext = /*#__PURE__*/ createContext(null);
+const createArticleStoreProvider = (data)=>createStore(()=>({
+            ...data
+        }));
+const ArticleProvider = ({ children, article })=>{
+    const uniqueId = useId();
+    const store = useMemo(()=>{
+        return createArticleStoreProvider({
+            article,
+            uniqueId
+        });
+    }, [
+        article,
+        uniqueId
+    ]);
+    return /*#__PURE__*/ jsx(ArticleContext.Provider, {
+        value: store,
+        children: /*#__PURE__*/ jsx(Fragment, {
+            children: children
+        })
+    });
+};
+const useArticleStore = (selector, equalityFn)=>{
+    const store = useContext(ArticleContext);
+    if (!store) {
+        throw new Error('Element of article must be used inside a Article');
+    }
+    return useStore(store, selector, equalityFn);
+};
+
+export { ArticleProvider, useArticleStore };

package/dist/esm/contexts/ArticleListContext.js

@@ -1 +1,27 @@
-import{jsx as t}from"react/jsx-runtime";import{useContext as r,createContext as e}from"react";import{useStore as i,createStore as o}from"zustand";let ArticleListContext=e(null),createArticleListProvider=t=>o(()=>({...t})),ArticleListProvider=({articles:r,blogs:e,children:i,styles:o,settings:s})=>t(ArticleListContext.Provider,{value:createArticleListProvider({articles:r,styles:o,settings:s,blogs:e}),children:i}),useArticleListStore=(t,e)=>{let o=r(ArticleListContext);if(!o)throw Error("useArticleListStore must be used within a useArticleListStore");return i(o,t,e)};export{ArticleListContext,ArticleListProvider,useArticleListStore};
+import { jsx } from 'react/jsx-runtime';
+import { useContext, createContext } from 'react';
+import { useStore, createStore } from 'zustand';
+
+const ArticleListContext = /*#__PURE__*/ createContext(null);
+const createArticleListProvider = (data)=>createStore(()=>({
+            ...data
+        }));
+const ArticleListProvider = ({ articles, children, styles, settings })=>{
+    return /*#__PURE__*/ jsx(ArticleListContext.Provider, {
+        value: createArticleListProvider({
+            articles,
+            styles,
+            settings
+        }),
+        children: children
+    });
+};
+const useArticleListStore = (selector, equalityFn)=>{
+    const store = useContext(ArticleListContext);
+    if (!store) {
+        throw new Error('useArticleListStore must be used within a useArticleListStore');
+    }
+    return useStore(store, selector, equalityFn);
+};
+
+export { ArticleListContext, ArticleListProvider, useArticleListStore };

package/dist/esm/contexts/BuilderComponent.js

@@ -1 +1,31 @@
-import{jsx as e}from"react/jsx-runtime";import{useStore as o,createStore as t}from"zustand";import{useContext as r,createContext as n}from"react";import m from"../components/Empty.js";let BuilderComponentContext=n(null),createBuilderComponentStore=e=>t((o,t)=>({components:e,getItem:e=>t().components[e]})),BuilderComponentProvider=({children:o,components:t,...r})=>e(BuilderComponentContext.Provider,{...r,value:createBuilderComponentStore(t),children:o}),useBuilderComponent=e=>{let t=r(BuilderComponentContext);if(!t)throw Error("useBuilderComponent must be used within a BuilderComponentProvider");return o(t,o=>e?o.getItem(e)??m:m)};export{BuilderComponentProvider,useBuilderComponent};
+import { jsx } from 'react/jsx-runtime';
+import { useStore, createStore } from 'zustand';
+import { useContext, createContext } from 'react';
+import Empty from '../components/Empty.js';
+
+const BuilderComponentContext = /*#__PURE__*/ createContext(null);
+const createBuilderComponentStore = (components)=>createStore((_, get)=>({
+            components,
+            getItem: (id)=>{
+                return get().components[id];
+            }
+        }));
+const BuilderComponentProvider = ({ children, components, ...passProps })=>{
+    return /*#__PURE__*/ jsx(BuilderComponentContext.Provider, {
+        ...passProps,
+        value: createBuilderComponentStore(components),
+        children: children
+    });
+};
+// export const useBuilderComponent = (id?: string) => {
+//   return useStore((s) => (id ? s.getItem(id) ?? Empty : Empty));
+// };
+const useBuilderComponent = (id)=>{
+    const store = useContext(BuilderComponentContext);
+    if (!store) {
+        throw new Error('useBuilderComponent must be used within a BuilderComponentProvider');
+    }
+    return useStore(store, (s)=>id ? s.getItem(id) ?? Empty : Empty);
+};
+
+export { BuilderComponentProvider, useBuilderComponent };

package/dist/esm/contexts/BuilderContext.js

@@ -1 +1,36 @@
-import{jsx as e}from"react/jsx-runtime";import{useContext as r,createContext as t,Suspense as i,Fragment as u}from"react";import{useStore as o,createStore as d}from"zustand";let BuilderContext=t(null),createBuilderProvider=(e,r,t)=>d((i,u)=>({state:e,isPostPurchase:r,isPreview:t,getItem:e=>u().state[e],getIsPostPurchase:()=>u().isPostPurchase,getIsPreview:()=>u().isPreview})),BuilderProvider=({children:r,state:t,isPostPurchase:o,isPreview:d,lazy:s,priority:l,...P})=>{let a=s?i:u,n=createBuilderProvider(t,o,d);return e(a,{children:e(BuilderContext.Provider,{...P,value:n,children:r})})},useBuilderStore=(e,t)=>{let i=r(BuilderContext);if(!i)throw Error("useBuilderStore must be used within a BuilderProvider");return o(i,e,t)};export{BuilderProvider,useBuilderStore};
+import { jsx } from 'react/jsx-runtime';
+import { useContext, createContext, Suspense, Fragment } from 'react';
+import { useStore, createStore } from 'zustand';
+
+const BuilderContext = /*#__PURE__*/ createContext(null);
+const createBuilderProvider = (data, isPostPurchase, isPreview)=>createStore((_, get)=>({
+            state: data,
+            isPostPurchase: isPostPurchase,
+            isPreview: isPreview,
+            getItem: (id)=>{
+                return get().state[id];
+            },
+            getIsPostPurchase: ()=>get().isPostPurchase,
+            getIsPreview: ()=>get().isPreview
+        }));
+const BuilderProvider = ({ children, state, isPostPurchase, isPreview, lazy, priority, ...passProps })=>{
+    const Component = lazy ? Suspense : Fragment;
+    const store = createBuilderProvider(state, isPostPurchase, isPreview);
+    return /*#__PURE__*/ jsx(Component, {
+        children: /*#__PURE__*/ jsx(BuilderContext.Provider, {
+            ...passProps,
+            value: store,
+            children: children
+        })
+    });
+};
+// export const useBuilderStore = useStore;
+const useBuilderStore = (selector, equalityFn)=>{
+    const store = useContext(BuilderContext);
+    if (!store) {
+        throw new Error('useBuilderStore must be used within a BuilderProvider');
+    }
+    return useStore(store, selector, equalityFn);
+};
+
+export { BuilderProvider, useBuilderStore };

package/dist/esm/contexts/BuilderPreviewContext.js

@@ -1 +1,483 @@
-import{jsx as e}from"react/jsx-runtime";import{useMemo as t,useContext as i,createContext as r,Suspense as s,Fragment as d}from"react";import{useStore as l,createStore as n}from"zustand";import{cloneDeep as a}from"../helpers/clone-deep.js";import{normalizeBuilderData as c}from"../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)))}let BuilderPreviewContext=r(null),root={uid:"ROOT",tag:"Root",label:"Root",childrens:[]},createBuilderPreviewProvider=(e,t)=>n((i,r)=>({state:e,loaded:!1,isThemeSectionEditor:!!t,dynamicProduct:null,dynamicCollection:null,addItem:e=>{let{position:t,data:s}=e,d=r().state,l=Date.now();if("section"===e.type){if(!Array.isArray(s)){let e=s.uid,r=d.ROOT;r.childrens?r.childrens.splice(t??0,0,e):r.childrens=[e],r.dateModified=l,i({state:{...d,[e]:{uid:e,type:"section",label:s.label},ROOT:a(r)}})}}else{let{id:r,data:s}=e,n=r?d[r]??d.ROOT:d.ROOT;if("section"===n.type)return;if(Array.isArray(s)){let e=s.map(e=>e.uid),r=s.reduceRight((e,t)=>{let i=c(t);return{...e,...i}},{});n.dateModified=l,n.childrens=n.childrens??[],n.childrens.splice(t??0,0,...e),i({state:{...d,...r,[n.uid]:a(n)}})}else{let e=c(s);n.dateModified=l,n.childrens=n.childrens??[],n.childrens.splice(t??0,0,s.uid),i({state:{...d,...e,[n.uid]:a(n)}})}}},changeItemProp:(e,t,s)=>{if(!s||!["setting","style","advanced"].includes(s))return;let d=r().state,l=d[e];if(l?.type!=="section"&&l){let r=Date.now();switch(l.dateModified=r,s){case"setting":i({state:{...d,[e]:{...l,settings:{...l.settings,...t}}}});break;case"style":i({state:{...d,[e]:{...l,styles:{...l.styles,...t}}}});break;case"advanced":i({state:{...d,[e]:{...l,advanced:{...l.advanced,...t}}}})}}},forceChangeItemProp:(e,t,s)=>{if(!s||!["setting","style","advanced"].includes(s))return;let d=r().state,l=d[e];if(l?.type!=="section"&&l){let r=Date.now();switch(l.dateModified=r,s){case"setting":i({state:{...d,[e]:{...l,settings:t}}});break;case"style":i({state:{...d,[e]:{...l,styles:t}}});break;case"advanced":i({state:{...d,[e]:{...l,advanced:t}}})}}},changeItemPropByKey:({id:e,key:t,data:s,group:d})=>{if(!d||!["setting","style","advanced"].includes(d))return;let l=r().state,n=l[e];if(n?.type!=="section"&&n){let r={style:n.styles??{},advanced:n.advanced??{},setting:n.settings??{}};void 0===s?(console.warn("Data is undefined"),delete r[d][t]):r[d][t]=s,i({state:{...l,[e]:{...n,settings:{...r.setting},styles:{...r.style},advanced:{...r.advanced}}}})}},getItem:e=>{let t=r().state[e];return{...t,rawChildrens:t?.childrens?.map(e=>r().state[e])}},removeItem:e=>{if("ROOT"===e)i({state:{ROOT:root}});else{let t=r().state;removeByKey(e,t);let s=Object.entries(t).find(([,t])=>"section"!==t.type&&t.childrens?.includes(e));if(s){let r=Date.now(),[d,l]=s;if("section"===l.type)return;l.childrens=l.childrens?.filter(t=>t!==e),l.dateModified=r,i({state:{...t,[d]:a(l)}})}}},moveItem:(e,t,s)=>{let d=r().state,l=d[e],n=d[t];if(l&&n&&"section"!==n.type){if("section"===l.type){let t=d.ROOT;if(!t.childrens)return;let r=t.childrens.findIndex(t=>t===e);moveByIndex(t.childrens,r,s??0),i({state:{...d,ROOT:a(t)}})}else{let r=Object.entries(d).find(([,t])=>"section"!==t.type&&t.childrens?.includes(e));if(l&&r){let c=Date.now(),[,o]=r;if("section"===o.type)return;if(o.dateModified=c,t===o.uid&&o.childrens){let t=o.childrens.findIndex(t=>t===e);o.childrens&&t!==s&&(moveByIndex(o.childrens,t,s??0),i({state:{...d,[o.uid]:a(o)}}))}else o.childrens=o.childrens?.filter(t=>t!==e),n&&(n.dateModified=c,n.childrens=n.childrens??[],n.childrens.splice(s??0,0,l.uid),i({state:{...d,[n.uid]:a(n),[o.uid]:a(o)}}))}}}},forceChangeState:e=>{i({state:e,loaded:!0})},initState:e=>{if(Array.isArray(e)){let t=e.map(e=>e.uid),r=e.reduceRight((e,t)=>{let i=c(t);return{...e,...i}},{});i({loaded:!0,state:{ROOT:{...root,childrens:t},...r}})}else{let t=c(e);i({loaded:!0,state:{ROOT:{...root,childrens:[e.uid]},...t}})}},addSection:(e,t)=>{let s=r().state,d=s.ROOT;d.childrens||(d.childrens=[]),d.childrens.splice(t??0,0,e.uid),i({state:{...s,ROOT:a(d)}})},getParents:(e,t)=>{let i=r().state,s=[],d=0,l=e;for(;!t||!(d>=t);){let e=Object.entries(i).find(([,e])=>"section"!==e.type&&e.childrens?.includes(l));if(!e)break;let[,t]=e;if(!t)break;s.push(t),l=t.uid,d++}return s},updateItemName:(e,t)=>{let s=r().state,d=s[e];d&&(d.name=t,i({state:{...s,[e]:a(d)}}))},updateItemAttribute:(e,t,s)=>{if(!s||!["label","customLabel","isShopifyVisibility"].includes(s))return;let d=r().state,l=d[e];if(l){if("section"!==l.type){let e=Date.now();l.dateModified=e}let r={...l,[s]:t};i({state:{...d,[e]:r}})}}})),BuilderPreviewProvider=({children:i,state:r,isThemeSectionEditor:l,lazy:n,...a})=>{let c=n?s:d,o=t(()=>createBuilderPreviewProvider(r,l),[r,l]);return e(c,{children:e(BuilderPreviewContext.Provider,{...a,value:o,children:i})})},useBuilderPreviewStore=(e,t)=>{let r=i(BuilderPreviewContext);if(!r)throw Error("useBuilderPreviewStore must be used within a BuilderPreviewProvider");return l(r,e,t)};export{BuilderPreviewProvider,useBuilderPreviewStore};
+import { jsx } from 'react/jsx-runtime';
+import { useMemo, useContext, createContext, Suspense, Fragment } from 'react';
+import { useStore, createStore } from 'zustand';
+import { cloneDeep } from '../helpers/clone-deep.js';
+import { normalizeBuilderData } from '../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__*/ createContext(null);
+const root = {
+    uid: 'ROOT',
+    tag: 'Root',
+    label: 'Root',
+    childrens: []
+};
+const createBuilderPreviewProvider = (args, pageName, isThemeSectionEditor)=>createStore((set, get)=>({
+            state: args,
+            loaded: false,
+            isThemeSectionEditor: !!isThemeSectionEditor,
+            pageName: pageName,
+            dynamicProduct: null,
+            dynamicCollection: null,
+            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(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(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(parent)
+                            }
+                        });
+                    } else {
+                        const item = normalizeBuilderData(data);
+                        parent.dateModified = dateModified;
+                        parent.childrens = parent.childrens ?? [];
+                        parent.childrens.splice(position ?? 0, 0, data.uid);
+                        set({
+                            state: {
+                                ...state,
+                                ...item,
+                                [parent.uid]: 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;
+                    }
+                }
+            },
+            forceChangeItemProp: (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: data
+                                    }
+                                }
+                            });
+                            break;
+                        case 'style':
+                            set({
+                                state: {
+                                    ...state,
+                                    [id]: {
+                                        ...item,
+                                        styles: data
+                                    }
+                                }
+                            });
+                            break;
+                        case 'advanced':
+                            set({
+                                state: {
+                                    ...state,
+                                    [id]: {
+                                        ...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)=>{
+                const item = get().state[id];
+                return {
+                    ...item,
+                    rawChildrens: item?.childrens?.map((v)=>get().state[v])
+                };
+            },
+            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(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(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(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(moveTo),
+                                        [parentItem.uid]: 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(current);
+                        return {
+                            ...prev,
+                            ...item
+                        };
+                    }, {});
+                    set({
+                        loaded: true,
+                        state: {
+                            ROOT: {
+                                ...root,
+                                childrens
+                            },
+                            ...newState
+                        }
+                    });
+                } else {
+                    const newState = 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(ROOT)
+                    }
+                });
+            },
+            getParents: (id, limit)=>{
+                const state = get().state;
+                const parents = [];
+                let index = 0;
+                let currentId = id;
+                // eslint-disable-next-line no-constant-condition
+                while(true){
+                    if (limit && index >= limit) break;
+                    const parent = Object.entries(state).find(([, value])=>value.type !== 'section' && value.childrens?.includes(currentId));
+                    if (!parent) break;
+                    const [, parentItem] = parent;
+                    if (!parentItem) break;
+                    parents.push(parentItem);
+                    currentId = parentItem.uid;
+                    index++;
+                }
+                return parents;
+            },
+            updateItemName: (id, name)=>{
+                const state = get().state;
+                const item = state[id];
+                if (item) {
+                    item.name = name;
+                    set({
+                        state: {
+                            ...state,
+                            [id]: cloneDeep(item)
+                        }
+                    });
+                }
+            },
+            updateItemAttribute: (id, value, attr)=>{
+                if (!attr || ![
+                    'label',
+                    'customLabel',
+                    'isShopifyVisibility'
+                ].includes(attr)) return;
+                const state = get().state;
+                const item = state[id];
+                if (item) {
+                    if (item.type !== 'section') {
+                        const dateModified = Date.now();
+                        item.dateModified = dateModified;
+                    }
+                    const updatedItem = {
+                        ...item,
+                        [attr]: value
+                    };
+                    set({
+                        state: {
+                            ...state,
+                            [id]: updatedItem
+                        }
+                    });
+                }
+            }
+        }));
+const BuilderPreviewProvider = ({ children, state, isThemeSectionEditor, pageName, lazy, ...passProps })=>{
+    const Component = lazy ? Suspense : Fragment;
+    const value = useMemo(()=>{
+        return createBuilderPreviewProvider(state, pageName, isThemeSectionEditor);
+    }, [
+        state,
+        isThemeSectionEditor,
+        pageName
+    ]);
+    return /*#__PURE__*/ jsx(Component, {
+        children: /*#__PURE__*/ jsx(BuilderPreviewContext.Provider, {
+            ...passProps,
+            value: value,
+            children: children
+        })
+    });
+};
+// export const useBuilderPreviewStore = useStore;
+const useBuilderPreviewStore = (selector, equalityFn)=>{
+    const store = useContext(BuilderPreviewContext);
+    if (!store) {
+        throw new Error('useBuilderPreviewStore must be used within a BuilderPreviewProvider');
+    }
+    return useStore(store, selector, equalityFn);
+};
+
+export { BuilderPreviewProvider, useBuilderPreviewStore };