@gem-sdk/core 1.0.0

package/dist/cjs/components/AddOn.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var AddonContext = require('../contexts/AddonContext.js');
+var shop = require('../hooks/shop.js');
+
+const AddOn = ({ name }) => {
+    const Comp = AddonContext.useAddon(name);
+    const plugins = shop.usePluginEnable();
+    if (!plugins?.includes(name)) {
+        return null;
+    }
+    return jsxRuntime.jsx(Comp, {});
+};
+
+exports.default = AddOn;

package/dist/cjs/components/ComponentWrapper.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var composeAdvanceStyle = require('../helpers/compose-advance-style.js');
+
+const disableWrap = [
+    'Col',
+    'Row',
+    'Section',
+    'Image',
+    'Text',
+    'Button',
+    'ProductButton',
+    'Cart',
+    'Tabs',
+    'TabItem',
+    'Carousel',
+    'CarouselItem',
+    'ShopPayButton',
+    'AccordionItem',
+    'Video',
+    'Header',
+    'HeroBanner',
+    'Icon',
+    'IconList',
+    'HTMLCode',
+    'IconListHoz',
+    'IconListItem',
+    'CSSCode',
+];
+const ComponentWrapper = ({ children, ...props }) => {
+    if (props.type === 'section')
+        return null;
+    const style = composeAdvanceStyle.composeAdvanceStyle(props.advanced, props.tag);
+    if (disableWrap.includes(props.tag) && react.isValidElement(children)) {
+        return jsxRuntime.jsx(children.type, { ...children.props, ...{ style } });
+    }
+    return (jsxRuntime.jsx("div", { style: style, className: `${props.uid}`, children: children }));
+};
+
+exports.default = ComponentWrapper;
+exports.disableWrap = disableWrap;

package/dist/cjs/components/ComponentWrapperPreview.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var composeAdvanceStyle = require('../helpers/compose-advance-style.js');
+var ComponentWrapper = require('./ComponentWrapper.js');
+
+const ComponentWrapperPreview = ({ children, ...props }) => {
+    if (props.type === 'section') {
+        return null;
+    }
+    const customProps = {};
+    // Build editor configs
+    if (props.editorConfigs) {
+        const editorConfigs = props.editorConfigs;
+        if (editorConfigs.placeholder?.notAppendBeforeAfter) {
+            customProps['data-placeholder-not-append-before-after'] = true;
+        }
+        if (editorConfigs.toolbar?.parent) {
+            customProps['data-toolbar-parent'] = true;
+        }
+        if (editorConfigs.component?.noDelete) {
+            customProps['data-component-no-delete'] = true;
+        }
+        if (editorConfigs.component?.noDuplicate) {
+            customProps['data-component-no-duplicate'] = true;
+        }
+        if (editorConfigs.component?.noDragDrop) {
+            customProps['data-component-no-drag-drop'] = true;
+        }
+        if (editorConfigs.component?.noSetting) {
+            customProps['data-component-no-setting'] = true;
+        }
+        if (editorConfigs.toolbar?.hide) {
+            customProps['data-toolbar-hide'] = true;
+        }
+        if (editorConfigs.slots?.children) {
+            customProps['data-slots-children'] = true;
+        }
+    }
+    const style = composeAdvanceStyle.composeAdvanceStyle(props.advanced, props.tag);
+    const builderAttrs = {
+        ...customProps,
+        'data-uid': props.uid,
+        'data-component-type': 'component',
+        'data-component-tag': props.tag,
+        'data-component-label': props.label,
+    };
+    if (ComponentWrapper.disableWrap.includes(props.tag) && react.isValidElement(children)) {
+        return jsxRuntime.jsx(children.type, { ...children.props, ...{ style, builderAttrs } });
+    }
+    // Render
+    return (jsxRuntime.jsx("div", { style: style, className: `${props.uid}`, ...builderAttrs, children: children }));
+};
+
+exports.default = ComponentWrapperPreview;

package/dist/cjs/components/Empty.js

@@ -0,0 +1,7 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const Empty = () => null;
+
+exports.default = Empty;

