@gem-sdk/core 1.13.42 → 1.14.0-dev.286

package/dist/esm/helpers/prefetch-queries.js

@@ -1,76 +1 @@
-import { unstable_serialize } from 'swr';
-import { getCollection } from './queries/get-collection.js';
-import { getProduct } from './queries/get-product.js';
-import { getProducts } from './queries/get-products.js';
-import { generateCollectionQueryKey, generateProductsQueryKey, generateProductQueryKey } from './query.js';
-
-const prefetchQueries = (input, options)=>{
-    const queries = [];
-    Object.keys(input).forEach((key)=>{
-        const item = input[key];
-        let data = undefined;
-        switch(item.tag){
-            case 'Product':
-                {
-                    if (item.settings?.isAuto) break;
-                    const variables = {
-                        id: item.settings?.productSetting?.productId ?? 'latest',
-                        isSample: options?.isSample,
-                        isStorefront: options?.isStorefront
-                    };
-                    data = {
-                        key: unstable_serialize(generateProductQueryKey(variables)),
-                        func: getProduct,
-                        variables
-                    };
-                    break;
-                }
-            case 'ProductList':
-                {
-                    const productSetting = item.settings?.productSetting;
-                    if (productSetting?.productSrc === 'Collection') {
-                        const variables = {
-                            id: productSetting?.collectionId ?? 'latest',
-                            numberOfProducts: item.settings?.numberOfProducts ?? 4,
-                            orderBy: item.settings?.orderBy,
-                            isSample: options?.isSample,
-                            isStorefront: options?.isStorefront
-                        };
-                        data = {
-                            key: unstable_serialize(generateCollectionQueryKey(variables)),
-                            func: getCollection,
-                            variables
-                        };
-                    } else {
-                        const variables = {
-                            ids: [
-                                ...productSetting?.productIds ?? []
-                            ].sort(),
-                            isSample: options?.isSample,
-                            isStorefront: options?.isStorefront
-                        };
-                        data = {
-                            key: unstable_serialize(generateProductsQueryKey(variables)),
-                            func: getProducts,
-                            variables
-                        };
-                    }
-                    break;
-                }
-        }
-        if (data) {
-            queries.push(data);
-        }
-    });
-    return queries.reduce((accumulator, current)=>{
-        if (!accumulator.some((x)=>x.key === current.key)) {
-            return [
-                ...accumulator,
-                current
-            ];
-        }
-        return accumulator;
-    }, []);
-};
-
-export { prefetchQueries };
+import{unstable_serialize as e}from"swr";import{getCollection as t}from"./queries/get-collection.js";import{getProduct as r}from"./queries/get-product.js";import{getProducts as s}from"./queries/get-products.js";import{generateCollectionQueryKey as o,generateProductsQueryKey as i,generateProductQueryKey as c}from"./query.js";let prefetchQueries=(u,l)=>{let n=[];return Object.keys(u).forEach(p=>{let f;let d=u[p];switch(d.tag){case"Product":{if(d.settings?.isAuto)break;let t={id:d.settings?.productSetting?.productId??"latest",isSample:l?.isSample,isStorefront:l?.isStorefront};f={key:e(c(t)),func:r,variables:t};break}case"ProductList":{let r=d.settings?.productSetting;if(r?.productSrc==="Collection"){let s={id:r?.collectionId??"latest",numberOfProducts:d.settings?.numberOfProducts??4,orderBy:d.settings?.orderBy,isSample:l?.isSample,isStorefront:l?.isStorefront};f={key:e(o(s)),func:t,variables:s}}else{let t={ids:[...r?.productIds??[]].sort(),isSample:l?.isSample,isStorefront:l?.isStorefront};f={key:e(i(t)),func:s,variables:t}}}}f&&n.push(f)}),n.reduce((e,t)=>e.some(e=>e.key===t.key)?e:[...e,t],[])};export{prefetchQueries};

package/dist/esm/helpers/product.js

