@gem-sdk/pages 2.0.0-dev.884 → 2.0.0-staging.118

package/dist/esm/libs/get-storefront-api.js

@@ -1 +1,10 @@
-let getStorefrontApi=(t,o)=>"BIGCOMMERCE"===o?`https://${t}.bigcommerce.com`:`https://${t}.myshopify.com/api/2022-07/graphql.json`;export{getStorefrontApi};
+const getStorefrontApi = (handle, provider)=>{
+    switch(provider){
+        case 'BIGCOMMERCE':
+            return `https://${handle}.bigcommerce.com`;
+        default:
+            return `https://${handle}.myshopify.com/api/2022-07/graphql.json`;
+    }
+};
+
+export { getStorefrontApi };

package/dist/esm/libs/getStaticPaths.js

@@ -1 +1,8 @@
-let getStaticPaths=async()=>({paths:[],fallback:!0});export{getStaticPaths};
+const getStaticPaths = async ()=>{
+    return {
+        paths: [],
+        fallback: true
+    };
+};
+
+export { getStaticPaths };

package/dist/esm/libs/google-fonts.js

@@ -1 +1,112 @@
-import{getFontsFromDataBuilder as e}from"./helpers/gen-fonts.js";let CHROME_UA="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36",IE_UA="Mozilla/5.0 (Windows NT 10.0; Trident/7.0; rv:11.0) like Gecko";async function getFontForUA(e,t){return fetch(e,{headers:{"User-Agent":t}}).then(e=>200===e.status?e.text():"")}let composeFonts=e=>{let t=e.filter((e,t,n)=>t===n.findIndex(t=>t.family===e.family));return t.map(t=>{let n=e.filter(e=>e.family===t.family).reduce((e,t)=>[...e,...t.variants],[]).filter((e,t,n)=>t===n.findIndex(t=>t===e));return{...t,variants:n}})},createFontUrl=(e,t)=>{let n=e.filter(e=>"google"===e.type||!e.type);if(!n.length)return;let r=new URLSearchParams,o=t?.display||"swap",a=n.filter((e,t,n)=>t===n.findIndex(t=>t.family===e.family)),l=composeFonts(a).map(e=>`${e.family.replace(/ /g,"+")}:${e.variants.join(",")}`).join("|");return r.append("family",l),r.append("display",o),t?.subset&&r.append("subset",t.subset),t?.effect&&r.append("effect",t.effect),`https://fonts.googleapis.com/css?${decodeURIComponent(r.toString())}`};async function getFonts(e,t,n=!0){let r=createFontUrl(e,t);if(!r)return"";try{if(n)return`@import url('${r}');`;let[e,t]=await Promise.all([getFontForUA(r,"Mozilla/5.0 (Windows NT 10.0; Trident/7.0; rv:11.0) like Gecko"),getFontForUA(r,"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36")]);return e+t}catch(e){return""}}let getFontFromGlobalStyle=e=>{if(!e)return"";try{let t=JSON.parse(e),n=t?.font??{},r=Object.entries(n).map(([,e])=>e);return getFonts(r)}catch{return""}};async function getFontStyleFromPageTemplate(t){let n=t.map(t=>getFonts(e(t.data)));return await Promise.all(n)}export{composeFonts,createFontUrl,getFontFromGlobalStyle,getFontStyleFromPageTemplate,getFonts};
+import { checkNotInOptionFont } from './helpers/check-option-font.js';
+import { getFontsFromDataBuilder } from './helpers/gen-fonts.js';
+
+const CHROME_UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36';
+const IE_UA = 'Mozilla/5.0 (Windows NT 10.0; Trident/7.0; rv:11.0) like Gecko';
+async function getFontForUA(url, UA) {
+    return fetch(url, {
+        headers: {
+            'User-Agent': UA
+        }
+    }).then((res)=>{
+        if (res.status === 200) {
+            return res.text();
+        }
+        return '';
+    });
+}
+const composeFonts = (fonts)=>{
+    const uniqFonts = fonts.filter((font, index, arr)=>{
+        return index === arr.findIndex((t)=>t.family === font.family);
+    });
+    return uniqFonts.map((font)=>{
+        const variants = fonts.filter((t)=>t.family === font.family).reduce((acc, t)=>{
+            return [
+                ...acc,
+                ...t.variants
+            ];
+        }, []).filter((t, index, arr)=>{
+            return index === arr.findIndex((v)=>v === t);
+        });
+        return {
+            ...font,
+            variants
+        };
+    });
+};
+const createFontUrl = (fonts, option, fontType)=>{
+    const mainFonts = fonts.filter((font)=>{
+        return !([
+            'bunny',
+            'google'
+        ].includes(font.type) && checkNotInOptionFont(font.family, fontType || 'google')) && (font.type === 'google' || font.type === 'bunny' || !font.type);
+    });
+    if (!mainFonts.length) return;
+    const params = new URLSearchParams();
+    const display = option?.display || 'swap';
+    const uniqFonts = mainFonts.filter((font, index, arr)=>{
+        return index === arr.findIndex((t)=>t.family === font.family);
+    });
+    const family = composeFonts(uniqFonts).map((font)=>{
+        return `${font.family.replace(/ /g, '+')}:${font.variants.join(',')}`;
+    }).join('|');
+    params.append('family', family);
+    params.append('display', display);
+    if (option?.subset) {
+        params.append('subset', option.subset);
+    }
+    if (option?.effect) {
+        params.append('effect', option.effect);
+    }
+    const bunnyFontUrl = `https://fonts.bunny.net/css?family=${family}`;
+    const googleFontUrl = `https://fonts.googleapis.com/css?${decodeURIComponent(params.toString())}`;
+    return fontType === 'bunny' ? bunnyFontUrl : googleFontUrl;
+};
+// eslint-disable-next-line max-params
+async function getFonts(fonts, option, isImportFontByUrl = true, fontType) {
+    /**
+   * The order of IE -> Chrome is important, other wise chrome starts loading woff1.
+   * CSS cascading 🤷‍♂️.
+   */ const url = createFontUrl(fonts, option, fontType);
+    if (!url) return '';
+    try {
+        if (isImportFontByUrl) return `@import url('${url}');`;
+        const [ie, chrome] = await Promise.all([
+            getFontForUA(url, IE_UA),
+            getFontForUA(url, CHROME_UA)
+        ]);
+        const maxSize = 50; // 50KB
+        const value = ie + chrome;
+        if (maxSize) {
+            const textEncoder = new TextEncoder();
+            const size = value ? textEncoder.encode(value).length : 0;
+            if (Math.ceil(size / 1024) >= maxSize) {
+                return `@import url('${url}');`;
+            }
+        }
+        return value;
+    } catch (e) {
+        return '';
+    }
+}
+const getFontFromGlobalStyle = (data, sourceFont)=>{
+    if (!data) return '';
+    try {
+        const globalStyle = JSON.parse(data);
+        const fontData = globalStyle?.font ?? {};
+        const fonts = Object.entries(fontData).map(([, value])=>{
+            return value;
+        });
+        return getFonts(fonts, undefined, undefined, sourceFont);
+    } catch  {
+        return '';
+    }
+};
+async function getFontStyleFromPageTemplate(pageTemplate, sourceFont) {
+    const fontStyle = pageTemplate.map((sectionData)=>{
+        return getFonts(getFontsFromDataBuilder(sectionData.data), undefined, undefined, sourceFont);
+    });
+    return await Promise.all(fontStyle);
+}
+
+export { composeFonts, createFontUrl, getFontFromGlobalStyle, getFontStyleFromPageTemplate, getFonts };

