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

package/dist/esm/helpers/third-party/generateAppBlockConfigs.js

@@ -0,0 +1,32 @@
+import { loopComponent } from '../loop-component.js';
+import { getAppBlockConfig } from './getAppBlockConfig.js';
+
+const generateAppBlockConfigs = (component)=>{
+    const strComponent = JSON.stringify(component) || '';
+    if (!strComponent.includes('appBlockId')) return null;
+    const configs = [];
+    loopComponent(component, (component)=>{
+        const settings = component.settings || {};
+        const appBlockId = settings?.appBlockId || '';
+        if (!appBlockId) return;
+        const config = getAppBlockConfig(component.tag, appBlockId, settings);
+        if (!config) return;
+        configs.push(config);
+    });
+    if (!configs.length) return null;
+    return {
+        newBlocks: extractBlocks(configs),
+        newBlockOrder: extractBlockOrder(configs)
+    };
+};
+function extractBlocks(array) {
+    return array.reduce((acc, item)=>{
+        acc[item.key] = item.value;
+        return acc;
+    }, {});
+}
+function extractBlockOrder(array) {
+    return array.map((item)=>item.key);
+}
+
+export { generateAppBlockConfigs };

package/dist/esm/helpers/third-party/getAppBlockConfig.js

@@ -0,0 +1,45 @@
+import { composeSettingsByWidgetType, overrideSettings } from './appSetting.js';
+import { getAppBlockType } from './getAppBlockType.js';
+
+const listAppUpdateNewVersion = [
+    'Growave',
+    'Trustoo',
+    'LooxReviews'
+];
+const listThirdPartyRejectAppBlock = {
+    YotpoReviews: {
+        conditionToReject: 'settings?.version === "v1"'
+    },
+    Trustoo: {
+        conditionToReject: 'settings?.version === "v1"'
+    },
+    LooxReviews: {
+        conditionToReject: 'settings?.version === "v1"'
+    }
+};
+const getAppBlockConfig = (tag, appBlockId, settings)=>{
+    if (listThirdPartyRejectAppBlock[tag] && eval(listThirdPartyRejectAppBlock[tag]?.conditionToReject ?? '')) {
+        return;
+    }
+    let widgetType = settings?.widgetType;
+    if (listAppUpdateNewVersion.includes(tag)) {
+        widgetType = settings?.widgetTypeV2;
+    }
+    const appBlockType = getAppBlockType({
+        tag,
+        widgetType
+    });
+    const settingByWidget = composeSettingsByWidgetType[tag][settings?.widgetType];
+    const appSettings = overrideSettings(tag, settingByWidget, settings);
+    return {
+        key: appBlockId,
+        value: {
+            type: appBlockType,
+            ...settingByWidget && {
+                settings: appSettings
+            }
+        }
+    };
+};
+
+export { getAppBlockConfig };

package/dist/esm/helpers/third-party/getAppBlockType.js

@@ -0,0 +1,10 @@
+import { mapShopifyAppMeta } from './constant.js';
+
+const getAppBlockType = ({ tag, widgetType })=>{
+    const shopifyAppMeta = mapShopifyAppMeta[tag];
+    if (!shopifyAppMeta) return '';
+    const { appName, appId } = shopifyAppMeta;
+    return `shopify://apps/${appName}/blocks/${widgetType}/${appId}`;
+};
+
+export { getAppBlockType };

package/dist/esm/helpers/third-party/getAppBlocks.js

