@gem-sdk/core 1.42.7 → 1.43.0-dev.100

package/dist/esm/components/ai-generator/AIGenContentLoading.js

@@ -0,0 +1,83 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { AIIcon } from './icons/AIIcon.js';
+
+function getRandomArbitrary(min, max) {
+    const randomNum = Math.random();
+    return randomNum * (max - min) + min;
+}
+const AIGenContentLoading = ({ ...props })=>{
+    const [isGenerating, setIsGenerating] = useState(false);
+    const [time, setTime] = useState(0);
+    const interval = useRef(null);
+    const onGenerateContentStatus = useCallback((e)=>{
+        const detail = e.detail;
+        if (detail?.generatingUid !== props.uid) {
+            return;
+        }
+        if (detail.status === 'loading') {
+            setIsGenerating(true);
+            return;
+        }
+        if (detail.status === 'success') {
+            setIsGenerating(false);
+            return;
+        }
+    }, [
+        props.uid
+    ]);
+    useEffect(()=>{
+        if (isGenerating) {
+            handleFakeLoading();
+        } else {
+            setTime(0);
+        }
+        return ()=>{
+            interval.current && clearInterval(interval.current);
+        };
+    }, [
+        isGenerating
+    ]);
+    const handleFakeLoading = ()=>{
+        setTime(0);
+        interval.current = setInterval(()=>{
+            setTime((time)=>{
+                const randomNum = getRandomArbitrary(0, 6);
+                return time >= 580 ? time : time + randomNum;
+            });
+        }, 50);
+    };
+    useEffect(()=>{
+        window.addEventListener('editor:ai-generate-content-status', onGenerateContentStatus);
+        return ()=>{
+            window.removeEventListener('editor:ai-generate-content-status', onGenerateContentStatus);
+        };
+    }, [
+        onGenerateContentStatus
+    ]);
+    return isGenerating ? /*#__PURE__*/ jsxs("div", {
+        className: "gp-absolute gp-top-0 gp-left-0 gp-w-full gp-h-full gp-bg-white gp-bg-opacity-70 gp-flex gp-justify-center gp-items-center gp-z-100 gp-gap-2",
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                className: "gp-absolute gp-left-0 gp-top-0 gp-z-2 gp-flex gp-h-full gp-w-full",
+                children: /*#__PURE__*/ jsxs("div", {
+                    className: `gp-relative gp-h-[2px] gp-w-full gp-overflow-hidden gp-rounded-md`,
+                    children: [
+                        /*#__PURE__*/ jsx("div", {
+                            className: "gp-absolute gp-h-full gp-w-full gp-rounded-md gp-bg-[#F4F4F4]"
+                        }),
+                        /*#__PURE__*/ jsx("div", {
+                            className: "gps-image-to-layout-progress-bar gp-absolute gp-h-full gp-rounded-md gp-transition-all",
+                            style: {
+                                width: `${time / 600 * 100}%`
+                            }
+                        })
+                    ]
+                })
+            }),
+            /*#__PURE__*/ jsx(AIIcon, {})
+        ]
+    }) : null;
+};
+
+export { AIGenContentLoading };

package/dist/esm/components/ai-generator/components/PickProduct.js