package/dist/esm/libs/helpers/check-option-font.js

@@ -0,0 +1,63 @@
+const listFontsNotInBunny = [
+    'Anton SC',
+    'Arsenal SC',
+    'Baskervville SC',
+    'Beiruti',
+    'Bodoni Moda SC',
+    'Bona Nova SC',
+    'Bungee Tint',
+    'Edu AU VIC WA NT Hand',
+    'Fustat',
+    'Ga Maamli',
+    'Kalnia Glaze',
+    'Maname',
+    'Matemasie',
+    'Material Icons',
+    'Material Icons Outlined',
+    'Material Icons Round',
+    'Material Icons Sharp',
+    'Material Icons Two Tone',
+    'Material Symbols Outlined',
+    'Material Symbols Rounded',
+    'Material Symbols Sharp',
+    'Moderustic',
+    'New Amsterdam',
+    'Playwrite AR',
+    'Playwrite AT',
+    'Playwrite BE VLG',
+    'Playwrite BE WAL',
+    'Playwrite CL',
+    'Playwrite CU',
+    'Playwrite CZ',
+    'Playwrite DK Loopet',
+    'Playwrite DK Uloopet',
+    'Playwrite HR',
+    'Playwrite HR Lijeva',
+    'Playwrite HU',
+    'Playwrite PE',
+    'SUSE',
+    'Sankofa Display',
+    'Wittgenstein',
+    'Zain'
+];
+const listFontsNotInGoogle = [
+    'Arima Madurai',
+    'Coda Caption',
+    'Fredoka One',
+    'Gentium Book Basic',
+    'Kantumruy',
+    'Merienda One',
+    'Source Sans Pro',
+    'Source Serif Pro',
+    'Briem Hand',
+    'Pushster'
+];
+const objectFont = {
+    bunny: listFontsNotInBunny,
+    google: listFontsNotInGoogle
+};
+const checkNotInOptionFont = (currentfont, type)=>{
+    return objectFont?.[type]?.includes(currentfont);
+};
+
+export { checkNotInOptionFont };