@@ -0,0 +1,28 @@
+import { addAppBlockId } from './addAppBlockId.js';
+import { generateAppBlockConfigs } from './generateAppBlockConfigs.js';
+import { mergeBlocks } from './mergeBlock.js';
+import { mergeBlockOrder } from './mergeBlockOrder.js';
+import { removeAllGPAppItemsFromBlocks, removeAllGPAppItemsFromBlockOrder } from './removeGPAppItems.js';
+
+const getAppBlocks = (section)=>{
+    const { blocks: currentBlock, block_order: currentBlockOrder } = JSON.parse(section?.appBlocks || '{}');
+    const component = JSON.parse(section?.component || '');
+    const componentWithAppBlockId = addAppBlockId(component);
+    const appBlockConfigs = generateAppBlockConfigs(componentWithAppBlockId);
+    if (!appBlockConfigs) {
+        if (!currentBlock || !currentBlockOrder) return {};
+        return {
+            blocks: removeAllGPAppItemsFromBlocks(currentBlock),
+            block_order: removeAllGPAppItemsFromBlockOrder(currentBlockOrder)
+        };
+    }
+    const { newBlocks, newBlockOrder } = appBlockConfigs;
+    const blocks = mergeBlocks(newBlocks, currentBlock);
+    const block_order = mergeBlockOrder(newBlockOrder, currentBlockOrder);
+    return {
+        blocks,
+        block_order
+    };
+};
+
+export { getAppBlocks };

package/dist/esm/helpers/third-party/mergeBlock.js

@@ -0,0 +1,17 @@
+function mergeBlocks(newBlocks, blocks) {
+    if (!blocks) return newBlocks;
+    const result = {};
+    // Add all non-gp_app blocks from the original blocks
+    for (const [key, value] of Object.entries(blocks)){
+        if (!key.startsWith('gp_app')) {
+            result[key] = value;
+        }
+    }
+    // Add all blocks from new-blocks
+    for (const [key, value] of Object.entries(newBlocks)){
+        result[key] = value;
+    }
+    return result;
+}
+
+export { mergeBlocks };

package/dist/esm/helpers/third-party/mergeBlockOrder.js

@@ -0,0 +1,45 @@
+import { THIRD_PARTY_APP_BLOCK_ID_PREFIX } from './constant.js';
+
+function isGpAppItem(item) {
+    if (!item) return false;
+    return item.startsWith(THIRD_PARTY_APP_BLOCK_ID_PREFIX);
+}
+function filterCurrentOrder(currentOrder, newOrderSet) {
+    return currentOrder.filter((item)=>!isGpAppItem(item) || newOrderSet.has(item));
+}
+function processNonGpAppItem(item, resultOrder) {
+    resultOrder.push(item);
+}
+function processGpAppItems(newOrder, newOrderIndex, resultOrder) {
+    while(newOrderIndex < newOrder.length && isGpAppItem(newOrder[newOrderIndex])){
+        resultOrder.push(newOrder[newOrderIndex]);
+        newOrderIndex++;
+    }
+    return newOrderIndex;
+}
+function addRemainingGpAppItems(newOrder, startIndex, resultOrder) {
+    for(let i = startIndex; i < newOrder.length; i++){
+        const item = newOrder[i];
+        if (item && isGpAppItem(item)) {
+            resultOrder.push(item);
+        }
+    }
+}
+function mergeBlockOrder(newOrder, currentOrder) {
+    if (!currentOrder) return newOrder;
+    const newOrderSet = new Set(newOrder);
+    const filteredCurrentOrder = filterCurrentOrder(currentOrder, newOrderSet);
+    const resultOrder = [];
+    let newOrderIndex = 0;
+    filteredCurrentOrder.forEach((item)=>{
+        if (!isGpAppItem(item)) {
+            processNonGpAppItem(item, resultOrder);
+            return;
+        }
+        newOrderIndex = processGpAppItems(newOrder, newOrderIndex, resultOrder);
+    });
+    addRemainingGpAppItems(newOrder, newOrderIndex, resultOrder);
+    return resultOrder;
+}
+
+export { mergeBlockOrder };

package/dist/esm/helpers/third-party/removeGPAppItems.js

@@ -0,0 +1,15 @@
+import { THIRD_PARTY_APP_BLOCK_ID_PREFIX } from './constant.js';
+
+const removeAllGPAppItemsFromBlocks = (blocks)=>{
+    for(const key in blocks){
+        if (key.startsWith(THIRD_PARTY_APP_BLOCK_ID_PREFIX)) {
+            delete blocks[key];
+        }
+    }
+    return blocks;
+};
+const removeAllGPAppItemsFromBlockOrder = (blockOrder)=>{
+    return blockOrder.filter((item)=>!item.includes(THIRD_PARTY_APP_BLOCK_ID_PREFIX));
+};
+
+export { removeAllGPAppItemsFromBlockOrder, removeAllGPAppItemsFromBlocks };

