@gem-sdk/pages 1.23.0-staging.29 → 1.23.0-staging.322

package/dist/cjs/components/builder/Toolbar.js

@@ -2,131 +2,69 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var jsxRuntime = require('react/jsx-runtime');
 var react = require('react');
+var Onboarding = require('./toolbar/Onboarding.js');
 
 const TOOLBAR_HOVER_HEIGHT = 24;
 const TOOLBAR_ACTIVE_HEIGHT = 32;
-const getDOMElementParents = ($el, selector, limit)=>{
-    // Set up a parent array
-    const parents = [];
-    // Push each parent $elms to the array
-    while($el){
-        $el = $el.parentElement ?? undefined;
-        if ($el) {
-            if ($el.tagName === 'BODY' || $el.getAttribute('data-uid') === 'ROOT') {
-                break;
-            }
-            if (selector) {
-                if ($el.matches(selector)) {
-                    parents.push($el);
-                    if (limit && parents.length == limit) {
-                        return parents;
-                    }
-                }
-                continue;
-            }
-            parents.push($el);
-            if (limit && parents.length == limit) {
-                return parents;
-            }
-        }
-    }
-    // Return our parent array
-    return parents;
-};
-const getChildrenByAttrSelector = ($el, attrSelector)=>{
-    const childLen = $el.children.length;
-    if (childLen) {
-        for(let i = 0; i < childLen; i++){
-            const children = $el.children[i];
-            if (children) {
-                const is = children.getAttribute(attrSelector);
-                if (is) {
-                    return children;
-                }
-            }
-        }
-    }
-};
-const isOverParent = ({ current, parent, index, revert })=>{
-    for(let i = 0; i < index; i++){
-        let is = current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent.top && current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent.top + parent.height || current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent.top + parent.height && current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent.top;
-        if (revert) {
-            is = current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent.bottom && current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent.bottom - parent.height || current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent.bottom - parent.height && current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent.bottom;
-        }
-        if (is) return true;
-    }
-    return false;
-};
-const waitForElementToExist = (selector, timeout = 200)=>{
-    return new Promise((resolve)=>{
-        const intervalID = setInterval(()=>{
-            const el = document.querySelector(selector);
-            if (el) {
-                clearInterval(intervalID);
-                clearTimeout(timeoutID);
-                resolve(el);
-            }
-        }, 50);
-        const timeoutID = setTimeout(()=>{
-            clearInterval(intervalID);
-            clearTimeout(timeoutID);
-            resolve(null);
-        }, timeout);
-    });
-};
-const notVisible = (el)=>{
-    const overflow = getComputedStyle(el).overflow;
-    return overflow !== 'visible';
-};
-const isSection = (el)=>{
+const isPopup = (el)=>{
     const tag = el.getAttribute('data-component-tag');
-    return tag === 'Section';
+    return tag === 'Dialog';
 };
-const isOverToolbarPosition = (el, parent)=>{
-    const rect = el.getBoundingClientRect();
-    const rectP = parent.getBoundingClientRect();
-    // 32px = toolbar active height
-    return rect.top - rectP.top < TOOLBAR_ACTIVE_HEIGHT + 1;
-};
-const findOverflowParent = (element, initEl)=>{
-    const thisEl = element;
-    const origEl = initEl || thisEl;
-    if (!thisEl) return;
-    if (isSection(thisEl)) return;
-    if (notVisible(thisEl) && isOverToolbarPosition(initEl, thisEl)) return thisEl;
-    if (thisEl.parentElement) {
-        return findOverflowParent(thisEl.parentElement, origEl);
-    } else {
-        return;
-    }
+const isSticky = (el)=>{
+    const tag = el.getAttribute('data-component-tag');
+    return tag === 'Sticky';
 };
 const Toolbar = ()=>{
     const currentComponentActive = react.useRef(null);
     const isDragging = react.useRef(false);
-    const obsActiveComponent = react.useRef();
+    const stopWatchReRenderComponent = react.useRef();
     const isResizeSpacing = react.useRef(false);
+    const [isOnboarding, setIsOnboarding] = react.useState(false);
+    const [countShowOnboarding, setCountShowOnboarding] = react.useState(0);
+    const [onboardingPosition, setOnboardingPosition] = react.useState('bottom');
+    const timeoutRef = react.useRef(null);
+    const timeoutOnboarding = 5000;
     /* Functions */ const changePositionToolbar = ({ state, $toolbar, $component })=>{
         const $parentOverflow = findOverflowParent($component, $toolbar);
+        const rect = $toolbar.getBoundingClientRect();
+        const rectComponent = $component.getBoundingClientRect();
+        const windowWidth = window.innerWidth;
         if ($parentOverflow) {
-            const rect = $component.getBoundingClientRect();
-            if (rect?.height >= 60) {
-                $toolbar.setAttribute(`data-toolbar-${state}-inside`, 'true');
-            } else {
+            if (rectComponent?.height <= 60) {
                 $toolbar.setAttribute(`data-toolbar-${state}-revert`, 'true');
+            } else {
+                $toolbar.setAttribute(`data-toolbar-${state}-inside`, 'true');
+            }
+            // fix toolbar overflow right side
+            if (rectComponent.left + rect.width > windowWidth) {
+                $toolbar.setAttribute(`data-toolbar-${state}-overflow`, 'true');
             }
         } else {
-            const rect = $toolbar.getBoundingClientRect();
             if (rect.top < TOOLBAR_ACTIVE_HEIGHT + 1) {
-                if (rect?.height >= 60) {
-                    $toolbar.setAttribute(`data-toolbar-${state}-inside`, 'true');
-                } else {
+                if (rectComponent?.height <= 60) {
                     $toolbar.setAttribute(`data-toolbar-${state}-revert`, 'true');
+                } else {
+                    $toolbar.setAttribute(`data-toolbar-${state}-inside`, 'true');
                 }
             }
+            // fix toolbar overflow right side
+            if (rectComponent.left + rect.width > windowWidth) {
+                $toolbar.setAttribute(`data-toolbar-${state}-overflow`, 'true');
+            }
+        }
+        // fix Popup overflow right position
+        const popupEl = $component?.closest('[aria-label="Dialog body"]');
+        if (popupEl) {
+            const rectPopupEl = popupEl.getBoundingClientRect();
+            const popupElRightPosition = rectPopupEl.left + rectPopupEl.width - 20;
+            if (rectComponent.left + rect.width > popupElRightPosition) {
+                $toolbar.setAttribute(`data-toolbar-${state}-overflow`, 'true');
+            }
         }
     };
-    const setHoverComponent = react.useCallback(({ $component, componentUid, focus, isThemeSection })=>{
+    const setHoverComponent = react.useCallback(({ $component, componentUid, focus, isThemeSection, isParent })=>{
         if (!$component && !componentUid) return;
         if (!$component) {
             const $c = document.querySelector(`[data-uid="${componentUid}"]`);
@@ -148,7 +86,9 @@ const Toolbar = ()=>{
         }
         if ($toolbar) {
             $toolbar.removeAttribute('style');
-            $toolbar.setAttribute('data-toolbar-hover', 'true');
+            if (!isParent) {
+                $toolbar.setAttribute('data-toolbar-hover', 'true');
+            }
             if (focus) {
                 $toolbar.setAttribute('data-toolbar-hover-focus', 'true');
             }
@@ -160,6 +100,9 @@ const Toolbar = ()=>{
         }
         if ($outline) {
             $outline.setAttribute('data-outline-hover', 'true');
+            if (isParent) {
+                $outline.setAttribute('data-outline-parent-hover', 'true');
+            }
             if (isThemeSection) {
                 $outline.setAttribute('data-outline-overlay-theme-section', 'true');
             }
@@ -168,10 +111,14 @@ const Toolbar = ()=>{
             }
         }
         if ($btnAddTop) {
-            $btnAddTop.setAttribute('data-toolbar-add-hover', 'true');
+            if (!isParent) {
+                $btnAddTop.setAttribute('data-toolbar-add-hover', 'true');
+            }
         }
         if ($btnAddBottom) {
-            $btnAddBottom.setAttribute('data-toolbar-add-hover', 'true');
+            if (!isParent) {
+                $btnAddBottom.setAttribute('data-toolbar-add-hover', 'true');
+            }
         }
     }, []);
     const setHoverComponentParents = react.useCallback(({ $component, componentUid })=>{
@@ -180,12 +127,13 @@ const Toolbar = ()=>{
             if (!$c) return;
             $component = $c;
         }
-        const $parents = getDOMElementParents($component, '[data-uid][data-component-type="component"]:not([data-component-no-setting])');
+        const $parents = getDOMElementParents($component, '[data-uid][data-component-type="component"]:not([data-component-no-setting])', 1);
         if ($parents.length) {
             for (const $parent of $parents){
                 if ($parent) {
                     setHoverComponent({
-                        $component: $parent
+                        $component: $parent,
+                        isParent: true
                     });
                 }
             }
@@ -260,8 +208,11 @@ const Toolbar = ()=>{
             'data-toolbar-hover',
             'data-outline-hover-focus',
             'data-toolbar-hover-revert',
+            'data-toolbar-hover-inside',
             'data-outline-hover',
-            'data-toolbar-add-hover'
+            'data-toolbar-add-hover',
+            'data-outline-parent-hover',
+            'data-toolbar-hover-overflow'
         ];
         const $elms = document.querySelectorAll(clearAttrs.map((attr)=>`[${attr}]`).join(','));
         if ($elms) {
@@ -273,6 +224,21 @@ const Toolbar = ()=>{
     }, [
         removeHoverOverlayComponent
     ]);
+    const onCloseOnboarding = react.useCallback(()=>{
+        timeoutRef.current && clearTimeout(timeoutRef.current);
+        if (countShowOnboarding > 0) {
+            const eventCreate = new CustomEvent('editor:toolbar:close-onboarding', {
+                bubbles: true,
+                detail: {
+                    close: 'close Onboarding'
+                }
+            });
+            window.dispatchEvent(eventCreate);
+            setIsOnboarding(false);
+        }
+    }, [
+        countShowOnboarding
+    ]);
     const removeActiveComponent = react.useCallback(()=>{
         currentComponentActive.current = null;
         const clearAttrs = [
@@ -280,9 +246,11 @@ const Toolbar = ()=>{
             'data-outline-active',
             'data-toolbar-add-active',
             'data-toolbar-active-revert',
+            'data-toolbar-active-inside',
             'data-spacing-margin-bottom-active',
             'data-toolbar-force-hover',
-            'data-outline-force-hover'
+            'data-outline-force-hover',
+            'data-toolbar-active-overflow'
         ];
         const $elms = document.querySelectorAll(clearAttrs.map((attr)=>`[${attr}]`).join(','));
         if ($elms) {
@@ -291,25 +259,32 @@ const Toolbar = ()=>{
             });
         }
         setFocusTextEditor(false);
-        if (obsActiveComponent.current) obsActiveComponent.current.disconnect();
-    }, []);
+        if (stopWatchReRenderComponent.current) stopWatchReRenderComponent.current();
+        onCloseOnboarding();
+    }, [
+        onCloseOnboarding
+    ]);
     const watchComponentReRender = ($el, callback)=>{
-        const parent = $el.parentNode;
-        if (!parent) return;
-        if (obsActiveComponent.current) obsActiveComponent.current.disconnect();
-        obsActiveComponent.current = new MutationObserver((mutations)=>{
-            for (const mutation of mutations){
-                mutation.removedNodes.forEach((el)=>{
-                    if (el === $el) {
-                        if (obsActiveComponent.current) obsActiveComponent.current.disconnect();
-                        callback();
-                    }
-                });
+        // editor:component:render
+        const onComponentReRender = (e)=>{
+            const detail = e.detail;
+            if (detail?.componentUid == currentComponentActive.current?.componentUid) {
+                callback();
             }
-        });
-        obsActiveComponent.current.observe(parent, {
-            childList: true
-        });
+        };
+        window.removeEventListener('editor:component:render', onComponentReRender);
+        window.addEventListener('editor:component:render', onComponentReRender);
+        const $images = $el.querySelectorAll('img');
+        if ($images?.length) {
+            $images.forEach(($img)=>{
+                $img.addEventListener('load', ()=>{
+                    callback();
+                });
+            });
+        }
+        stopWatchReRenderComponent.current = ()=>{
+            window.removeEventListener('editor:component:render', onComponentReRender);
+        };
     };
     const setActiveComponentSpacing = react.useCallback(({ $component })=>{
         if (!$component) return;
@@ -320,43 +295,96 @@ const Toolbar = ()=>{
             const $bg = $marginBottom.querySelector('[data-spacing-margin-bottom-bg]') || null;
             const $drag = $marginBottom.querySelector('[data-spacing-margin-bottom-drag]') || null;
             if ($bg && $drag) {
-                const value = style.marginBottom;
+                let value = style.marginBottom;
+                if (parseFloat(value) < 0) {
+                    value = '0';
+                }
                 $bg.style.height = value;
                 $drag.style.top = value;
                 $marginBottom.setAttribute('data-spacing-margin-bottom-active', 'true');
+                if (isLayoutElement($component)) {
+                    $bg.style.left = '0';
+                } else {
+                    const paddingLeft = style.paddingLeft;
+                    const leftValue = `-${paddingLeft}`;
+                    const translateCss = `translate(${leftValue}, -100%)`;
+                    $bg.style.left = leftValue;
+                    $drag.style.transform = translateCss;
+                }
             }
         }
     }, []);
-    const setActiveComponentForceHoverSection = ($component, value)=>{
-        const $section = $component.closest('[data-toolbar-wrap][data-component-tag="Section"]');
-        if ($section) {
-            if (value) {
-                const $toolbar = getChildrenByAttrSelector($section, 'data-toolbar');
-                const $outline = getChildrenByAttrSelector($section, 'data-outline');
-                if ($toolbar) {
-                    $toolbar.setAttribute('data-toolbar-force-hover', 'true');
-                }
-                if ($outline) {
-                    $outline.setAttribute('data-outline-force-hover', 'true');
-                }
-            } else {
-                const $toolbar = getChildrenByAttrSelector($section, 'data-toolbar');
-                const $outline = getChildrenByAttrSelector($section, 'data-outline');
-                if ($toolbar) {
-                    $toolbar.removeAttribute('data-toolbar-force-hover');
-                }
-                if ($outline) {
-                    $outline.removeAttribute('data-outline-force-hover');
+    const calculateOnboardingPosition = ()=>{
+        const toolbar = document.querySelector('[data-toolbar-active]');
+        const toolbarOnboading = document.querySelector('[data-toolbar-onboarding]');
+        if (toolbar && toolbarOnboading) {
+            toolbarOnboading?.removeAttribute('data-onboarding-active');
+            setTimeout(()=>{
+                const rect = toolbar.getBoundingClientRect();
+                const rectTop = rect.top || 0;
+                const rectOnboading = toolbarOnboading?.getBoundingClientRect();
+                const onboardingHeight = rectOnboading?.height || 0;
+                const $iframe = parent.document.querySelector('.iframe');
+                const $iframeWin = $iframe?.contentWindow;
+                const iframeWinScrollY = $iframeWin?.scrollY || 0;
+                const iframeHeight = $iframe?.clientHeight || 0;
+                if (rectTop + onboardingHeight > iframeHeight) {
+                    const oboardingTop = rect.top + iframeWinScrollY - onboardingHeight - 8;
+                    toolbarOnboading?.setAttribute('style', `top: ${oboardingTop}px;left: ${rect.left}px;`);
+                    setOnboardingPosition('top');
+                    if ($iframeWin && oboardingTop < rect.top + iframeWinScrollY) {
+                        setTimeout(()=>{
+                            const toTop = oboardingTop - 20;
+                            $iframeWin.scrollTo({
+                                top: toTop,
+                                behavior: 'smooth'
+                            });
+                        }, 200);
+                    }
+                } else {
+                    const oboardingTop = rect.top + iframeWinScrollY + rect.height + 8;
+                    toolbarOnboading?.setAttribute('style', `top: ${oboardingTop}px;left: ${rect.left}px;`);
+                    setOnboardingPosition('bottom');
                 }
-            }
+                setCountShowOnboarding((countShowOnboarding)=>countShowOnboarding + 1);
+                toolbarOnboading?.setAttribute('data-onboarding-active', 'true');
+            }, 100);
         }
     };
+    const setToolbarOnboarding = react.useCallback(({ $component })=>{
+        if (!$component) return;
+        if (isSection($component) || isPopup($component) || isSticky($component)) return;
+        const toolbarOnboading = document.querySelector('[data-toolbar-onboarding]');
+        // only show one time
+        if (countShowOnboarding == 0) {
+            calculateOnboardingPosition();
+        } else {
+            onCloseOnboarding();
+            toolbarOnboading?.removeAttribute('data-onboarding-active');
+        }
+    }, [
+        countShowOnboarding,
+        onCloseOnboarding
+    ]);
     const setActiveComponent = react.useCallback(async ({ componentUid, productId, timeAwait = 500, forceReActive })=>{
         if (!componentUid) return;
-        const $component = await waitForElementToExist(`${productId ? `[data-product-id="${productId}"] ` : ''}[data-uid="${componentUid}"]`, timeAwait);
-        if (!$component) return;
+        let $component = await waitForElementToExist(`${productId ? `[data-product-id="${productId}"] ` : ''}[data-uid="${componentUid}"]`, timeAwait);
+        // check element fetch data: product, product list
+        if (!$component) {
+            const isLoading = document.querySelector(`.gp-loading-placeholder`);
+            if (!isLoading) {
+                return;
+            }
+            if (isLoading) {
+                // await element onload
+                $component = await waitForElementToExist(`${productId ? `[data-product-id="${productId}"] ` : ''}[data-uid="${componentUid}"]`, 15000);
+            }
+        }
+        if (!$component) {
+            return;
+        }
         if (!forceReActive && componentUid == currentComponentActive.current?.componentUid && productId == currentComponentActive.current?.productId) return;
-        if (!forceReActive && componentUid !== currentComponentActive.current?.componentUid || productId !== currentComponentActive.current?.productId) removeActiveComponent();
+        if (componentUid !== currentComponentActive.current?.componentUid || productId !== currentComponentActive.current?.productId || forceReActive) removeActiveComponent();
         const $toolbar = getChildrenByAttrSelector($component, 'data-toolbar');
         const $outline = getChildrenByAttrSelector($component, 'data-outline');
         const $btnAddTop = getChildrenByAttrSelector($component, 'data-toolbar-add-top');
@@ -398,7 +426,14 @@ const Toolbar = ()=>{
         setActiveComponentSpacing({
             $component
         });
-        setActiveComponentForceHoverSection($component, true);
+        timeoutRef.current && clearTimeout(timeoutRef.current);
+        timeoutRef.current = setTimeout(()=>{
+            if ($component) {
+                setToolbarOnboarding({
+                    $component
+                });
+            }
+        }, timeoutOnboarding);
         removeHoverComponent();
         // Reactive when component re-render
         watchComponentReRender($component, ()=>{
@@ -412,7 +447,8 @@ const Toolbar = ()=>{
     }, [
         removeActiveComponent,
         removeHoverComponent,
-        setActiveComponentSpacing
+        setActiveComponentSpacing,
+        setToolbarOnboarding
     ]);
     const setFocusTextEditor = async (value)=>{
         if (!value) {
@@ -535,7 +571,7 @@ const Toolbar = ()=>{
         if (isDragging.current) return;
         if (isResizeSpacing.current) return;
         const $target = e.target;
-        if (!$target) {
+        if (!$target || typeof $target.closest !== 'function') {
             removeHoverOverlayComponent();
             return;
         }
@@ -578,6 +614,7 @@ const Toolbar = ()=>{
                 if ($product) {
                     const productId = $product.getAttribute('data-product-id');
                     if (productId == currentComponentActive.current.productId) {
+                        removeHoverComponent();
                         return;
                     }
                 }
@@ -677,6 +714,46 @@ const Toolbar = ()=>{
     }, [
         removeHoverComponent
     ]);
+    const setHoverParentComponent = (uid, type)=>{
+        if (!uid) return;
+        const $parentComponents = document.querySelectorAll(`[data-uid="${uid}"]`);
+        if ($parentComponents.length) {
+            $parentComponents.forEach(($parentComponent)=>{
+                const $outline = getChildrenByAttrSelector($parentComponent, 'data-outline');
+                if ($outline) {
+                    if (type === 'in') {
+                        $outline.setAttribute('data-outline-force-hover', 'true');
+                        $outline.setAttribute('data-outline-force-overlay', 'true');
+                    } else {
+                        $outline.removeAttribute('data-outline-force-hover');
+                        $outline.removeAttribute('data-outline-force-overlay');
+                    }
+                }
+            });
+        }
+    };
+    const onHoverComponent = react.useCallback((e)=>{
+        if (isDragging.current) return;
+        const detail = e.detail;
+        if (detail?.componentUid) {
+            setHoverParentComponent(detail?.componentUid, detail?.type);
+        }
+    }, [
+        isDragging
+    ]);
+    const onToolbarOnboarding = react.useCallback((e)=>{
+        const detail = e.detail;
+        if (detail?.isNewUser) {
+            setIsOnboarding(true);
+        }
+    }, []);
+    const onWindowResize = react.useCallback(()=>{
+        if (isOnboarding) {
+            calculateOnboardingPosition();
+        }
+    }, [
+        isOnboarding
+    ]);
     /* Register event */ react.useEffect(()=>{
         document.addEventListener('mousemove', onMouseMove);
         window.addEventListener('editor:active-component', onActiveComponent);
@@ -685,6 +762,9 @@ const Toolbar = ()=>{
         window.addEventListener('editor:is-editing-text-editor', onIsEditingTextEditor);
         window.addEventListener('editor:toolbar:show-parents', onShowParents);
         window.addEventListener('editor:toolbar:resize-spacing', onResizeSpacing);
+        window.addEventListener('editor:hover-component', onHoverComponent);
+        window.addEventListener('editor:toolbar-onboarding', onToolbarOnboarding);
+        window.addEventListener('resize', onWindowResize);
         return ()=>{
             document.removeEventListener('mousemove', onMouseMove);
             window.removeEventListener('editor:active-component', onActiveComponent);
@@ -693,6 +773,9 @@ const Toolbar = ()=>{
             window.removeEventListener('editor:is-editing-text-editor', onIsEditingTextEditor);
             window.removeEventListener('editor:toolbar:show-parents', onShowParents);
             window.removeEventListener('editor:toolbar:resize-spacing', onResizeSpacing);
+            window.removeEventListener('editor:hover-component', onHoverComponent);
+            window.removeEventListener('editor:toolbar-onboarding', onToolbarOnboarding);
+            window.removeEventListener('resize', onWindowResize);
         };
     }, [
         onMouseMove,
@@ -701,9 +784,115 @@ const Toolbar = ()=>{
         onIsDragging,
         onIsEditingTextEditor,
         onShowParents,
-        onResizeSpacing
+        onResizeSpacing,
+        onHoverComponent,
+        onToolbarOnboarding,
+        onWindowResize
     ]);
-    return null;
+    return isOnboarding && /*#__PURE__*/ jsxRuntime.jsx(Onboarding.default, {
+        enable: true,
+        position: onboardingPosition,
+        onCloseOnboarding: onCloseOnboarding
+    });
+};
+const getDOMElementParents = ($el, selector, limit)=>{
+    // Set up a parent array
+    const parents = [];
+    // Push each parent $elms to the array
+    while($el){
+        $el = $el.parentElement ?? undefined;
+        if ($el) {
+            if ($el.tagName === 'BODY' || $el.getAttribute('data-uid') === 'ROOT') {
+                break;
+            }
+            if (selector) {
+                if ($el.matches(selector)) {
+                    parents.push($el);
+                    if (limit && parents.length == limit) {
+                        return parents;
+                    }
+                }
+                continue;
+            }
+            parents.push($el);
+            if (limit && parents.length == limit) {
+                return parents;
+            }
+        }
+    }
+    // Return our parent array
+    return parents;
+};
+const getChildrenByAttrSelector = ($el, attrSelector)=>{
+    const childLen = $el.children.length;
+    if (childLen) {
+        for(let i = 0; i < childLen; i++){
+            const children = $el.children[i];
+            if (children) {
+                const is = children.getAttribute(attrSelector);
+                if (is) {
+                    return children;
+                }
+            }
+        }
+    }
+};
+const isOverParent = ({ current, parent: parent1, index, revert })=>{
+    for(let i = 0; i < index; i++){
+        let is = current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent1.top && current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent1.top + parent1.height || current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent1.top + parent1.height && current.top - (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent1.top;
+        if (revert) {
+            is = current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent1.bottom && current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent1.bottom - parent1.height || current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i >= parent1.bottom - parent1.height && current.bottom + (TOOLBAR_HOVER_HEIGHT - 1) * i <= parent1.bottom;
+        }
+        if (is) return true;
+    }
+    return false;
+};
+const waitForElementToExist = (selector, timeout = 200)=>{
+    return new Promise((resolve)=>{
+        const intervalID = setInterval(()=>{
+            const el = document.querySelector(selector);
+            if (el) {
+                clearInterval(intervalID);
+                clearTimeout(timeoutID);
+                resolve(el);
+            }
+        }, 50);
+        const timeoutID = setTimeout(()=>{
+            clearInterval(intervalID);
+            clearTimeout(timeoutID);
+            resolve(null);
+        }, timeout);
+    });
+};
+const notVisible = (el)=>{
+    const overflow = getComputedStyle(el).overflow;
+    return overflow !== 'visible';
+};
+const isSection = (el)=>{
+    const tag = el.getAttribute('data-component-tag');
+    return tag === 'Section';
+};
+const isLayoutElement = (el)=>{
+    const tag = el.getAttribute('data-component-tag');
+    return tag === 'Row' || tag === 'Product';
+};
+const isOverToolbarPosition = (el, parent1)=>{
+    const rect = el.getBoundingClientRect();
+    const rectP = parent1.getBoundingClientRect();
+    // 32px = toolbar active height
+    return rect.top - rectP.top < TOOLBAR_ACTIVE_HEIGHT + 1;
+};
+const findOverflowParent = (element, initEl)=>{
+    const thisEl = element;
+    const origEl = initEl || thisEl;
+    if (!thisEl) return;
+    if (isSection(thisEl)) return;
+    if (notVisible(thisEl) && isOverToolbarPosition(initEl, thisEl)) return thisEl;
+    if (thisEl.parentElement) {
+        return findOverflowParent(thisEl.parentElement, origEl);
+    } else {
+        return;
+    }
 };
 var Toolbar$1 = /*#__PURE__*/ react.memo(Toolbar);