package/dist/esm/libs/helpers/common.js

@@ -1 +1,24 @@
-async function wait(e){return new Promise(t=>setTimeout(t,e))}let retryWithDelay=async(e,t)=>{let r=t?.retries??3,i=t?.delay??1e3;try{return await e()}catch(a){if(r<=0||t?.retryIf&&!t.retryIf(a))return Promise.reject(a);return await wait(i),retryWithDelay(e,{...t,retries:r-1,delay:i})}};export{retryWithDelay,wait};
+async function wait(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+const retryWithDelay = async (fn, config)=>{
+    const retries = config?.retries ?? 3;
+    const delay = config?.delay ?? 1000;
+    try {
+        return await fn();
+    } catch (err) {
+        if (retries <= 0 || config?.retryIf && !config.retryIf(err)) {
+            return Promise.reject(err);
+        }
+        //delay the next call
+        await wait(delay);
+        //recursively call the same func
+        return retryWithDelay(fn, {
+            ...config,
+            retries: retries - 1,
+            delay
+        });
+    }
+};
+
+export { retryWithDelay, wait };

package/dist/esm/libs/helpers/gen-css.js

@@ -1 +1,133 @@
-import{getShortName as e}from"@gem-sdk/core";import t from"deepmerge";let baseDevices={tablet:"1023px",mobile:"767px"},flattenObject=(e,t)=>Object.keys(e).reduce((r,o)=>{let i=t?`${t}-`:"";return"object"==typeof e[o]&&null!==e[o]&&Object.keys(e[o]).length>0?Object.assign(r,flattenObject(e[o],i+o)):r[i+o]=e[o],r},{}),devicesOrder=["desktop","tablet","mobile"],mapObject=t=>Object.entries(t??{}).reduce((t,[r,o])=>({...t,[e(r)]:"object"==typeof o?mapObject(o):o}),{}),getValueByDevice=(e,t)=>{let r={typography:Object.fromEntries(Object.entries(e?.typography??{}).map(([e,r])=>{let o={...r?.[t]};return o?(o.fontFamily&&(o.fontFamily=`var(--g-font-${o.fontFamily}, ${o.fontFamily})`),[e,o]):[e,void 0]})),spacing:Object.fromEntries(Object.entries(e?.spacing??{}).map(([e,r])=>[e,r?.[t]])),container:Object.fromEntries(Object.entries(e?.container??{}).map(([e,r])=>[e,r?.[t]])),font:Object.fromEntries(Object.entries(e?.font??{}).map(([e,t])=>[e,t?.family]))};return r},genCSSVariable=e=>Object.entries(mapObject(flattenObject(e))).map(([e,t])=>{if(void 0!==t)return["font-heading","font-body"].includes(e)?`--g-${e}: '${t}'`:`--g-${e}:${t}`}).filter(e=>void 0!==e).join(";"),genCSS=(e,r)=>{if(!e)return"";let o={};try{if(o="string"==typeof e?JSON.parse(e):e,r){let e=getValueByDevice(o,"desktop"),r=getValueByDevice(o,"mobile"),i=t(e,r);i.color=o.color,i.radius=o.radius;let n=genCSSVariable(i);return`:root{${n}}`}return devicesOrder.map(e=>{let t=getValueByDevice(o,e);"desktop"===e&&(t.color=o.color,t.radius=o.radius);let r=genCSSVariable(t);return"desktop"===e?`:root{${r}}`:`@media (max-width: ${baseDevices[e]}) {:root{${r}}}`}).join("\n")}catch{return""}};export{genCSS};
+import { getShortName } from '@gem-sdk/core';
+import merge from 'deepmerge';
+
+const baseDevices = {
+    tablet: '1023px',
+    mobile: '767px'
+};
+const devicesOrder = [
+    'desktop',
+    'tablet',
+    'mobile'
+];
+const flattenObject = (obj, prefix)=>{
+    return Object.keys(obj).reduce((acc, k)=>{
+        const pre = prefix ? `${prefix}-` : '';
+        if (typeof obj[k] === 'object' && obj[k] !== null && Object.keys(obj[k]).length > 0) Object.assign(acc, flattenObject(obj[k], pre + k));
+        else acc[pre + k] = obj[k];
+        return acc;
+    }, {});
+};
+const mapObject = (obj)=>{
+    return Object.entries(obj ?? {}).reduce((acc, [k, v])=>{
+        return {
+            ...acc,
+            [getShortName(k)]: typeof v === 'object' ? mapObject(v) : v
+        };
+    }, {});
+};
+const getValueByDevice = (data, device)=>{
+    const deviceData = {
+        typography: Object.fromEntries(Object.entries(data?.typography ?? {}).map(([key, value])=>{
+            const typo = {
+                ...value?.[device]
+            };
+            if (!typo) return [
+                key,
+                undefined
+            ];
+            if (typo.fontFamily) {
+                typo.fontFamily = `var(--g-font-${typo.fontFamily}, ${typo.fontFamily})`;
+            }
+            return [
+                key,
+                typo
+            ];
+        })),
+        spacing: Object.fromEntries(Object.entries(data?.spacing ?? {}).map(([key, value])=>{
+            return [
+                key,
+                value?.[device]
+            ];
+        })),
+        container: Object.fromEntries(Object.entries(data?.container ?? {}).map(([key, value])=>{
+            return [
+                key,
+                value?.[device]
+            ];
+        })),
+        font: Object.fromEntries(Object.entries(data?.font ?? {}).map(([key, value])=>{
+            return [
+                key,
+                value?.family
+            ];
+        })),
+        theme: {
+            font: Object.fromEntries(Object.entries(data?.theme?.font ?? {}).map(([key, value])=>{
+                return [
+                    key,
+                    value?.family
+                ];
+            }))
+        }
+    };
+    return deviceData;
+};
+const quoteFontName = (font)=>{
+    if ([
+        'sans-serif'
+    ].includes(font)) {
+        return font;
+    }
+    return `'${font}'`;
+};
+const genCSSVariable = (deviceData)=>{
+    return Object.entries(mapObject(flattenObject(deviceData))).map(([key, value])=>{
+        if (value === undefined) return undefined;
+        if ([
+            'font-heading',
+            'font-body',
+            'theme-font-heading',
+            'theme-font-body'
+        ].includes(key)) {
+            return `--g-${key}: ${quoteFontName(value)}`;
+        }
+        return `--g-${key}:${value}`;
+    }).filter((v)=>v !== undefined).join(';');
+};
+const genCSS = (input, mobileOnly)=>{
+    if (!input) return '';
+    let data = {};
+    try {
+        if (typeof input === 'string') {
+            data = JSON.parse(input);
+        } else {
+            data = input;
+        }
+        if (mobileOnly) {
+            const desktop = getValueByDevice(data, 'desktop');
+            const mobile = getValueByDevice(data, 'mobile');
+            const deviceData = merge(desktop, mobile);
+            deviceData.color = data.color;
+            deviceData.radius = data.radius;
+            const cssData = genCSSVariable(deviceData);
+            return `:root{${cssData}}`;
+        }
+        return devicesOrder.map((device)=>{
+            const deviceData = getValueByDevice(data, device);
+            if (device === 'desktop') {
+                deviceData.color = data.color;
+                deviceData.radius = data.radius;
+            }
+            const cssData = genCSSVariable(deviceData);
+            if (device === 'desktop') {
+                return `:root{${cssData}}`;
+            }
+            return `@media (max-width: ${baseDevices[device]}) {:root{${cssData}}}`;
+        }).join('\n');
+    } catch  {
+        return '';
+    }
+};
+
+export { genCSS };

package/dist/esm/libs/helpers/gen-fonts.js

@@ -1 +1,87 @@
-let getFontsFromDataBuilder=t=>{let e=[];for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o)){let i=t[o],n=i.styles,l=i.settings;getFontFromGroupSetting(e,n),getFontFromGroupSetting(e,l)}return e},getFontFromGroupSetting=(t,e)=>{for(let o in e)if(Object.prototype.hasOwnProperty.call(e,o)){let i=e[o];if(i){let e=i.custom?.fontFamily,o=i.custom?.fontVariants;if(o?.length||(o=[i.custom?.fontWeight]),e&&o?.length){let n=o.map(t=>"regular"===t?"400":t),l=i.custom?.fontWeight&&n.includes(i.custom?.fontWeight)?i.custom?.fontWeight:n[0];if(l){let o=t.find(t=>t.family==e&&t.variants.includes(l));if(!o){let o=t.find(t=>t.family==e);if(o)o.variants.push(l);else{let o=[l];"700"!==l&&n.includes("700")&&o.push("700"),t.push({family:e,variants:o,subsets:[],type:"google"})}}}}}}};export{getFontFromGroupSetting,getFontsFromDataBuilder};
+const getFontsFromDataBuilder = (dataBuilder)=>{
+    const fonts = [];
+    for(const uid in dataBuilder){
+        if (Object.prototype.hasOwnProperty.call(dataBuilder, uid)) {
+            const data = dataBuilder[uid];
+            const styles = data.styles;
+            const settings = data.settings;
+            getFontFromGroupSetting(fonts, styles);
+            getFontFromGroupSetting(fonts, settings);
+        }
+    }
+    return fonts;
+};
+const getFontFromGroupSetting = (fonts, groupSetting)=>{
+    const states = [
+        'normal',
+        'hover',
+        'focus',
+        'active',
+        'disabled',
+        'price',
+        'compareAtPrice'
+    ];
+    for(const attr in groupSetting){
+        if (Object.prototype.hasOwnProperty.call(groupSetting, attr)) {
+            const value = groupSetting[attr];
+            if (!value) continue;
+            getFontValue(fonts, value);
+            for (const state of states){
+                if (!value[state]) continue;
+                getFontValue(fonts, value[state]);
+            }
+        }
+    }
+};
+const getFontValue = (fonts, value)=>{
+    let customFontFamily = value.custom?.fontFamily;
+    if (typeof customFontFamily === 'string') {
+        customFontFamily = {
+            value: value.custom?.fontFamily || '',
+            type: 'google'
+        };
+    }
+    const fontFamily = customFontFamily?.value;
+    let customFontVariants = value.custom?.fontVariants;
+    if (!customFontVariants?.length) {
+        customFontVariants = [
+            value.custom?.fontWeight
+        ];
+    }
+    if (customFontFamily && customFontVariants?.length) {
+        const variants = customFontVariants.map((item)=>{
+            switch(item){
+                case 'regular':
+                    return '400';
+            }
+            return item;
+        });
+        const customFontWeight = value.custom?.fontWeight && variants.includes(value.custom?.fontWeight) ? value.custom?.fontWeight : variants[0];
+        if (customFontWeight) {
+            const isExist = fonts.find((item)=>item.family == fontFamily && item.variants.includes(customFontWeight));
+            if (!isExist) {
+                const isFontFamily = fonts.find((item)=>item.family == fontFamily);
+                if (isFontFamily) {
+                    isFontFamily.variants.push(customFontWeight);
+                } else {
+                    const fontVariants = [
+                        customFontWeight
+                    ];
+                    if (customFontWeight !== '700') {
+                        if (variants.includes('700')) {
+                            fontVariants.push('700'); // Auto add 700 for bold in editor inline
+                        }
+                    }
+                    fonts.push({
+                        family: fontFamily || '',
+                        variants: fontVariants,
+                        subsets: [],
+                        type: customFontFamily.type
+                    });
+                }
+            }
+        }
+    }
+};
+
+export { getFontFromGroupSetting, getFontsFromDataBuilder };