package/dist/esm/helpers/tracking/fpixel.js

@@ -1 +1,24 @@
-let pageview=()=>{window.fbq&&window.fbq("track","PageView")},event=(e,t={})=>{window.fbq&&window.fbq("track",e,t)},addToCart=e=>{window.fbq&&window.fbq("track","AddToCart",{content_ids:[e.id],content_name:e.name,content_category:e.category,content_type:"product",value:e.price,currency:e.currency})};export{addToCart,event,pageview};
+const pageview = ()=>{
+    if (!window.fbq) return;
+    window.fbq('track', 'PageView');
+};
+// https://developers.facebook.com/docs/facebook-pixel/advanced/
+const event = (name, options = {})=>{
+    if (!window.fbq) return;
+    window.fbq('track', name, options);
+};
+const addToCart = (product)=>{
+    if (!window.fbq) return;
+    window.fbq('track', 'AddToCart', {
+        content_ids: [
+            product.id
+        ],
+        content_name: product.name,
+        content_category: product.category,
+        content_type: 'product',
+        value: product.price,
+        currency: product.currency
+    });
+};
+
+export { addToCart, event, pageview };

package/dist/esm/helpers/tracking/gtag.js

@@ -1 +1,87 @@
-let pageview=(e,a)=>{window.gtag&&a&&window.gtag("config",a,{page_path:e}),window.ga&&window.ga("send","pageview",e)},addToCart=e=>{window.ga&&e&&(window.ga("ec:addProduct",{...e,id:e.sku,name:"Default Title"===e.variant?e.name:`${e.name} - ${e.variant}`,variant:"Default Title"===e.variant?e.name:e.variant}),window.ga("ec:setAction","add"),window.ga("send","event",{eventCategory:"EnhancedEcommerce",eventAction:"Added Product",nonInteraction:!0}))},productClick=e=>{window.ga&&(ga("ec:addProduct",{id:e.id,name:e.name,category:e.category,brand:e.brand,variant:e.variant}),ga("ec:setAction","click"),ga("send","event",{eventAction:"Click",eventCategory:"Product"}))},productDetail=e=>{e&&window.ga&&(ga("ec:addProduct",{brand:e.brand,category:e.category,id:e.id,name:e.name,variant:e.variant}),ga("ec:setAction","detail"),ga("send","event",{eventAction:"Detail",eventCategory:"Ecommerce",nonInteraction:1}))},removeFromCart=(e,a)=>{e&&window.ga&&(ga("ec:addProduct",{id:e.id,name:e.name,price:a}),ga("ec:setAction","remove"),ga("send","event",{eventAction:"Click",eventCategory:"Remove from cart"}))};export{addToCart,pageview,productClick,productDetail,removeFromCart};
+// https://developers.google.com/analytics/devguides/collection/gtagjs/pages
+const pageview = (url, trackingId)=>{
+    // GA 4
+    if (window.gtag && trackingId) {
+        window.gtag('config', trackingId, {
+            page_path: url
+        });
+    }
+    // GA 3
+    if (window.ga) {
+        window.ga('send', 'pageview', url);
+    }
+};
+/** Addition to cart events
+ * https://developers.google.com/analytics/devguides/collection/analyticsjs/enhanced-ecommerce#add-remove-cart
+ */ const addToCart = (product)=>{
+    // GA 3
+    if (!window.ga || !product) {
+        return;
+    }
+    window.ga('ec:addProduct', {
+        ...product,
+        id: product.sku,
+        name: product.variant === 'Default Title' ? product.name : `${product.name} - ${product.variant}`,
+        variant: product.variant === 'Default Title' ? product.name : product.variant
+    });
+    window.ga('ec:setAction', 'add');
+    window.ga('send', 'event', {
+        eventCategory: 'EnhancedEcommerce',
+        eventAction: 'Added Product',
+        nonInteraction: true
+    });
+};
+/** Product clicked event
+ * https://developers.google.com/analytics/devguides/collection/analyticsjs/enhanced-ecommerce#product-click
+ */ const productClick = (product)=>{
+    if (!window.ga) {
+        return;
+    }
+    ga('ec:addProduct', {
+        id: product.id,
+        name: product.name,
+        category: product.category,
+        brand: product.brand,
+        variant: product.variant
+    });
+    ga('ec:setAction', 'click');
+    ga('send', 'event', {
+        eventAction: 'Click',
+        eventCategory: 'Product'
+    });
+};
+/** Product viewed event
+ * https://developers.google.com/analytics/devguides/collection/analyticsjs/enhanced-ecommerce#measuring-actvities
+ */ const productDetail = (product)=>{
+    if (!product || !window.ga) return;
+    ga('ec:addProduct', {
+        brand: product.brand,
+        category: product.category,
+        id: product.id,
+        name: product.name,
+        variant: product.variant
+    });
+    ga('ec:setAction', 'detail');
+    ga('send', 'event', {
+        eventAction: 'Detail',
+        eventCategory: 'Ecommerce',
+        nonInteraction: 1
+    });
+};
+/** Removal from cart events
+ * https://developers.google.com/analytics/devguides/collection/analyticsjs/enhanced-ecommerce#add-remove-cart
+ */ const removeFromCart = (product, price)=>{
+    if (!product || !window.ga) return;
+    ga('ec:addProduct', {
+        id: product.id,
+        name: product.name,
+        price
+    });
+    ga('ec:setAction', 'remove');
+    ga('send', 'event', {
+        eventAction: 'Click',
+        eventCategory: 'Remove from cart'
+    });
+};
+
+export { addToCart, pageview, productClick, productDetail, removeFromCart };