@@ -1,41 +1 @@
-import { checkInStock } from './variant.js';
-
-function getSelectedVariant(variants, choices) {
-    /**
-   * Ensure the user has selected all the required options, not just some.
-   */ if (!variants || !variants.length || !choices || variants[0]?.selectedOptions.length !== Object.keys(choices).length) {
-        return;
-    }
-    return variants.find((variant)=>{
-        return Object.entries(choices).every(([name, value])=>{
-            return variant?.selectedOptions.some((option)=>option.name === name && option.value === value);
-        });
-    });
-}
-function parseSelectedOption(options) {
-    if (!options || options && options.length === 0) {
-        return;
-    }
-    return options.reduce((acc, { name, value })=>{
-        if (name && value) {
-            return {
-                ...acc,
-                [name]: value
-            };
-        }
-        return acc;
-    }, {});
-}
-function checkAvailableVariantInStock(variants, optionId, optionValue) {
-    return variants ? variants.some((item)=>{
-        if (item) {
-            const { selectedOptions } = item;
-            const opt = selectedOptions?.some((option)=>option?.name === optionId && option.value === optionValue);
-            const isInStock = checkInStock(item);
-            return opt && isInStock;
-        }
-        return false;
-    }) : false;
-}
-
-export { checkAvailableVariantInStock, getSelectedVariant, parseSelectedOption };
+import{checkInStock as e}from"./variant.js";function getSelectedVariant(e,t){if(e&&e.length&&t&&e[0]?.selectedOptions.length===Object.keys(t).length)return e.find(e=>Object.entries(t).every(([t,n])=>e?.selectedOptions.some(e=>e.name===t&&e.value===n)))}function parseSelectedOption(e){if(e&&(!e||0!==e.length))return e.reduce((e,{name:t,value:n})=>t&&n?{...e,[t]:n}:e,{})}function checkAvailableVariantInStock(t,n,r){return!!t&&t.some(t=>{if(t){let{selectedOptions:a}=t,i=a?.some(e=>e?.name===n&&e.value===r),c=e(t);return i&&c}return!1})}export{checkAvailableVariantInStock,getSelectedVariant,parseSelectedOption};

package/dist/esm/helpers/queries/get-collection.js