package/dist/cjs/components/Render.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var reactErrorBoundary = require('react-error-boundary');
+var BuilderComponent = require('../contexts/BuilderComponent.js');
+var BuilderContext = require('../contexts/BuilderContext.js');
+var ComponentWrapper = require('./ComponentWrapper.js');
+var RenderSection = require('./RenderSection.js');
+
+const Render = ({ uid, ...passProps }) => {
+    const item = BuilderContext.useBuilderStore((s) => s.getItem(uid));
+    const Component = BuilderComponent.useBuilderComponent(item?.tag);
+    if (!item)
+        return null;
+    if (item?.type === 'section') {
+        return jsxRuntime.jsx(RenderSection.default, { sectionId: item.uid });
+    }
+    else {
+        return (jsxRuntime.jsx(reactErrorBoundary.ErrorBoundary, { fallbackRender: ({ error, resetErrorBoundary }) => (jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [jsxRuntime.jsx("span", { "aria-label": "Error message", children: error.message }), jsxRuntime.jsx("button", { type: "button", onClick: resetErrorBoundary, children: "Try again" })] })), children: jsxRuntime.jsx(ComponentWrapper.default, { ...item, children: item?.childrens?.length ? (jsxRuntime.jsx(Component, { builderProps: { uid, builderData: item }, styles: item.styles, setting: item.settings, ...passProps, children: item.childrens.map((id) => (jsxRuntime.jsx(RenderMemo, { uid: id }, id))) })) : (jsxRuntime.jsx(Component, { builderProps: { uid, builderData: item }, styles: item.styles, setting: item.settings, ...passProps })) }) }, item.uid));
+    }
+};
+const RenderMemo = react.memo(Render);
+RenderMemo.displayName = 'RenderMemo';
+
+exports.default = RenderMemo;

package/dist/cjs/components/RenderBlock.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var reactErrorBoundary = require('react-error-boundary');
+var BuilderComponent = require('../contexts/BuilderComponent.js');
+var BuilderContext = require('../contexts/BuilderContext.js');
+var ComponentWrapper = require('./ComponentWrapper.js');
+
+const RenderBlock = ({ uid }) => {
+    const item = BuilderContext.useBuilderStore((s) => s.getItem(uid));
+    const Component = BuilderComponent.useBuilderComponent(item?.tag);
+    if (!item || item.type === 'section')
+        return null;
+    return (jsxRuntime.jsx(reactErrorBoundary.ErrorBoundary, { fallbackRender: ({ error, resetErrorBoundary }) => (jsxRuntime.jsxs(ComponentWrapper.default, { ...item, children: [jsxRuntime.jsx("span", { "aria-label": "Error message", children: error.message }), jsxRuntime.jsx("button", { type: "button", onClick: resetErrorBoundary, children: "Try again" })] })), children: jsxRuntime.jsx(ComponentWrapper.default, { ...item, children: item?.childrens?.length ? (jsxRuntime.jsx(Component, { builderProps: { uid }, styles: item.styles ?? {}, setting: item.settings ?? {}, children: item?.childrens?.map((id) => (jsxRuntime.jsx(RenderBlockMemo, { uid: id }, id))) })) : (jsxRuntime.jsx(Component, { builderProps: { uid }, styles: item.styles ?? {}, setting: item.settings ?? {} })) }) }, item.uid));
+};
+const RenderBlockMemo = react.memo(RenderBlock);
+
+exports.default = RenderBlockMemo;

package/dist/cjs/components/RenderPreview.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var reactErrorBoundary = require('react-error-boundary');
+var BuilderComponent = require('../contexts/BuilderComponent.js');
+var BuilderPreviewContext = require('../contexts/BuilderPreviewContext.js');
+var ComponentWrapperPreview = require('./ComponentWrapperPreview.js');
+var RenderSection = require('./RenderSection.js');
+
+const RenderPreview = ({ uid, ...passProps }) => {
+    const item = BuilderPreviewContext.useBuilderPreviewStore((s) => s.getItem(uid));
+    const Component = BuilderComponent.useBuilderComponent(item?.tag);
+    if (!item)
+        return null;
+    if (item?.type === 'section') {
+        return jsxRuntime.jsx(RenderSection.default, { sectionId: item.uid });
+    }
+    else {
+        return (jsxRuntime.jsx(reactErrorBoundary.ErrorBoundary, { fallbackRender: ({ error, resetErrorBoundary }) => (jsxRuntime.jsxs(ComponentWrapperPreview.default, { ...item, children: [jsxRuntime.jsx("span", { "aria-label": "Error message", children: error.message }), jsxRuntime.jsx("button", { type: "button", onClick: resetErrorBoundary, children: "Try again" })] })), children: jsxRuntime.jsx(ComponentWrapperPreview.default, { ...item, children: item?.childrens?.length ? (jsxRuntime.jsx(Component, { builderProps: { uid, builderData: item }, styles: item.styles, setting: item.settings, ...passProps, children: item.childrens.map((id) => (jsxRuntime.jsx(RenderPreviewMemo, { uid: id }, id))) })) : (jsxRuntime.jsx(Component, { builderProps: { uid, builderData: item }, styles: item.styles, setting: item.settings, ...passProps })) }) }, item.uid));
+    }
+};
+const RenderPreviewMemo = react.memo(RenderPreview);
+RenderPreviewMemo.displayName = 'RenderPreviewMemo';
+
+exports.default = RenderPreviewMemo;