package/dist/esm/helpers/tracking/tiktokpixel.js

@@ -1 +1,15 @@
-let addToCart=t=>{window?.ttq?.track&&window.ttq.track("AddToCart",{content_id:t.id,content_type:"product",content_name:t.name,quantity:t.quantity,price:t.price,value:(t.price??0)*(t.quantity??0),currency:t.currency})};export{addToCart};
+// @ts-nocheck
+const addToCart = (product)=>{
+    if (!window?.ttq?.track) return;
+    window.ttq.track('AddToCart', {
+        content_id: product.id,
+        content_type: 'product',
+        content_name: product.name,
+        quantity: product.quantity,
+        price: product.price,
+        value: (product.price ?? 0) * (product.quantity ?? 0),
+        currency: product.currency
+    });
+};
+
+export { addToCart };

package/dist/esm/helpers/typography.js

@@ -1,17 +1,149 @@
-import{getSingleColorVariable as o}from"./colors.js";import{removeNullUndefined as e,makeStyle as t,makeStyleResponsive as p}from"./make-style.js";let genTypoClass=o=>`gp-g-${o}`,composeTypographyCss=o=>{let e=o?.custom,{fontFamily:t,fontSize:p,fontStyle:a,fontWeight:s,lineHeight:i,letterSpacing:y}=e?.desktop??{};return`
-  ${t?`font-family: var(--g-font-${t}, ${t});`:""}
-  ${p?`font-size: ${p};`:""}
-  ${a?`font-style: ${a};`:""}
-  ${s?`font-weight: ${s};`:""}
-  ${y?`letter-spacing: ${y};`:""}
-  ${i?`line-height: ${i};`:""}
-  `},composeTypographyV2Css=(o,e)=>{let t=o?.custom,{fontFamily:p,fontSize:a,fontWeight:s,lineHeight:i,letterSpacing:y}=t??{},l=o?.attrs,{bold:n,italic:r,underline:g,transform:$}=l??{},c=e?"!important":"";return`
-  ${p?`font-family: var(--g-font-${p}, ${p}) ${c};`:""}
-  ${a?.desktop?`font-size: ${a?.desktop} ${c};`:""}
-  ${n?`font-weight: bold ${c};`:s?`font-weight: ${s} ${c};`:""}
-  ${y?`letter-spacing: ${y} ${c};`:""}
-  ${i?.desktop?`line-height: ${i?.desktop} ${c};`:""}
-  ${r?`font-style: italic ${c};`:""}
-  ${g?`text-decoration-line: underline ${c};`:""}
-  ${$?`text-transform: ${$} ${c};`:""}
-  `};function getCustomCSSByDevice(o,e){if(!o||!e)return{};let t="desktop"!==e&&e?`-${e}`:"",{fontFamily:p}=o?.[e]??{};return{[`--size${t}`]:o?.[e]?.fontSize,[`--lh${t}`]:o?.[e]?.lineHeight,[`--fs${t}`]:o?.[e]?.fontStyle,[`--ff${t}`]:p?`var(--g-font-${p}, ${p})`:void 0,[`--weight${t}`]:o?.[e]?.fontWeight,[`--ls${t}`]:o?.[e]?.letterSpacing}}let composeTypography=o=>o?e({...getCustomCSSByDevice(o,"desktop"),...getCustomCSSByDevice(o,"tablet"),...getCustomCSSByDevice(o,"mobile")}):{},composeTypographyV2=(o,a)=>o?e({...t({fs:a?.italic?void 0:o?.fontStyle,ff:o?.fontFamily?`var(--g-font-${o.fontFamily.replace(/ /g,"-")}, '${o.fontFamily}'), ${o.fallbackFontFamily}`:void 0,weight:a?.bold?void 0:o?.fontWeight,ls:o?.letterSpacing}),...p("size",o?.fontSize),...p("lh",o?.lineHeight)}):{},composeTypographyAttr=p=>p?e({...t({fs:p?.italic?"italic":void 0,weight:p?.bold?"bold":void 0,c:o(p?.color),tt:p?.transform,tdl:p?.underline?"underline":void 0})}):{},composeTypographyClassName=(o,e)=>o?o?.type&&!o.custom?genTypoClass(o.type):"":e?.type&&genTypoClass(e?.type),composeFallbackTypographyStyle=o=>["heading","heading-1","heading-2","heading-3","heading-4","heading-5","heading-6"].includes(o)?"var(--g-font-heading, heading)":"var(--g-font-body, body)",composeTypographyStyle=(o,e,t)=>{if(o){let e=composeFallbackTypographyStyle(o.type??"heading"),p={...o.custom,fallbackFontFamily:e};return{...composeTypographyV2(p,o.attrs),...!t&&composeTypographyAttr(o.attrs)}}return{...e?.type?{}:composeTypography(e?.custom)}};export{composeFallbackTypographyStyle,composeTypography,composeTypographyAttr,composeTypographyClassName,composeTypographyCss,composeTypographyStyle,composeTypographyV2,composeTypographyV2Css,genTypoClass};
+import { getSingleColorVariable } from './colors.js';
+import { removeNullUndefined, makeStyle, makeStyleResponsive } from './make-style.js';
+
+const genTypoClass = (name)=>{
+    return `gp-g-${name}`;
+};
+const composeTypographyCss = (typography)=>{
+    const typographyCustom = typography?.custom;
+    const { fontFamily, fontSize, fontStyle, fontWeight, lineHeight, letterSpacing } = typographyCustom?.desktop ?? {};
+    return `
+  ${fontFamily ? `fontFamily: ${composeFontFamilyTypographyV2({
+        fontFamily
+    })};` : ''}
+  ${fontSize ? `font-size: ${fontSize};` : ''}
+  ${fontStyle ? `font-style: ${fontStyle};` : ''}
+  ${fontWeight ? `font-weight: ${fontWeight};` : ''}
+  ${letterSpacing ? `letter-spacing: ${letterSpacing};` : ''}
+  ${lineHeight ? `line-height: ${lineHeight};` : ''}
+  `;
+};
+const composeTypographyV2Css = (typography, isImportant)=>{
+    const typographyCustom = typography?.custom;
+    const { fontFamily, fontSize, fontWeight, lineHeight, letterSpacing } = typographyCustom ?? {};
+    const typographyAttrs = typography?.attrs;
+    const { bold, italic, underline, transform } = typographyAttrs ?? {};
+    const composeImportant = isImportant ? '!important' : '';
+    return `
+  ${fontFamily ? `font-family: ${composeFontFamilyTypographyV2({
+        fontFamily,
+        type: typography?.type
+    })} ${composeImportant}` : ''};
+  ${fontSize?.desktop ? `font-size: ${fontSize?.desktop} ${composeImportant}` : ''};
+  ${bold ? `font-weight: bold ${composeImportant}` : fontWeight ? `font-weight: ${fontWeight} ${composeImportant}` : ''};
+  ${letterSpacing ? `letter-spacing: ${letterSpacing} ${composeImportant}` : ''};
+  ${lineHeight?.desktop ? `line-height: ${lineHeight?.desktop} ${composeImportant}` : ''};
+  ${italic ? `font-style: italic ${composeImportant}` : ''};
+  ${underline ? `text-decoration-line: underline ${composeImportant}` : ''};
+  ${transform ? `text-transform: ${transform} ${composeImportant}` : ''};
+  `;
+};
+function getCustomCSSByDevice(typography, device) {
+    if (!typography || !device) return {};
+    const suffix = device === 'desktop' || !device ? '' : `-${device}`;
+    const { fontFamily } = typography?.[device] ?? {};
+    return {
+        [`--size${suffix}`]: typography?.[device]?.fontSize,
+        [`--lh${suffix}`]: typography?.[device]?.lineHeight,
+        [`--fs${suffix}`]: typography?.[device]?.fontStyle,
+        [`--ff${suffix}`]: composeFontFamilyTypographyV2({
+            fontFamily
+        }),
+        [`--weight${suffix}`]: typography?.[device]?.fontWeight,
+        [`--ls${suffix}`]: typography?.[device]?.letterSpacing
+    };
+}
+const composeTypography = (typography)=>{
+    if (!typography) return {};
+    return removeNullUndefined({
+        ...getCustomCSSByDevice(typography, 'desktop'),
+        ...getCustomCSSByDevice(typography, 'tablet'),
+        ...getCustomCSSByDevice(typography, 'mobile')
+    });
+};
+const composeTypographyV2 = (value, attrs)=>{
+    if (!value) return {};
+    return removeNullUndefined({
+        ...makeStyle({
+            fs: !attrs?.italic ? value?.fontStyle : undefined,
+            ff: composeFontFamilyTypographyV2(value),
+            weight: !attrs?.bold ? value?.fontWeight : undefined,
+            ls: value?.letterSpacing
+        }),
+        ...makeStyleResponsive('size', value?.fontSize),
+        ...makeStyleResponsive('lh', value?.lineHeight)
+    });
+};
+const composeFontFamilyTypographyV2 = (value)=>{
+    const { fontFamily, isCustom, fallbackFontFamily, type } = value || {};
+    if (!fontFamily) {
+        return isCustom ? fallbackFontFamily : undefined;
+    }
+    if (typeof fontFamily === 'string') {
+        return getFontUsedByTypographyV2({
+            fontFamily,
+            fallbackFontFamily: value?.fallbackFontFamily || composeFallbackTypographyStyle(type ?? 'heading')
+        });
+    }
+    if (typeof fontFamily === 'object' && typeof fontFamily?.value === 'string') {
+        switch(fontFamily.type){
+            case 'theme':
+                return `var(${fontFamily?.value}), var(--g-font-body)`;
+            default:
+                return getFontUsedByTypographyV2({
+                    fontFamily: fontFamily.value,
+                    fallbackFontFamily: value?.fallbackFontFamily || composeFallbackTypographyStyle(type ?? 'heading')
+                });
+        }
+    }
+    return;
+};
+const getFontUsedByTypographyV2 = ({ fontFamily, fallbackFontFamily })=>{
+    if (fontFamily) {
+        return `var(--g-font-${fontFamily?.replace(/ /g, '-')}, '${fontFamily}'), ${fallbackFontFamily}`;
+    }
+    return;
+};
+const composeTypographyAttr = (attrs)=>{
+    if (!attrs) return {};
+    return removeNullUndefined({
+        ...makeStyle({
+            fs: attrs?.italic ? 'italic' : undefined,
+            weight: attrs?.bold ? 'bold' : undefined,
+            c: getSingleColorVariable(attrs?.color),
+            tt: attrs?.transform,
+            tdl: attrs?.underline ? 'underline' : undefined
+        })
+    });
+};
+const composeTypographyClassName = (typo, typography)=>{
+    return typo ? typo?.type && !isCustomTypo(typo.custom) ? genTypoClass(typo.type) : '' : typography?.type && genTypoClass(typography?.type);
+};
+const composeFallbackTypographyStyle = (tag)=>{
+    if (tag.toLocaleLowerCase().includes('heading')) {
+        return 'var(--g-font-heading, heading)';
+    }
+    return 'var(--g-font-body, body)';
+};
+const composeTypographyStyle = (typo, typography, disableAttr)=>{
+    if (typo) {
+        const fallbackFontFamily = composeFallbackTypographyStyle(typo.type ?? 'heading');
+        const customTypo = {
+            ...typo.custom,
+            fallbackFontFamily: fallbackFontFamily,
+            isCustom: isCustomTypo(typo.custom)
+        };
+        return {
+            ...composeTypographyV2(customTypo, typo.attrs),
+            ...!disableAttr && composeTypographyAttr(typo.attrs)
+        };
+    }
+    return {
+        ...!typography?.type ? composeTypography(typography?.custom) : {}
+    };
+};
+const isCustomTypo = (customTypo)=>{
+    return customTypo && Object.keys(customTypo).length > 1 || customTypo && Object.keys(customTypo).length === 1 && !customTypo.fontSize;
+};
+
+export { composeFallbackTypographyStyle, composeFontFamilyTypographyV2, composeTypography, composeTypographyAttr, composeTypographyClassName, composeTypographyCss, composeTypographyStyle, composeTypographyV2, composeTypographyV2Css, genTypoClass };