@@ -1,217 +1 @@
-import { CollectionDetailFilterDocument } from '../../graphql/queries/collection-detail-filter.generated.js';
-import { ProductVariantsDocument } from '../../graphql/queries/product-variants.generated.js';
-import { isDefined } from '../is-defined.js';
-
-const PRODUCT_PER_PAGE = 8; // number of products per page
-function productSortedByOrder(key) {
-    switch(key){
-        case 'TITLE_ASC':
-            return {
-                direction: 'ASC',
-                field: 'TITLE'
-            };
-        case 'TITLE_DESC':
-            return {
-                direction: 'DESC',
-                field: 'TITLE'
-            };
-        case 'CREATED_AT_ASC':
-            return {
-                direction: 'ASC',
-                field: 'CREATED_AT'
-            };
-        case 'CREATED_AT_DESC':
-            return {
-                direction: 'DESC',
-                field: 'CREATED_AT'
-            };
-        case 'none':
-        default:
-            return {
-                direction: 'ASC',
-                field: 'TITLE'
-            };
-    }
-}
-const getCollection = async (fetcher, arg)=>{
-    const collections = await loopFetchCollection(fetcher, arg);
-    if (!collections) {
-        throw new Error('collections not found');
-    }
-    // merge product collection variant
-    const mergeProducts = await mergeProductCollectionVariant(fetcher, collections, arg.isSample);
-    return mergeProducts;
-};
-const fetchCollection = async (fetcher, variables)=>{
-    return fetcher([
-        CollectionDetailFilterDocument,
-        variables
-    ]);
-};
-const calculateFirstProduct = (numberOfProducts, currentPage, productsPerPage)=>{
-    const remainingProducts = numberOfProducts - productsPerPage * currentPage;
-    if (numberOfProducts < productsPerPage) return numberOfProducts;
-    return remainingProducts > 0 ? productsPerPage : productsPerPage + remainingProducts;
-};
-const chunkArray = (array, size)=>{
-    const chunked_arr = [];
-    let index = 0;
-    while(index < array.length){
-        chunked_arr.push(array.slice(index, size + index));
-        index += size;
-    }
-    return chunked_arr;
-};
-const loopFetchCollection = async (fetcher, arg)=>{
-    let variables; // variables of collection query
-    let productAfterFetcher; // product after of collection query
-    let dataCollection; // data of collection query
-    let hasNextPage; //
-    let firstCollection;
-    let currentPage = 1;
-    if (arg.numberOfProducts) {
-        const pages = Math.ceil(arg.numberOfProducts / PRODUCT_PER_PAGE);
-        while(currentPage <= pages && hasNextPage !== false){
-            variables = {
-                firstVariant: 1,
-                firstMedia: 30,
-                orderBy: {
-                    field: 'PLATFORM_CREATED_AT',
-                    direction: 'DESC'
-                },
-                orderByMedia: {
-                    field: 'POSITION',
-                    direction: 'ASC'
-                },
-                firstProduct: calculateFirstProduct(arg.numberOfProducts, currentPage, PRODUCT_PER_PAGE),
-                ...!arg.id || arg.id.toLowerCase() === 'latest' ? {
-                    where: {
-                        hasCollectionProducts: true,
-                        isSample: arg.isSample
-                    }
-                } : {
-                    where: {
-                        baseID: arg.id
-                    }
-                },
-                orderByProduct: productSortedByOrder(arg.orderBy),
-                whereProduct: {
-                    status: 'ACTIVE',
-                    ...arg.isStorefront && {
-                        isStorefront: arg.isStorefront
-                    },
-                    isSample: arg.isSample
-                },
-                ...productAfterFetcher ? {
-                    productsAfter: productAfterFetcher
-                } : undefined
-            };
-            const pageData = await fetchCollection(fetcher, variables);
-            productAfterFetcher = pageData?.collections?.edges?.[0]?.node?.products?.pageInfo?.endCursor;
-            if (currentPage === 1) {
-                dataCollection = pageData; // set data of first page
-                firstCollection = dataCollection?.collections?.edges?.[0];
-            } else if (firstCollection?.node?.products && pageData?.collections?.edges?.[0]?.node?.products?.edges) {
-                // concat new values to the old ones
-                firstCollection.node.products = {
-                    pageInfo: pageData?.collections?.edges?.[0]?.node?.products?.pageInfo,
-                    edges: firstCollection.node?.products?.edges.concat(pageData?.collections?.edges?.[0]?.node?.products?.edges)
-                };
-            }
-            currentPage++;
-            // hasNextPage = false if there is no more pages then break the loop
-            if (!firstCollection?.node?.products?.pageInfo?.hasNextPage) {
-                hasNextPage = false;
-                break;
-            }
-        }
-        return dataCollection;
-    }
-};
-const mergeProductCollectionVariant = async (fetcher, collection, isSample)=>{
-    const node = collection?.collections?.edges?.[0]?.node;
-    if (!node) return collection;
-    const productList = node?.products?.edges;
-    const listBaseId = productList?.map((product)=>product?.node?.baseID).filter(isDefined);
-    const ProductListWithVariants = await fetchVariantsByBaseIds(fetcher, {
-        ids: listBaseId,
-        isSample
-    });
-    // mapping variant to product list in collections
-    const newProductList = productList?.map((product)=>{
-        const productVariants = ProductListWithVariants?.variants?.edges?.filter((productV)=>productV?.node?.id === product?.node?.id);
-        return {
-            ...product,
-            node: product.node ? {
-                ...product.node,
-                variants: product.node?.variants ? {
-                    ...product.node?.variants,
-                    edges: productVariants?.[0]?.node?.variants?.edges ?? []
-                } : undefined
-            } : undefined
-        };
-    }) ?? [];
-    const newCollection = {
-        ...collection,
-        collections: {
-            edges: [
-                {
-                    node: {
-                        ...node,
-                        products: {
-                            edges: newProductList
-                        }
-                    },
-                    cursor: undefined
-                }
-            ]
-        }
-    };
-    return newCollection;
-};
-const fetchVariantsByBaseIds = async (fetcher, { ids, isSample, isStorefront })=>{
-    const chunkedIds = chunkArray(ids ?? [], 8);
-    const defaultEdges = [];
-    const query = async (variables)=>{
-        try {
-            return await fetcher([
-                ProductVariantsDocument,
-                variables
-            ]);
-        } catch  {
-            return {};
-        }
-    };
-    const promises = chunkedIds.map((chunkedId)=>{
-        const variables = {
-            firstVariant: 100,
-            first: chunkedId.length,
-            orderBy: {
-                field: 'TITLE',
-                direction: 'ASC'
-            },
-            where: {
-                status: 'ACTIVE',
-                isSample,
-                ...isStorefront && {
-                    isStorefront
-                },
-                ...chunkedId.length && {
-                    baseIDIn: chunkedId.sort()
-                }
-            }
-        };
-        return query(variables);
-    });
-    const responses = await Promise.all(promises);
-    const edges = responses?.reduce((acc, response)=>{
-        return acc.concat(response?.variants?.edges ?? []);
-    }, defaultEdges);
-    return {
-        variants: {
-            edges
-        }
-    };
-};
-
-export { calculateFirstProduct, getCollection };
+import{CollectionDetailFilterDocument as e}from"../../graphql/queries/collection-detail-filter.generated.js";import{ProductVariantsDocument as t}from"../../graphql/queries/product-variants.generated.js";import{isDefined as r}from"../is-defined.js";let PRODUCT_PER_PAGE=8;function productSortedByOrder(e){switch(e){case"TITLE_ASC":case"none":default:return{direction:"ASC",field:"TITLE"};case"TITLE_DESC":return{direction:"DESC",field:"TITLE"};case"CREATED_AT_ASC":return{direction:"ASC",field:"PLATFORM_CREATED_AT"};case"CREATED_AT_DESC":return{direction:"DESC",field:"PLATFORM_CREATED_AT"}}}let getCollection=async(e,t)=>{let r=await loopFetchCollection(e,t);if(!r)throw Error("collections not found");let o=await mergeProductCollectionVariant(e,r,t.isSample);return o},fetchCollection=async(t,r)=>t([e,r]),calculateFirstProduct=(e,t,r)=>{let o=e-r*t;return e<r?e:o>0?r:r+o},chunkArray=(e,t)=>{let r=[],o=0;for(;o<e.length;)r.push(e.slice(o,t+o)),o+=t;return r},loopFetchCollection=async(e,t)=>{let r,o,d,i,n;let s=1;if(t.numberOfProducts){let a=Math.ceil(t.numberOfProducts/8);for(;s<=a&&!1!==i;){r={firstVariant:1,firstMedia:30,orderBy:{field:"PLATFORM_UPDATED_AT",direction:"DESC"},orderByMedia:{field:"POSITION",direction:"ASC"},firstProduct:calculateFirstProduct(t.numberOfProducts,s,8),...t.id&&"latest"!==t.id.toLowerCase()?{where:{baseID:t.id}}:{where:{isSample:t.isSample}},orderByProduct:productSortedByOrder(t.orderBy),whereProduct:{status:"ACTIVE",...t.isStorefront&&{isStorefront:t.isStorefront},isSample:t.isSample},...o?{productsAfter:o}:void 0};let a=await fetchCollection(e,r);if(o=a?.collections?.edges?.[0]?.node?.products?.pageInfo?.endCursor,1===s?(d=a,n=d?.collections?.edges?.[0]):n?.node?.products&&a?.collections?.edges?.[0]?.node?.products?.edges&&(n.node.products={pageInfo:a?.collections?.edges?.[0]?.node?.products?.pageInfo,edges:n.node?.products?.edges.concat(a?.collections?.edges?.[0]?.node?.products?.edges)}),s++,!n?.node?.products?.pageInfo?.hasNextPage){i=!1;break}}return d}},mergeProductCollectionVariant=async(e,t,o)=>{let d=t?.collections?.edges?.[0]?.node;if(!d)return t;let i=d?.products?.edges,n=i?.map(e=>e?.node?.baseID).filter(r),s=await fetchVariantsByBaseIds(e,{ids:n,isSample:o}),a=i?.map(e=>{let t=s?.variants?.edges?.filter(t=>t?.node?.id===e?.node?.id);return{...e,node:e.node?{...e.node,variants:e.node?.variants?{...e.node?.variants,edges:t?.[0]?.node?.variants?.edges??[]}:void 0}:void 0}})??[],c={...t,collections:{edges:[{node:{...d,products:{edges:a}},cursor:void 0}]}};return c},fetchVariantsByBaseIds=async(e,{ids:r,isSample:o,isStorefront:d})=>{let i=chunkArray(r??[],8),n=[],s=async r=>{try{return await e([t,r])}catch{return{}}},a=i.map(e=>{let t={firstVariant:100,first:e.length,orderBy:{field:"TITLE",direction:"ASC"},where:{status:"ACTIVE",isSample:o,...d&&{isStorefront:d},...e.length&&{baseIDIn:e.sort()}}};return s(t)}),c=await Promise.all(a),l=c?.reduce((e,t)=>e.concat(t?.variants?.edges??[]),n);return{variants:{edges:l}}};export{calculateFirstProduct,getCollection};