package/dist/esm/libs/helpers/generate-manifres.js

@@ -1 +1,3 @@
-let generateManifest=e=>`data:application/manifest+json,${encodeURIComponent(JSON.stringify(e))}`;export{generateManifest};
+const generateManifest = (data)=>`data:application/manifest+json,${encodeURIComponent(JSON.stringify(data))}`;
+
+export { generateManifest };

package/dist/esm/libs/helpers/get-fallback.js

@@ -1 +1,32 @@
-import{prefetchQueries as e}from"@gem-sdk/core";let getFallbackV2=async(t,a,l=!0)=>{let r=!!l&&!process.env.NEXT_PUBLIC_STOREFRONT_TOKEN,s=a.map(t=>e(t.data,{isSample:r,isStorefront:l})).flat(),c=await Promise.allSettled(s.map(({query:e,variables:a,func:l})=>l?l(t,a):e?t([e,a]):{})),m=s.reduce((e,{key:t},a)=>{let l=c[a];return l?.status==="fulfilled"?{...e,[t]:l.value}:e},{});return m};export{getFallbackV2};
+import { prefetchQueries } from '@gem-sdk/core';
+
+const getFallbackV2 = async (fetcher, data, isStorefront = true)=>{
+    const isSample = isStorefront ? !process.env.NEXT_PUBLIC_STOREFRONT_TOKEN : false;
+    const queries = data.map((v)=>prefetchQueries(v.data, {
+            isSample,
+            isStorefront
+        })).flat();
+    const datas = await Promise.allSettled(queries.map(({ query, variables, func })=>{
+        if (func) {
+            return func(fetcher, variables);
+        }
+        if (query) return fetcher([
+            query,
+            variables
+        ]);
+        return {};
+    }));
+    const fallback = queries.reduce((acc, { key }, index)=>{
+        const res = datas[index];
+        if (res?.status === 'fulfilled') {
+            return {
+                ...acc,
+                [key]: res.value
+            };
+        }
+        return acc;
+    }, {});
+    return fallback;
+};
+
+export { getFallbackV2 };