package/dist/esm/helpers/variant.js

@@ -1 +1,9 @@
-function checkInStock(t,n){return!!t&&(t?.inventoryQuantity&&t.inventoryQuantity>0&&!isDefaultVariant(t,n)||!t?.manageInventory||"CONTINUE"===t.inventoryPolicy)}function isDefaultVariant(t,n){return(n?.[0]?.selectedOptions.length??0)>1&&t?.title==="Default Title"}export{checkInStock};
+function checkInStock(variant, product) {
+    if (!variant) return false;
+    return variant?.inventoryQuantity && variant.inventoryQuantity > 0 && !isDefaultVariant(variant, product) || !variant?.manageInventory || variant.inventoryPolicy === 'CONTINUE';
+}
+function isDefaultVariant(variant, product) {
+    return Boolean(variant?.title === 'Default Title' && product?.options?.some((option)=>option.values.length > 1));
+}
+
+export { checkInStock };

package/dist/esm/hooks/animation/useAnimationActions.js

@@ -1 +1,37 @@
-import{useRef as r,useCallback as t}from"react";let useAnimationActions=()=>{let n=r(),e=t(r=>{n.current=r},[n]),o=t(()=>{if(n.current)for(let r of n.current)r.play()},[]),c=t(()=>{if(n.current)for(let r of n.current)r.cancel()},[]),i=t(r=>{if(n.current)for(let t of n.current)t.onfinish=r},[]);return{currentAnimation:n.current,setAnimation:e,playAnimation:o,cancelAnimation:c,setAnimationOnFinish:i}};export{useAnimationActions};
+import { useRef, useCallback } from 'react';
+
+const useAnimationActions = ()=>{
+    const listAnimations = useRef();
+    const setAnimation = useCallback((newListAnimations)=>{
+        listAnimations.current = newListAnimations;
+    }, [
+        listAnimations
+    ]);
+    const playAnimation = useCallback(()=>{
+        if (!listAnimations.current) return;
+        for (const animation of listAnimations.current){
+            animation.play();
+        }
+    }, []);
+    const cancelAnimation = useCallback(()=>{
+        if (!listAnimations.current) return;
+        for (const animation of listAnimations.current){
+            animation.cancel();
+        }
+    }, []);
+    const setAnimationOnFinish = useCallback((onFinish)=>{
+        if (!listAnimations.current) return;
+        for (const animation of listAnimations.current){
+            animation.onfinish = onFinish;
+        }
+    }, []);
+    return {
+        currentAnimation: listAnimations.current,
+        setAnimation,
+        playAnimation,
+        cancelAnimation,
+        setAnimationOnFinish
+    };
+};
+
+export { useAnimationActions };