package/dist/cjs/components/RenderSection.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var BuilderContext = require('../contexts/BuilderContext.js');
+var SectionContext = require('../contexts/SectionContext.js');
+var RenderBlock = require('./RenderBlock.js');
+
+const RenderSection = ({ sectionId }) => {
+    const state = SectionContext.useSection(sectionId);
+    if (!state)
+        return null;
+    return (jsxRuntime.jsx(BuilderContext.BuilderProvider, { state: state, children: jsxRuntime.jsx(RenderBlock.default, { uid: sectionId }) }, sectionId));
+};
+const RenderSectionMemo = react.memo(RenderSection);
+
+exports.default = RenderSectionMemo;

package/dist/cjs/contexts/AddonContext.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var Empty = require('../components/Empty.js');
+
+const AddonContext = react.createContext(null);
+const AddonProvider = ({ children, components, ...passProps }) => {
+    return (jsxRuntime.jsx(AddonContext.Provider, { ...passProps, value: { components }, children: children }));
+};
+const useAddons = () => {
+    const context = react.useContext(AddonContext);
+    if (!context) {
+        throw new Error('useAddons must be used within an AddonProvider');
+    }
+    return react.useMemo(() => context.components, [context.components]);
+};
+const useAddon = (id) => {
+    const addons = useAddons();
+    return react.useMemo(() => (id ? addons[id] ?? Empty.default : Empty.default), [id, addons]);
+};
+
+exports.AddonProvider = AddonProvider;
+exports.useAddon = useAddon;
+exports.useAddons = useAddons;

package/dist/cjs/contexts/BuilderComponent.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var create = require('zustand');
+var react = require('react');
+var Empty = require('../components/Empty.js');
+
+const BuilderComponentContext = react.createContext(null);
+const createBuilderComponentStore = (components) => create.createStore((_, get) => ({
+    components,
+    getItem: (id) => {
+        return get().components[id];
+    },
+}));
+const BuilderComponentProvider = ({ children, components, ...passProps }) => {
+    return (jsxRuntime.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 = react.useContext(BuilderComponentContext);
+    if (!store) {
+        throw new Error('useBuilderComponent must be used within a BuilderComponentProvider');
+    }
+    return create.useStore(store, (s) => (id ? s.getItem(id) ?? Empty.default : Empty.default));
+};
+
+exports.BuilderComponentProvider = BuilderComponentProvider;
+exports.useBuilderComponent = useBuilderComponent;

package/dist/cjs/contexts/BuilderContext.js

@@ -0,0 +1,29 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var create = require('zustand');
+
+const BuilderContext = react.createContext(null);
+const createBuilderProvider = (data) => create.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 (jsxRuntime.jsx(Component, { children: 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 create.useStore(store, selector, equalityFn);
+};
+
+exports.BuilderProvider = BuilderProvider;
+exports.useBuilderStore = useBuilderStore;

package/dist/cjs/contexts/BuilderPreviewContext.js

@@ -0,0 +1,353 @@
+'use strict';
+
+var jsxRuntime = require('react/jsx-runtime');
+var react = require('react');
+var create = 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 = react.createContext(null);
+const root = {
+    uid: 'ROOT',
+    tag: 'Root',
+    label: 'Root',
+    childrens: [],
+};
+const createBuilderPreviewProvider = (args) => create.createStore((set, get) => ({
+    state: args,
+    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 });
+    },
+    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({
+                state: {
+                    ROOT: {
+                        ...root,
+                        childrens,
+                    },
+                    ...newState,
+                },
+            });
+        }
+        else {
+            const newState = normalizeBuilderData.normalizeBuilderData(data);
+            set({
+                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;
+    return (jsxRuntime.jsx(Component, { children: jsxRuntime.jsx(BuilderPreviewContext.Provider, { ...passProps, value: createBuilderPreviewProvider(state), 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 create.useStore(store, selector, equalityFn);
+};
+
+exports.BuilderPreviewProvider = BuilderPreviewProvider;
+exports.useBuilderPreviewStore = useBuilderPreviewStore;