@@ -0,0 +1,217 @@
+import { jsxs, jsx } from 'react/jsx-runtime';
+import { useState, useRef, useMemo, useEffect } from 'react';
+import { SearchIcon } from '../icons/SearchIcon.js';
+import { useListProductQuery } from '../../../hooks/shop/use-products-query.js';
+import classNames from 'classnames';
+import 'zustand';
+import 'swr';
+import '@gem-sdk/adapter-shopify';
+import 'swr/mutation';
+import { useProductQuery } from '../../../hooks/shop/use-product-query.js';
+import 'vanilla-lazyload';
+import '../../../hooks/useCartUI.js';
+import 'react-transition-group';
+import '@gem-sdk/core';
+import 'dayjs';
+import '../../../helpers/convert.js';
+
+const PickProduct = (props)=>{
+    const LIMIT_PRODUCTS = 8;
+    const [productVariables, setProductVariables] = useState(!props.productId ? {
+        first: LIMIT_PRODUCTS
+    } : undefined);
+    const { data: productList, isLoading: isLoadingGetProducts, isValidating: isValidatingGetProducts, size: productsSize, setSize: setProductsSize } = useListProductQuery(productVariables, {
+        revalidateFirstPage: false
+    });
+    const { data: sectionProduct } = useProductQuery(props.productId);
+    const [activeProduct, setActiveProduct] = useState();
+    const [isShowChooseProduct, setIsShowChooseProduct] = useState(false);
+    const debounceSearch = useRef(null);
+    const debounceScroll = useRef(null);
+    const toggleChooseProduct = ()=>{
+        if (props.productId) return;
+        setIsShowChooseProduct(!isShowChooseProduct);
+    };
+    const chooseProduct = (product)=>{
+        setActiveProduct(product);
+        setIsShowChooseProduct(false);
+    };
+    const searchProduct = (e)=>{
+        debounceSearch.current && clearTimeout(debounceSearch.current);
+        debounceSearch.current = setTimeout(()=>{
+            const searchValue = e.target.value ?? '';
+            if (searchValue) {
+                setProductVariables({
+                    first: LIMIT_PRODUCTS,
+                    where: {
+                        titleContainsFold: searchValue
+                    }
+                });
+                return;
+            }
+            setProductVariables({
+                first: LIMIT_PRODUCTS
+            });
+        }, 200);
+    };
+    const handleOpenProductElementSettings = ()=>{
+        props.openProductSetting();
+    };
+    const handleLoadMore = (e)=>{
+        const target = e.target;
+        if (target.scrollHeight - target.scrollTop === target.clientHeight) {
+            debounceScroll.current && clearTimeout(debounceScroll.current);
+            debounceScroll.current = setTimeout(()=>{
+                setProductsSize(productsSize + 1);
+            }, 50);
+        }
+    };
+    const products = useMemo(()=>{
+        return productList?.reduce((acc, curr)=>{
+            return [
+                ...acc,
+                ...curr.products?.edges ?? []
+            ];
+        }, []) ?? [];
+    }, [
+        productList
+    ]);
+    useEffect(()=>{
+        if (products.length && !activeProduct && !props.productId) {
+            const firstProduct = products[0]?.node;
+            if (!firstProduct) return;
+            setActiveProduct({
+                id: firstProduct?.id,
+                name: firstProduct?.title,
+                image: firstProduct.featuredImage?.src
+            });
+        }
+    }, [
+        products,
+        activeProduct,
+        props.productId
+    ]);
+    useEffect(()=>{
+        if (activeProduct && activeProduct.name) {
+            props.changeProductName(activeProduct.name);
+        }
+    }, [
+        activeProduct,
+        props
+    ]);
+    useEffect(()=>{
+        if (sectionProduct) {
+            setActiveProduct({
+                id: sectionProduct.id,
+                name: sectionProduct.title,
+                image: sectionProduct.featuredImage?.src
+            });
+        }
+    }, [
+        sectionProduct
+    ]);
+    return /*#__PURE__*/ jsxs("div", {
+        className: "gp-flex gp-flex-col gp-gap-2",
+        children: [
+            /*#__PURE__*/ jsx("p", {
+                className: "gp-py-2 gp-text-xs",
+                children: "Product"
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "gp-relative",
+                children: [
+                    !isLoadingGetProducts || activeProduct ? /*#__PURE__*/ jsxs("button", {
+                        className: classNames({
+                            'gp-cursor-default': props.productId
+                        }, 'gp-flex gp-gap-2 gp-items-center gp-w-full gp-p-2 gp-rounded-lg gp-bg-[#333333] gp-text-xs'),
+                        onClick: toggleChooseProduct,
+                        children: [
+                            /*#__PURE__*/ jsx("img", {
+                                className: "gp-rounded-lg gp-w-10 gp-h-10",
+                                src: activeProduct?.image,
+                                alt: "product_image"
+                            }),
+                            /*#__PURE__*/ jsx("span", {
+                                className: "gp-truncate gp-max-w-[210px]",
+                                children: activeProduct?.name
+                            })
+                        ]
+                    }) : /*#__PURE__*/ jsx("div", {
+                        children: /*#__PURE__*/ jsx("span", {
+                            className: "gp-text-xs",
+                            children: "Getting products..."
+                        })
+                    }),
+                    props.productId && /*#__PURE__*/ jsx("div", {
+                        className: "gp-mt-2 gp-text-xs",
+                        children: /*#__PURE__*/ jsxs("p", {
+                            children: [
+                                "You can manage it in",
+                                ' ',
+                                /*#__PURE__*/ jsx("button", {
+                                    className: "gp-text-[#8AA4FF] gp-cursor-pointer hover:gp-underline",
+                                    onClick: handleOpenProductElementSettings,
+                                    children: "Product element"
+                                })
+                            ]
+                        })
+                    }),
+                    isShowChooseProduct && /*#__PURE__*/ jsxs("div", {
+                        className: "gp-absolute gp-w-full gp-top-16 gp-left-0 gp-rounded-lg gp-bg-[#333333] gp-p-2 gp-flex gp-flex-col gp-gap-2 gp-z-10",
+                        children: [
+                            /*#__PURE__*/ jsxs("div", {
+                                className: "gp-flex gp-items-center gp-gap-2 gp-p-2",
+                                children: [
+                                    /*#__PURE__*/ jsx(SearchIcon, {}),
+                                    /*#__PURE__*/ jsx("input", {
+                                        className: "gp-bg-transparent gp-w-full focus-visible:!gp-outline-none gp-text-xs",
+                                        placeholder: "Search product...",
+                                        onChange: searchProduct
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs("div", {
+                                className: "gp-max-h-[168px] gp-overflow-auto scrollbar:gp-w-1 scrollbar-thumb:gp-bg-[#999] scrollbar-thumb:gp-rounded-xl",
+                                onScroll: handleLoadMore,
+                                children: [
+                                    products?.map((item)=>{
+                                        return /*#__PURE__*/ jsxs("button", {
+                                            className: "gp-flex gp-p-2 hover:gp-bg-[#3B3B3B] gp-rounded-lg gp-cursor-pointer gp-gap-2 gp-items-center",
+                                            onClick: ()=>{
+                                                chooseProduct({
+                                                    id: item.node?.id,
+                                                    name: item.node?.title,
+                                                    image: item.node?.featuredImage?.src
+                                                });
+                                            },
+                                            children: [
+                                                /*#__PURE__*/ jsx("img", {
+                                                    className: "gp-rounded-lg gp-w-10 gp-h-10",
+                                                    src: item.node?.featuredImage?.src,
+                                                    alt: "product_image"
+                                                }),
+                                                /*#__PURE__*/ jsx("span", {
+                                                    className: "gp-truncate gp-max-w-[210px] gp-text-xs",
+                                                    children: item.node?.title
+                                                })
+                                            ]
+                                        }, item.node?.id);
+                                    }),
+                                    isLoadingGetProducts || isValidatingGetProducts && /*#__PURE__*/ jsx("div", {
+                                        className: "gp-p-2",
+                                        children: /*#__PURE__*/ jsx("span", {
+                                            className: "gp-text-xs",
+                                            children: "Getting products..."
+                                        })
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+};
+
+export { PickProduct };

package/dist/esm/components/ai-generator/components/ToneAndVoice.js

@@ -0,0 +1,75 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { useState, useEffect } from 'react';
+import { DropdownIcon, TickIcon } from '../icons/DropdownIcon.js';
+import classNames from 'classnames';
+
+const ToneAndVoice = (props)=>{
+    const listToneAndVoice = [
+        'Persuasive',
+        'Friendly',
+        'Professional',
+        'Casual'
+    ];
+    const [tone, setTone] = useState(listToneAndVoice[0]);
+    const [isShow, setIsShow] = useState(false);
+    const toggle = ()=>{
+        setIsShow(!isShow);
+    };
+    const setValue = (value)=>{
+        setTone(value);
+        setIsShow(false);
+    };
+    useEffect(()=>{
+        tone && props.changeToneAndVoice(tone);
+    }, [
+        tone,
+        props
+    ]);
+    return /*#__PURE__*/ jsx("div", {
+        children: /*#__PURE__*/ jsxs("div", {
+            className: "gp-flex gp-flex-col gp-gap-2",
+            children: [
+                /*#__PURE__*/ jsx("p", {
+                    className: "gp-py-2 gp-text-xs",
+                    children: "Tone and Voice"
+                }),
+                /*#__PURE__*/ jsxs("div", {
+                    className: "gp-relative",
+                    children: [
+                        /*#__PURE__*/ jsxs("button", {
+                            className: "gp-flex gp-justify-between gp-items-center gp-w-full gp-p-2 gp-rounded-lg gp-bg-[#333333] gp-text-xs",
+                            onClick: toggle,
+                            children: [
+                                tone,
+                                /*#__PURE__*/ jsx(DropdownIcon, {})
+                            ]
+                        }),
+                        isShow ? /*#__PURE__*/ jsx("div", {
+                            className: "gp-absolute gp-w-full gp-top-10 gp-left-0 gp-rounded-lg gp-bg-[#333333] gp-p-2 gp-flex gp-flex-col gp-gap-2 gp-z-10",
+                            children: listToneAndVoice.map((item)=>{
+                                return /*#__PURE__*/ jsxs("button", {
+                                    className: "gp-flex gp-p-2 hover:gp-bg-[#3B3B3B] gp-rounded-lg gp-cursor-pointer gp-gap-3 gp-items-center",
+                                    onClick: ()=>setValue(item),
+                                    children: [
+                                        /*#__PURE__*/ jsx("div", {
+                                            className: classNames({
+                                                'gp-invisible': tone !== item
+                                            }),
+                                            children: /*#__PURE__*/ jsx(TickIcon, {})
+                                        }),
+                                        /*#__PURE__*/ jsx("span", {
+                                            className: "gp-text-xs",
+                                            children: item
+                                        })
+                                    ]
+                                }, item);
+                            })
+                        }) : null
+                    ]
+                })
+            ]
+        })
+    });
+};
+
+export { ToneAndVoice };

package/dist/esm/components/ai-generator/hooks/useCheckingProductInside.js

@@ -0,0 +1,45 @@
+import { useState, useCallback, useEffect } from 'react';
+
+const useCheckingProductInside = (genTool, options)=>{
+    const [productElement, setProductElement] = useState({});
+    const checkSectionHasProduct = useCallback(()=>{
+        if (!genTool.current) {
+            setProductElement({
+                productId: '',
+                uid: ''
+            });
+            return;
+        }
+        const sectionEl = genTool.current?.closest('[data-component-tag="Section"]');
+        const productEl = sectionEl?.querySelector('[data-product-id]:not([data-product-id=""])');
+        const productId = productEl?.getAttribute('data-product-id');
+        const productElUid = productEl?.getAttribute('data-uid');
+        const productListOutSideProduct = productEl?.closest('[data-component-tag="ProductList"]');
+        if (productListOutSideProduct || !productId) {
+            setProductElement({
+                productId: '',
+                uid: ''
+            });
+            return;
+        }
+        setProductElement({
+            productId: productId ? 'gid://shopify/Product/' + productId : '',
+            uid: productElUid ?? ''
+        });
+    }, [
+        genTool
+    ]);
+    useEffect(()=>{
+        if (!options?.isEnabled) return;
+        checkSectionHasProduct();
+    }, [
+        options?.isEnabled,
+        checkSectionHasProduct
+    ]);
+    return {
+        productElement,
+        checkSectionHasProduct
+    };
+};
+
+export { useCheckingProductInside };

package/dist/esm/components/ai-generator/hooks/useFlipPopup.js

@@ -0,0 +1,108 @@
+import { useState, useCallback, useEffect } from 'react';
+
+const useFlipPopup = (isShowPopup, dom)=>{
+    const { genTool, genPopup, genPopupHeader, genButtonWrapper } = dom;
+    const [popupPositionY, setPopupPositionY] = useState('top');
+    const [popupPositionX, setPopupPositionX] = useState('left');
+    const [bodyMaxHeight, setBodyMaxHeight] = useState(null);
+    const [isValidating, setIsValidating] = useState(true);
+    const calculateMaxHeight = useCallback((currentPopupPositionY)=>{
+        const parentOverflow = genTool.current?.closest("[class~='gp-overflow-hidden']");
+        if (!parentOverflow || !genTool.current) {
+            return {
+                positionY: currentPopupPositionY,
+                maxHeight: null
+            };
+        }
+        const parentOverflowPos = parentOverflow.getBoundingClientRect();
+        const genToolPos = genTool.current.getBoundingClientRect();
+        const genToolHeaderHeight = genPopupHeader.current?.getBoundingClientRect().height || 0;
+        const genButtonHeight = genButtonWrapper.current?.getBoundingClientRect().height || 0;
+        const DISTANCE = 8;
+        const maxHeightForPositionTop = Math.max(parentOverflowPos.bottom - genToolPos.bottom - genToolHeaderHeight - genButtonHeight - DISTANCE, 0);
+        const maxHeightForPositionBottom = Math.max(genToolPos.top - parentOverflowPos.top - genToolHeaderHeight - genButtonHeight - DISTANCE, 0);
+        if (maxHeightForPositionBottom > maxHeightForPositionTop) {
+            return {
+                positionY: 'bottom',
+                maxHeight: maxHeightForPositionBottom
+            };
+        }
+        return {
+            positionY: 'top',
+            maxHeight: maxHeightForPositionTop
+        };
+    }, [
+        genTool,
+        genPopupHeader,
+        genButtonWrapper
+    ]);
+    const handleChangePopupPositionY = useCallback((posY)=>{
+        const { positionY: calcPosY, maxHeight } = calculateMaxHeight(posY);
+        setPopupPositionY(calcPosY);
+        setBodyMaxHeight(maxHeight);
+    }, [
+        calculateMaxHeight
+    ]);
+    const calculatePopupPositionY = useCallback(()=>{
+        if (!genTool.current || !genPopup.current) return;
+        const viewHeight = window.innerHeight;
+        const scrollHeight = document.documentElement.scrollHeight;
+        const scrollTop = document.documentElement.scrollTop;
+        const toolPos = genTool.current?.getBoundingClientRect();
+        const genPopupHeight = genPopup.current?.getBoundingClientRect().height;
+        const MIN_DISTANCE = 50;
+        if (scrollTop + toolPos.top + genPopupHeight >= scrollHeight - MIN_DISTANCE) {
+            handleChangePopupPositionY('bottom');
+            return;
+        }
+        if (toolPos.bottom + genPopupHeight > viewHeight) {
+            if (toolPos.top - genPopupHeight < 0) {
+                handleChangePopupPositionY('top');
+                return;
+            }
+            handleChangePopupPositionY('bottom');
+            return;
+        }
+        handleChangePopupPositionY('top');
+    }, [
+        genPopup,
+        genTool,
+        handleChangePopupPositionY
+    ]);
+    const calculatePopupPositionX = useCallback(()=>{
+        if (!genTool.current || !genPopup.current) return;
+        const viewWidth = window.innerWidth;
+        const toolPos = genTool.current?.getBoundingClientRect();
+        const genPopupWidth = genPopup.current?.getBoundingClientRect().width;
+        if (toolPos.left + genPopupWidth > viewWidth) {
+            setPopupPositionX('right');
+            return;
+        }
+        setPopupPositionX('left');
+    }, [
+        genPopup,
+        genTool
+    ]);
+    useEffect(()=>{
+        if (!isShowPopup) {
+            setIsValidating(true);
+            return;
+        }
+        setIsValidating(true);
+        calculatePopupPositionY();
+        calculatePopupPositionX();
+        setIsValidating(false);
+    }, [
+        isShowPopup,
+        calculatePopupPositionX,
+        calculatePopupPositionY
+    ]);
+    return {
+        isValidating,
+        bodyMaxHeight,
+        popupPositionY,
+        popupPositionX
+    };
+};
+
+export { useFlipPopup };

package/dist/esm/components/ai-generator/hooks/useGettingGenerateRequest.js

@@ -0,0 +1,35 @@
+import { useState } from 'react';
+
+const useGettingGenerateRequest = ()=>{
+    const [prompt, setPrompt] = useState('');
+    const [productName, setProductName] = useState('');
+    const [tone, setTone] = useState('');
+    const changePrompt = (value)=>{
+        const limit = 200;
+        setPrompt(value.slice(0, limit));
+    };
+    const changeProductName = (value)=>{
+        setProductName(value);
+    };
+    const changeTone = (value)=>{
+        setTone(value);
+    };
+    const getRequestBody = ()=>{
+        return {
+            prompt,
+            productName,
+            tone
+        };
+    };
+    return {
+        prompt,
+        changePrompt,
+        productName,
+        changeProductName,
+        tone,
+        changeTone,
+        getRequestBody
+    };
+};
+
+export { useGettingGenerateRequest };

package/dist/esm/components/ai-generator/hooks/useListenEventGenerate.js

@@ -0,0 +1,68 @@
+import { useState, useCallback, useEffect } from 'react';
+
+const useListenEventGenerate = (componentInfo)=>{
+    const { uid: componentUid, tag: componentTag } = componentInfo;
+    const [isGenerating, setIsGenerating] = useState(false);
+    const onGenerate = (body)=>{
+        const eventCreate = new CustomEvent('editor:toolbar:ai-generate-content', {
+            bubbles: true,
+            detail: {
+                componentUid: componentUid,
+                componentTag: componentTag,
+                genRequest: body
+            }
+        });
+        window.dispatchEvent(eventCreate);
+        setIsGenerating(true);
+        onNotifyStatus('loading');
+    };
+    const onNotifyStatus = (status)=>{
+        const eventNotifyStatus = new CustomEvent('editor:ai-generate-content-status', {
+            bubbles: true,
+            detail: {
+                status: status,
+                generatingUid: componentUid
+            }
+        });
+        window.dispatchEvent(eventNotifyStatus);
+    };
+    const onGenerateContentStatus = useCallback((e)=>{
+        const detail = e.detail;
+        if (detail?.generatingUid === componentUid && detail.status === 'success') {
+            setIsGenerating(false);
+        }
+    }, [
+        componentUid
+    ]);
+    const onOpenProductElementSettings = (productElementUid)=>{
+        const eventCreate = new CustomEvent('editor:toolbar:open-product-element', {
+            bubbles: true,
+            detail: {
+                productElementUid: productElementUid
+            }
+        });
+        window.dispatchEvent(eventCreate);
+    };
+    const goToPricing = ()=>{
+        const eventCreate = new CustomEvent('editor:toolbar:ai-gen-content-go-to-pricing', {
+            bubbles: true
+        });
+        window.dispatchEvent(eventCreate);
+    };
+    useEffect(()=>{
+        window.addEventListener('editor:ai-generate-content-status', onGenerateContentStatus);
+        return ()=>{
+            window.removeEventListener('editor:ai-generate-content-status', onGenerateContentStatus);
+        };
+    }, [
+        onGenerateContentStatus
+    ]);
+    return {
+        isGenerating,
+        onGenerate,
+        onOpenProductElementSettings,
+        goToPricing
+    };
+};
+
+export { useListenEventGenerate };