package/dist/esm/helpers/queries/get-collections.js

@@ -1,19 +1 @@
-import { CollectionsDocument } from '../../graphql/queries/collections.generated.js';
-
-const getCollections = async (fetcher, variable)=>{
-    const collections = await fetchCollections(fetcher, variable ?? {});
-    if (!collections) {
-        throw new Error('Collection not found');
-    }
-    return {
-        ...collections
-    };
-};
-const fetchCollections = async (fetcher, variables)=>{
-    return fetcher([
-        CollectionsDocument,
-        variables
-    ]);
-};
-
-export { getCollections };
+import{CollectionsDocument as e}from"../../graphql/queries/collections.generated.js";let getCollections=async(e,o)=>{let t=await fetchCollections(e,o??{});if(!t)throw Error("Collection not found");return{...t}},fetchCollections=async(o,t)=>o([e,t]);export{getCollections};

package/dist/esm/helpers/queries/get-product-by-slug.js

@@ -1,123 +1 @@
-import { ProductLittleDetailDocument } from '../../graphql/queries/product-little-detail.generated.js';
-import { ProductMediasDocument } from '../../graphql/queries/product-medias.generated.js';
-import { ProductVariantsDocument } from '../../graphql/queries/product-variants.generated.js';
-
-const getProductBySlug = async (fetcher, slug)=>{
-    const [product, variants, medias] = await Promise.all([
-        fetchProduct(fetcher, slug),
-        fetchVariants(fetcher, slug),
-        fetchMedias(fetcher, slug)
-    ]);
-    if (!product) {
-        throw new Error('Product not found');
-    }
-    return {
-        ...product,
-        variants: {
-            edges: variants
-        },
-        medias: {
-            edges: medias
-        }
-    };
-};
-const orderBy = {
-    field: 'PLATFORM_UPDATED_AT',
-    direction: 'DESC'
-};
-const fetchProduct = async (fetcher, handle, isStorefront)=>{
-    const variables = {
-        orderBy,
-        where: {
-            status: 'ACTIVE',
-            handle,
-            ...isStorefront && {
-                isStorefront
-            }
-        }
-    };
-    const response = await fetcher([
-        ProductLittleDetailDocument,
-        variables
-    ]);
-    return response.product?.edges?.[0]?.node;
-};
-const fetchVariants = async (fetcher, handle, isStorefront)=>{
-    const initVariables = {
-        orderBy,
-        orderByVariant: {
-            field: 'POSITION',
-            direction: 'ASC'
-        },
-        where: {
-            status: 'ACTIVE',
-            handle,
-            ...isStorefront && {
-                isStorefront
-            }
-        }
-    };
-    const query = async (variables, olds)=>{
-        try {
-            const response = await fetcher([
-                ProductVariantsDocument,
-                variables
-            ]);
-            const product = response.variants?.edges?.[0];
-            const items = olds?.concat(product?.node?.variants?.edges ?? []);
-            if (product?.node?.variants?.pageInfo?.hasNextPage) {
-                return query({
-                    ...variables,
-                    afterVariant: product?.node?.variants?.pageInfo.endCursor
-                }, items);
-            }
-            return items ?? [];
-        } catch  {
-            return olds ?? [];
-        }
-    };
-    return query(initVariables, []);
-};
-const fetchMedias = async (fetcher, handle, isStorefront)=>{
-    const initVariables = {
-        orderBy,
-        where: {
-            status: 'ACTIVE',
-            handle,
-            ...isStorefront && {
-                isStorefront
-            }
-        },
-        orderByMedia: {
-            field: 'POSITION',
-            direction: 'ASC'
-        }
-    };
-    const query = async (variables)=>{
-        try {
-            const response = await fetcher([
-                ProductMediasDocument,
-                variables
-            ]);
-            const product = response.medias?.edges?.[0];
-            const items = product?.node?.medias?.edges ?? [];
-            if (product?.node?.medias?.pageInfo?.hasNextPage) {
-                try {
-                    const newData = await query({
-                        ...variables,
-                        afterMedia: product?.node?.medias?.pageInfo.endCursor
-                    });
-                    return items.concat(newData);
-                } catch  {
-                    return items;
-                }
-            }
-            return items;
-        } catch  {
-            return [];
-        }
-    };
-    return query(initVariables);
-};
-
-export { getProductBySlug };
+import{ProductLittleDetailDocument as e}from"../../graphql/queries/product-little-detail.generated.js";import{ProductMediasDocument as r}from"../../graphql/queries/product-medias.generated.js";import{ProductVariantsDocument as t}from"../../graphql/queries/product-variants.generated.js";let getProductBySlug=async(e,r)=>{let[t,a,d]=await Promise.all([fetchProduct(e,r),fetchVariants(e,r),fetchMedias(e,r)]);if(!t)throw Error("Product not found");return{...t,variants:{edges:a},medias:{edges:d}}},orderBy={field:"PLATFORM_UPDATED_AT",direction:"DESC"},fetchProduct=async(r,t,a)=>{let d={orderBy,where:{status:"ACTIVE",handle:t,...a&&{isStorefront:a}}},n=await r([e,d]);return n.product?.edges?.[0]?.node},fetchVariants=async(e,r,a)=>{let d={orderBy,orderByVariant:{field:"POSITION",direction:"ASC"},where:{status:"ACTIVE",handle:r,...a&&{isStorefront:a}}},n=async(r,a)=>{try{let d=await e([t,r]),i=d.variants?.edges?.[0],s=a?.concat(i?.node?.variants?.edges??[]);if(i?.node?.variants?.pageInfo?.hasNextPage)return n({...r,afterVariant:i?.node?.variants?.pageInfo.endCursor},s);return s??[]}catch{return a??[]}};return n(d,[])},fetchMedias=async(e,t,a)=>{let d={orderBy,where:{status:"ACTIVE",handle:t,...a&&{isStorefront:a}},orderByMedia:{field:"POSITION",direction:"ASC"}},n=async t=>{try{let a=await e([r,t]),d=a.medias?.edges?.[0],i=d?.node?.medias?.edges??[];if(d?.node?.medias?.pageInfo?.hasNextPage)try{let e=await n({...t,afterMedia:d?.node?.medias?.pageInfo.endCursor});return i.concat(e)}catch{}return i}catch{return[]}};return n(d)};export{getProductBySlug};