package/dist/esm/libs/helpers/normalize.js

@@ -1 +1,103 @@
-let normalizeBuilderData=e=>{let t={};function i(e,t={}){if(e){let{childrens:r,dateModified:n,editorConfigs:o,...a}=e;if("section"===a.type)t[a.uid]=a;else{let e=r?.map(e=>e?.uid)??[];t[a.uid]={...a,childrens:e},r&&r.map(e=>i(e,t))}}}return i(e,t),{...t}},orderSection=(e,t)=>{let i=t?.filter(t=>e?.some(e=>e?.id===t)),r=i?.map(t=>e?.find(e=>e?.id===t))??[],n=e?.filter(e=>(!e?.id||!i?.includes(e.id))&&!e?.deletedAt)??[];return r.concat(n)};function normalizePageSectionResponse(e,t){let i=orderSection(e,t),r=i.map(e=>{if(!e?.component)return!1;try{let t=JSON.parse(e.component);return t}catch{return!1}}).filter(Boolean);return normalizeBuilderData({uid:"ROOT",tag:"Root",childrens:r})}function normalizePageSectionResponseV2(e,t){let i=orderSection(e,t),r=i.map(e=>{if(!e?.component)return!1;try{let t=JSON.parse(e.component);return t}catch{return!1}}).filter(Boolean);return r.map(e=>({uid:e.uid,lazy:!!e.settings?.lazy,priority:!!e.settings?.priority,data:normalizeBuilderData(e)}))}let parseBuilderTemplateV2=e=>normalizePageSectionResponseV2([...e?.pageSections??[],...e?.themePageCustomSections??[]],e?.sectionPosition),parseBuilderTemplate=e=>normalizePageSectionResponse([...e?.pageSections??[],...e?.themePageCustomSections??[]],e?.sectionPosition),parseBuilderLibraryTemplate=e=>normalizePageSectionResponseV2([...e?.sections??[]],e?.sectionPosition);export{normalizeBuilderData,normalizePageSectionResponseV2,parseBuilderLibraryTemplate,parseBuilderTemplate,parseBuilderTemplateV2};
+const normalizeBuilderData = (data)=>{
+    const result = {};
+    function compose(cData, currData = {}) {
+        if (cData) {
+            const { childrens, dateModified, editorConfigs, ...rest } = cData;
+            if (rest.type === 'section') {
+                currData[rest.uid] = rest;
+            } else {
+                const items = childrens?.map((child)=>child?.uid) ?? [];
+                currData[rest.uid] = {
+                    ...rest,
+                    childrens: items
+                };
+                if (childrens) {
+                    childrens.map((child)=>compose(child, currData));
+                }
+            }
+        }
+    }
+    compose(data, result);
+    return {
+        ...result
+    };
+};
+const orderSection = (sections, orders)=>{
+    // Filter out sections that are not in the order list
+    const ids = orders?.filter((id)=>sections?.some((v)=>v?.id === id));
+    // Return the ordered sections
+    const orderedSections = ids?.map((id)=>sections?.find((v)=>v?.id === id)) ?? [];
+    // Return the sections that are not in the order list
+    const sectionsNotInOrder = sections?.filter((v)=>(!v?.id || !ids?.includes(v.id)) && !v?.deletedAt) ?? [];
+    // Return the ordered sections + the sections that are not in the order list
+    return orderedSections.concat(sectionsNotInOrder);
+};
+function normalizePageSectionResponse(sections, orders) {
+    const sortedSections = orderSection(sections, orders);
+    const childrens = sortedSections.map((item)=>{
+        if (!item?.component) return false;
+        try {
+            const data = JSON.parse(item.component);
+            return data;
+        } catch  {
+            return false;
+        }
+    }).filter(Boolean);
+    return normalizeBuilderData({
+        uid: 'ROOT',
+        tag: 'Root',
+        childrens
+    });
+}
+function normalizePageSectionResponseV2(sections, orders) {
+    const sortedSections = orderSection(sections, orders);
+    const childrens = sortedSections.map((item)=>{
+        if (!item?.component) return false;
+        try {
+            const data = JSON.parse(item.component);
+            return data;
+        } catch  {
+            return false;
+        }
+    }).filter(Boolean);
+    return childrens.map((v)=>{
+        return {
+            uid: v.uid,
+            lazy: Boolean(v.settings?.lazy),
+            priority: Boolean(v.settings?.priority),
+            data: normalizeBuilderData(v)
+        };
+    });
+}
+const parseBuilderTemplateV2 = (data)=>{
+    return normalizePageSectionResponseV2([
+        ...data?.pageSections ?? [],
+        ...data?.themePageCustomSections ?? []
+    ], data?.sectionPosition);
+};
+const parseBuilderTemplate = (data)=>{
+    return normalizePageSectionResponse([
+        ...data?.pageSections ?? [],
+        ...data?.themePageCustomSections ?? []
+    ], data?.sectionPosition);
+};
+const extractPageBackground = (data)=>{
+    try {
+        const pageBackgroundStr = data?.metafields?.find((item)=>item?.key === 'page_background')?.value;
+        return JSON.parse(pageBackgroundStr ?? '{}');
+    } catch  {
+        return {};
+    }
+};
+const parseBuilderLibraryTemplate = (data)=>{
+    return normalizePageSectionResponseV2([
+        ...data?.sections ?? []
+    ], data?.sectionPosition);
+};
+const parseShopLibraryPageTemplate = (data)=>{
+    return normalizePageSectionResponseV2([
+        ...data?.shopLibrarySections ?? []
+    ], data?.sectionPosition);
+};
+
+export { extractPageBackground, normalizeBuilderData, normalizePageSectionResponseV2, parseBuilderLibraryTemplate, parseBuilderTemplate, parseBuilderTemplateV2, parseShopLibraryPageTemplate };