package/dist/esm/hooks/animation/useAnimationConfig.js

@@ -1 +1,28 @@
-import{useMemo as e,useCallback as n}from"react";import{useCurrentDevice as t}from"../use-current-device.js";let useAnimationConfig=i=>{let a=t(),r=e(()=>i?.advanced?.animation?.[a],[a,i?.advanced?.animation]),o=n(()=>{let{trigger:e,triggerConfig:n}=r,{animation:t,setting:i}=n[e];return{type:t,setting:i[t]}},[r]),m=r?.enabled;return{isEnabledAnimation:m,getAnimationConfig:o}};export{useAnimationConfig};
+import { useMemo, useCallback } from 'react';
+import { useCurrentDevice } from '../use-current-device.js';
+
+const useAnimationConfig = (props)=>{
+    const currentDevice = useCurrentDevice();
+    const configByDevices = useMemo(()=>props?.advanced?.animation?.[currentDevice], [
+        currentDevice,
+        props?.advanced?.animation
+    ]);
+    const getAnimationConfig = useCallback(()=>{
+        const { trigger, triggerConfig } = configByDevices;
+        const { animation, setting } = triggerConfig[trigger];
+        return {
+            type: animation,
+            setting: setting[animation],
+            reverse: trigger === "hidden"
+        };
+    }, [
+        configByDevices
+    ]);
+    const isEnabledAnimation = configByDevices?.enabled;
+    return {
+        isEnabledAnimation,
+        getAnimationConfig
+    };
+};
+
+export { useAnimationConfig };

