@gem-sdk/core 1.5.17 → 1.5.22

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

@@ -3,58 +3,78 @@ import { getCollection } from './queries/get-collection.js';
 import { getProduct } from './queries/get-product.js';
 import { getProducts } from './queries/get-products.js';
 
-const prefetchQueries = (input, isSample) => {
-    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 };
-                data = {
-                    key: unstable_serialize(['query/product', variables]),
-                    func: getProduct,
-                    variables,
-                };
-                break;
-            }
-            case 'ProductList': {
-                if (item?.settings?.productSrc === 'Collection') {
-                    const variables = {
-                        id: item.settings?.collectionId ?? 'latest',
-                        numberOfProducts: item.settings?.numberOfProducts ?? 4,
-                        orderBy: item.settings?.orderBy,
-                        isSample,
-                    };
-                    data = {
-                        key: unstable_serialize(['query/collection', variables]),
-                        func: getCollection,
-                        variables,
-                    };
-                }
-                else {
-                    const variables = { ids: [...(item?.settings?.productIds ?? [])].sort(), isSample };
-                    data = {
-                        key: unstable_serialize(['query/products', 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;
-    }, []);
+const prefetchQueries = (input, isSample)=>{
+    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
+                    };
+                    data = {
+                        key: unstable_serialize([
+                            'query/product',
+                            variables
+                        ]),
+                        func: getProduct,
+                        variables
+                    };
+                    break;
+                }
+            case 'ProductList':
+                {
+                    if (item?.settings?.productSrc === 'Collection') {
+                        const variables = {
+                            id: item.settings?.collectionId ?? 'latest',
+                            numberOfProducts: item.settings?.numberOfProducts ?? 4,
+                            orderBy: item.settings?.orderBy,
+                            isSample
+                        };
+                        data = {
+                            key: unstable_serialize([
+                                'query/collection',
+                                variables
+                            ]),
+                            func: getCollection,
+                            variables
+                        };
+                    } else {
+                        const variables = {
+                            ids: [
+                                ...item?.settings?.productIds ?? []
+                            ].sort(),
+                            isSample
+                        };
+                        data = {
+                            key: unstable_serialize([
+                                'query/products',
+                                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 };

package/dist/esm/helpers/product.js

@@ -1,32 +1,28 @@
-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 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;
+    }, {});
 }
 
 export { getSelectedVariant, parseSelectedOption };

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

@@ -2,173 +2,185 @@ import { CollectionDetailFilterDocument } from '../../graphql/queries/collection
 import { ProductVariantsDocument } from '../../graphql/queries/product-variants.generated.js';
 import { isDefined } from '../is-defined.js';
 
-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':
-            return undefined;
-        default:
-            return undefined;
-    }
-}
-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 loopFetchCollection = async (fetcher, arg) => {
-    const productsPerPage = 8; // number of products per page
-    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 / productsPerPage);
-        while (currentPage <= pages && hasNextPage !== false) {
-            variables = {
-                firstVariant: 1,
-                firstMedia: 30,
-                orderBy: {
-                    field: 'UPDATED_AT',
-                    direction: 'DESC',
-                },
-                orderByMedia: {
-                    field: 'POSITION',
-                    direction: 'ASC',
-                },
-                firstProduct: calculateFirstProduct(arg.numberOfProducts, currentPage, productsPerPage),
-                ...(!arg.id || arg.id.toLowerCase() === 'latest'
-                    ? { where: { hasCollectionProducts: true, isSample: arg.isSample } }
-                    : { where: { baseID: arg.id } }),
-                orderByProduct: productSortedByOrder(arg.orderBy),
-                whereProduct: {
-                    isStorefront: true,
-                    isSample: arg.isSample,
-                },
-                productsAfter: productAfterFetcher,
-            };
-            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 }) => {
-    const initVariables = {
-        firstVariant: 100,
-        first: ids?.length || 1,
-        orderBy: {
-            field: 'UPDATED_AT',
-            direction: 'DESC',
-        },
-        where: {
-            isStorefront: true,
-            isSample,
-            ...(ids?.length && { baseIDIn: ids.sort() }),
-        },
-    };
-    const query = async (variables) => {
-        try {
-            const response = await fetcher([
-                ProductVariantsDocument,
-                variables,
-            ]);
-            return response;
-        }
-        catch {
-            return {};
-        }
-    };
-    return query(initVariables);
+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':
+            return undefined;
+        default:
+            return undefined;
+    }
+}
+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 loopFetchCollection = async (fetcher, arg)=>{
+    const productsPerPage = 8; // number of products per page
+    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 / productsPerPage);
+        while(currentPage <= pages && hasNextPage !== false){
+            variables = {
+                firstVariant: 1,
+                firstMedia: 30,
+                orderBy: {
+                    field: 'UPDATED_AT',
+                    direction: 'DESC'
+                },
+                orderByMedia: {
+                    field: 'POSITION',
+                    direction: 'ASC'
+                },
+                firstProduct: calculateFirstProduct(arg.numberOfProducts, currentPage, productsPerPage),
+                ...!arg.id || arg.id.toLowerCase() === 'latest' ? {
+                    where: {
+                        hasCollectionProducts: true,
+                        isSample: arg.isSample
+                    }
+                } : {
+                    where: {
+                        baseID: arg.id
+                    }
+                },
+                orderByProduct: productSortedByOrder(arg.orderBy),
+                whereProduct: {
+                    isStorefront: true,
+                    isSample: arg.isSample
+                },
+                productsAfter: productAfterFetcher
+            };
+            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  })=>{
+    const initVariables = {
+        firstVariant: 100,
+        first: ids?.length || 1,
+        orderBy: {
+            field: 'UPDATED_AT',
+            direction: 'DESC'
+        },
+        where: {
+            isStorefront: true,
+            isSample,
+            ...ids?.length && {
+                baseIDIn: ids.sort()
+            }
+        }
+    };
+    const query = async (variables)=>{
+        try {
+            const response = await fetcher([
+                ProductVariantsDocument,
+                variables
+            ]);
+            return response;
+        } catch  {
+            return {};
+        }
+    };
+    return query(initVariables);
 };
 
 export { calculateFirstProduct, getCollection };