package/dist/esm/libs/helpers/parse-json.js

@@ -1 +1,13 @@
-let parseJson=r=>{if(!r)return null;try{return JSON.parse(r)}catch(r){return null}},serializableJson=r=>JSON.parse(JSON.stringify(r));export{parseJson,serializableJson};
+const parseJson = (json)=>{
+    if (!json) return null;
+    try {
+        return JSON.parse(json);
+    } catch (e) {
+        return null;
+    }
+};
+const serializableJson = (props)=>{
+    return JSON.parse(JSON.stringify(props));
+};
+
+export { parseJson, serializableJson };

package/dist/esm/libs/helpers/user-agent.js

@@ -1 +1,5 @@
-function isBot(o){return/Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Chrome-Lighthouse|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver/i.test(o)}export{isBot};
+function isBot(input) {
+    return /Googlebot|Mediapartners-Google|AdsBot-Google|googleweblight|Storebot-Google|Google-PageRenderer|Chrome-Lighthouse|Bingbot|BingPreview|Slurp|DuckDuckBot|baiduspider|yandex|sogou|LinkedInBot|bitlybot|tumblr|vkShare|quora link preview|facebookexternalhit|facebookcatalog|Twitterbot|applebot|redditbot|Slackbot|Discordbot|WhatsApp|SkypeUriPreview|ia_archiver/i.test(input);
+}
+
+export { isBot };