package/dist/esm/hooks/animation/useAnimationPreview.js

@@ -1 +1,29 @@
-import{useCallback as e}from"react";let useAnimationPreview=({props:i,playAnimation:t,cancelAnimation:r,setAnimationOnFinish:n,setToolbarActive:u})=>{let o=e(e=>{let{uid:o,isCancel:a}=e.detail;if(i.uid===o){if(r(),a){u(!0);return}t(),u(!1),n(()=>{u(!0)})}},[i.uid,r,t,u,n]);return{previewAnimation:o}};export{useAnimationPreview};
+import { useCallback } from 'react';
+
+const useAnimationPreview = ({ props, playAnimation, cancelAnimation, setAnimationOnFinish, setToolbarActive })=>{
+    const previewAnimation = useCallback((e)=>{
+        const { uid, isCancel } = e.detail;
+        if (props.uid !== uid) return;
+        cancelAnimation();
+        if (isCancel) {
+            setToolbarActive(true);
+            return;
+        }
+        playAnimation();
+        setToolbarActive(false);
+        setAnimationOnFinish(()=>{
+            setToolbarActive(true);
+        });
+    }, [
+        props.uid,
+        cancelAnimation,
+        playAnimation,
+        setToolbarActive,
+        setAnimationOnFinish
+    ]);
+    return {
+        previewAnimation
+    };
+};
+
+export { useAnimationPreview };