package/dist/esm/helpers/queries/get-product.js

@@ -1,150 +1 @@
-import { ProductLittleDetailDocument } from '../../graphql/queries/product-little-detail.generated.js';
-import { ProductMediasDocument } from '../../graphql/queries/product-medias.generated.js';
-import { ProductVariantsDocument } from '../../graphql/queries/product-variants.generated.js';
-
-const getProduct = async (fetcher, { id, isSample, isStorefront })=>{
-    const [product, variants, medias] = await Promise.all([
-        fetchProduct(fetcher, {
-            id,
-            isSample,
-            isStorefront
-        }),
-        fetchVariants(fetcher, {
-            id,
-            isSample,
-            isStorefront
-        }),
-        fetchMedias(fetcher, {
-            id,
-            isSample,
-            isStorefront
-        })
-    ]);
-    if (!product) {
-        throw new Error('Product not found');
-    }
-    return {
-        ...product,
-        variants: {
-            edges: variants
-        },
-        medias: {
-            edges: medias
-        }
-    };
-};
-const orderBy = {
-    field: 'CREATED_AT',
-    direction: 'DESC'
-};
-const fetchProduct = async (fetcher, { id, isSample, isStorefront })=>{
-    const variables = {
-        orderBy,
-        where: {
-            isSample,
-            ...isStorefront && {
-                isStorefront
-            },
-            ...(!id || id && id.toLowerCase() == 'latest') && {
-                status: 'ACTIVE'
-            },
-            ...id && id.toLowerCase() !== 'latest' && {
-                baseID: id
-            }
-        }
-    };
-    const response = await fetcher([
-        ProductLittleDetailDocument,
-        variables
-    ]);
-    return response.product?.edges?.[0]?.node;
-};
-const fetchVariants = async (fetcher, { id, isSample, isStorefront })=>{
-    const initVariables = {
-        orderBy,
-        where: {
-            isSample,
-            ...isStorefront && {
-                isStorefront
-            },
-            ...(!id || id && id.toLowerCase() == 'latest') && {
-                status: 'ACTIVE'
-            },
-            ...id && id.toLowerCase() !== 'latest' && {
-                baseID: id
-            }
-        },
-        orderByVariant: {
-            field: 'POSITION',
-            direction: 'ASC'
-        }
-    };
-    const query = async (variables, olds)=>{
-        try {
-            const response = await fetcher([
-                ProductVariantsDocument,
-                variables
-            ]);
-            const product = response.variants?.edges?.[0];
-            const items = olds?.concat(product?.node?.variants?.edges ?? []);
-            if (product?.node?.variants?.pageInfo?.hasNextPage) {
-                return query({
-                    ...variables,
-                    afterVariant: product?.node?.variants?.pageInfo.endCursor
-                }, items);
-            }
-            return items ?? [];
-        } catch  {
-            return olds ?? [];
-        }
-    };
-    return query(initVariables, []);
-};
-const fetchMedias = async (fetcher, { id, isSample, isStorefront })=>{
-    const initVariables = {
-        orderBy,
-        where: {
-            isSample,
-            ...isStorefront && {
-                isStorefront
-            },
-            ...(!id || id && id.toLowerCase() == 'latest') && {
-                status: 'ACTIVE'
-            },
-            ...id && id.toLowerCase() !== 'latest' && {
-                baseID: id
-            }
-        },
-        orderByMedia: {
-            field: 'POSITION',
-            direction: 'ASC'
-        }
-    };
-    const query = async (variables)=>{
-        try {
-            const response = await fetcher([
-                ProductMediasDocument,
-                variables
-            ]);
-            const product = response.medias?.edges?.[0];
-            const items = product?.node?.medias?.edges ?? [];
-            if (product?.node?.medias?.pageInfo?.hasNextPage) {
-                try {
-                    const newData = await query({
-                        ...variables,
-                        afterMedia: product?.node?.medias?.pageInfo.endCursor
-                    });
-                    return items.concat(newData);
-                } catch  {
-                    return items;
-                }
-            }
-            return items;
-        } catch  {
-            return [];
-        }
-    };
-    return query(initVariables);
-};
-
-export { fetchMedias, fetchVariants, getProduct };
+import{ProductLittleDetailDocument as e}from"../../graphql/queries/product-little-detail.generated.js";import{ProductMediasDocument as t}from"../../graphql/queries/product-medias.generated.js";import{ProductVariantsDocument as r}from"../../graphql/queries/product-variants.generated.js";let getProduct=async(e,{id:t,isSample:r,isStorefront:a})=>{let[s,o,d]=await Promise.all([fetchProduct(e,{id:t,isSample:r,isStorefront:a}),fetchVariants(e,{id:t,isSample:r,isStorefront:a}),fetchMedias(e,{id:t,isSample:r,isStorefront:a})]);if(!s)throw Error("Product not found");return{...s,variants:{edges:o},medias:{edges:d}}},orderBy={field:"CREATED_AT",direction:"DESC"},fetchProduct=async(t,{id:r,isSample:a,isStorefront:s})=>{let o={orderBy,where:{isSample:a,...s&&{isStorefront:s},...(!r||r&&"latest"==r.toLowerCase())&&{status:"ACTIVE"},...r&&"latest"!==r.toLowerCase()&&{baseID:r}}},d=await t([e,o]);return d.product?.edges?.[0]?.node},fetchVariants=async(e,{id:t,isSample:a,isStorefront:s})=>{let o={orderBy,where:{isSample:a,...s&&{isStorefront:s},...(!t||t&&"latest"==t.toLowerCase())&&{status:"ACTIVE"},...t&&"latest"!==t.toLowerCase()&&{baseID:t}},orderByVariant:{field:"POSITION",direction:"ASC"}},d=async(t,a)=>{try{let s=await e([r,t]),o=s.variants?.edges?.[0],n=a?.concat(o?.node?.variants?.edges??[]);if(o?.node?.variants?.pageInfo?.hasNextPage)return d({...t,afterVariant:o?.node?.variants?.pageInfo.endCursor},n);return n??[]}catch{return a??[]}};return d(o,[])},fetchMedias=async(e,{id:r,isSample:a,isStorefront:s})=>{let o={orderBy,where:{isSample:a,...s&&{isStorefront:s},...(!r||r&&"latest"==r.toLowerCase())&&{status:"ACTIVE"},...r&&"latest"!==r.toLowerCase()&&{baseID:r}},orderByMedia:{field:"POSITION",direction:"ASC"}},d=async r=>{try{let a=await e([t,r]),s=a.medias?.edges?.[0],o=s?.node?.medias?.edges??[];if(s?.node?.medias?.pageInfo?.hasNextPage)try{let e=await d({...r,afterMedia:s?.node?.medias?.pageInfo.endCursor});return o.concat(e)}catch{}return o}catch{return[]}};return d(o)};export{fetchMedias,fetchVariants,getProduct};