package/dist/esm/libs/hooks/use-tracking-view.js

@@ -1 +1,41 @@
-import{PageViewUpDocument as e}from"@gem-sdk/core";import{useCallback as o,useEffect as r}from"react";let useTrackingView=(t,n,i)=>{let p=t||process.env.NEXT_PUBLIC_SHOP_TOKEN,s=process.env.NEXT_PUBLIC_API_URL,a=o(o=>{if(!s||!p)return;let r={pageHandle:o},t={"Content-Type":"application/json","X-GemX-Shop-Token":p};fetch(s,{method:"POST",headers:t,body:JSON.stringify({query:e,variables:r})}).finally(()=>{})},[s,p]);r(()=>{n&&!i&&a(n)},[n,a,i])};export{useTrackingView};
+'use client';
+import { PageViewUpDocument } from '@gem-sdk/core';
+import { useCallback, useEffect } from 'react';
+
+const useTrackingView = (token, handle, isFallback)=>{
+    const shopToken = token || process.env.NEXT_PUBLIC_SHOP_TOKEN;
+    const apiURL = process.env.NEXT_PUBLIC_API_URL;
+    const sendTracking = useCallback((handle)=>{
+        if (!apiURL || !shopToken) return;
+        const variables = {
+            pageHandle: handle
+        };
+        const headers = {
+            'Content-Type': 'application/json',
+            'X-GemX-Shop-Token': shopToken
+        };
+        fetch(apiURL, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                query: PageViewUpDocument,
+                variables
+            })
+        }).finally(()=>{
+        //
+        });
+    }, [
+        apiURL,
+        shopToken
+    ]);
+    useEffect(()=>{
+        if (!handle || isFallback) return;
+        sendTracking(handle);
+    }, [
+        handle,
+        sendTracking,
+        isFallback
+    ]);
+};
+
+export { useTrackingView };