@faststore/core 3.0.17 → 3.0.21

package/.next/server/chunks/350.js

@@ -0,0 +1,2834 @@
+"use strict";
+exports.id = 350;
+exports.ids = [350];
+exports.modules = {
+
+/***/ 8608:
+/***/ ((module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.a(module, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* unused harmony export stringify */
+/* harmony import */ var _graphql_tools_utils__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8722);
+var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_graphql_tools_utils__WEBPACK_IMPORTED_MODULE_0__]);
+_graphql_tools_utils__WEBPACK_IMPORTED_MODULE_0__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+
+const NAME = "cacheControl";
+const stringify = ({ scope = "private", sMaxAge = 0, staleWhileRevalidate = 0 }) => `${scope}, s-maxage=${sMaxAge}, stale-while-revalidate=${staleWhileRevalidate}`;
+const min = (a, b) => {
+    if (typeof a === "number" && typeof b === "number") {
+        return a > b ? b : a;
+    }
+    if (typeof a === "number") {
+        return a;
+    }
+    return b;
+};
+const minScope = (a, b) => {
+    if (typeof a === "string" && typeof b === "string") {
+        return a === "public" && b === "public" ? "public" : "private";
+    }
+    return a || b;
+};
+const directive = {
+    typeDefs: `directive @cacheControl(sMaxAge: Int, staleWhileRevalidate: Int, scope: String) on FIELD_DEFINITION`,
+    transformer: (schema) => (0,_graphql_tools_utils__WEBPACK_IMPORTED_MODULE_0__.mapSchema)(schema, {
+        [_graphql_tools_utils__WEBPACK_IMPORTED_MODULE_0__.MapperKind.OBJECT_FIELD]: (fieldConfig) => {
+            const cacheControl = (0,_graphql_tools_utils__WEBPACK_IMPORTED_MODULE_0__.getDirective)(schema, fieldConfig, NAME)?.[0];
+            if (cacheControl) {
+                const { sMaxAge, staleWhileRevalidate, scope } = cacheControl;
+                const resolver = fieldConfig.resolve;
+                fieldConfig.resolve = (obj, args, ctx, info) => {
+                    ctx.cacheControl = {
+                        sMaxAge: min(ctx.cacheControl?.sMaxAge, sMaxAge),
+                        staleWhileRevalidate: min(ctx.cacheControl?.staleWhileRevalidate, staleWhileRevalidate),
+                        scope: minScope(ctx.cacheControl?.scope, scope),
+                    };
+                    return resolver?.(obj, args, ctx, info);
+                };
+            }
+            return fieldConfig;
+        },
+    }),
+};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (directive);
+//# sourceMappingURL=cacheControl.js.map
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } });
+
+/***/ }),
+
+/***/ 7397:
+/***/ ((module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.a(module, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "E9": () => (/* binding */ getContextFactory),
+/* harmony export */   "T9": () => (/* reexport safe */ _platforms_errors__WEBPACK_IMPORTED_MODULE_3__.T9),
+/* harmony export */   "XD": () => (/* reexport safe */ _platforms_errors__WEBPACK_IMPORTED_MODULE_3__.XD),
+/* harmony export */   "yd": () => (/* binding */ getResolvers)
+/* harmony export */ });
+/* unused harmony exports getTypeDefs, getSchema */
+/* harmony import */ var _platforms_vtex__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(8815);
+/* harmony import */ var _typeDefs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(3999);
+/* harmony import */ var _directives_cacheControl__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(8608);
+/* harmony import */ var _platforms_errors__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(782);
+/* harmony import */ var _telemetry__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(941);
+var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_typeDefs__WEBPACK_IMPORTED_MODULE_1__, _directives_cacheControl__WEBPACK_IMPORTED_MODULE_2__]);
+([_typeDefs__WEBPACK_IMPORTED_MODULE_1__, _directives_cacheControl__WEBPACK_IMPORTED_MODULE_2__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);
+
+
+
+
+
+
+
+
+const platforms = {
+    vtex: {
+        getResolvers: _platforms_vtex__WEBPACK_IMPORTED_MODULE_0__/* .getResolvers */ .y,
+        getContextFactory: _platforms_vtex__WEBPACK_IMPORTED_MODULE_0__/* .getContextFactory */ .E,
+    },
+};
+const directives = [
+    _directives_cacheControl__WEBPACK_IMPORTED_MODULE_2__/* ["default"] */ .Z
+];
+const getTypeDefs = () => [typeDefs, ...directives.map(d => d.typeDefs)];
+const getResolvers = (options) => platforms[options.platform].getResolvers(options);
+const getContextFactory = (options) => platforms[options.platform].getContextFactory(options);
+const getSchema = async (options) => {
+    const schema = makeExecutableSchema({
+        resolvers: getResolvers(options),
+        typeDefs: getTypeDefs(),
+    });
+    return directives.reduce((s, d) => d.transformer(s), schema);
+};
+
+//# sourceMappingURL=index.js.map
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } });
+
+/***/ }),
+
+/***/ 782:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "T9": () => (/* binding */ isFastStoreError),
+/* harmony export */   "XD": () => (/* binding */ isNotFoundError),
+/* harmony export */   "dR": () => (/* binding */ NotFoundError),
+/* harmony export */   "oY": () => (/* binding */ BadRequestError)
+/* harmony export */ });
+/* unused harmony export isBadRequestError */
+class FastStoreError extends Error {
+    extensions;
+    constructor(extensions, message) {
+        super(message);
+        this.extensions = extensions;
+        this.name = 'FastStoreError';
+    }
+}
+class BadRequestError extends FastStoreError {
+    constructor(message) {
+        super({ status: 400, type: 'BadRequestError' }, message);
+    }
+}
+class NotFoundError extends FastStoreError {
+    constructor(message) {
+        super({ status: 404, type: 'NotFoundError' }, message);
+    }
+}
+const isFastStoreError = (error) => error?.name === 'FastStoreError';
+const isNotFoundError = (error) => error?.extensions?.type === 'NotFoundError';
+const isBadRequestError = (error) => error?.extensions?.type === 'BadRequestError';
+//# sourceMappingURL=errors.js.map
+
+/***/ }),
+
+/***/ 8815:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "E": () => (/* binding */ getContextFactory),
+  "y": () => (/* binding */ getResolvers)
+});
+
+// EXTERNAL MODULE: external "isomorphic-unfetch"
+var external_isomorphic_unfetch_ = __webpack_require__(7881);
+var external_isomorphic_unfetch_default = /*#__PURE__*/__webpack_require__.n(external_isomorphic_unfetch_);
+// EXTERNAL MODULE: ../api/dist/esm/package.json
+var esm_package = __webpack_require__(2828);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/clients/fetch.js
+
+
+const USER_AGENT = `${esm_package/* name */.u2}@${esm_package/* version */.i8}`;
+const fetchAPI = async (info, init) => {
+    const response = await external_isomorphic_unfetch_default()(info, {
+        ...init,
+        headers: {
+            ...init?.headers,
+            'User-Agent': USER_AGENT,
+        },
+    });
+    if (response.ok) {
+        return response.status !== 204 ? response.json() : undefined;
+    }
+    console.error(info, init, response);
+    const text = await response.text();
+    throw new Error(text);
+};
+//# sourceMappingURL=fetch.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/clients/commerce/index.js
+
+const BASE_INIT = {
+    method: 'POST',
+    headers: {
+        'content-type': 'application/json',
+    },
+};
+const VtexCommerce = ({ account, environment, incrementAddress }, ctx) => {
+    const base = `https://${account}.${environment}.com.br`;
+    return {
+        catalog: {
+            salesChannel: (sc) => fetchAPI(`${base}/api/catalog_system/pub/saleschannel/${sc}`),
+            brand: {
+                list: () => fetchAPI(`${base}/api/catalog_system/pub/brand/list`),
+            },
+            category: {
+                tree: (depth = 3) => fetchAPI(`${base}/api/catalog_system/pub/category/tree/${depth}`),
+            },
+            portal: {
+                pagetype: (slug) => fetchAPI(`${base}/api/catalog_system/pub/portal/pagetype/${slug}`),
+            },
+            products: {
+                crossselling: ({ type, productId, groupByProduct = true, }) => {
+                    const params = new URLSearchParams({
+                        sc: ctx.storage.channel.salesChannel,
+                        groupByProduct: groupByProduct.toString(),
+                    });
+                    return fetchAPI(`${base}/api/catalog_system/pub/products/crossselling/${type}/${productId}?${params}`);
+                },
+            },
+        },
+        checkout: {
+            simulation: (args, { salesChannel } = ctx.storage.channel) => {
+                const params = new URLSearchParams({
+                    sc: salesChannel,
+                });
+                return fetchAPI(`${base}/api/checkout/pub/orderForms/simulation?${params.toString()}`, {
+                    ...BASE_INIT,
+                    body: JSON.stringify(args),
+                });
+            },
+            shippingData: ({ id, index, deliveryMode, selectedAddresses, }, setDeliveryWindow) => {
+                const deliveryWindow = setDeliveryWindow
+                    ? {
+                        startDateUtc: deliveryMode?.deliveryWindow?.startDate,
+                        endDateUtc: deliveryMode?.deliveryWindow?.endDate,
+                    }
+                    : null;
+                const mappedBody = {
+                    logisticsInfo: Array.from({ length: index }, (_, itemIndex) => ({
+                        itemIndex,
+                        selectedDeliveryChannel: deliveryMode?.deliveryChannel || null,
+                        selectedSla: deliveryMode?.deliveryMethod || null,
+                        deliveryWindow: deliveryWindow,
+                    })),
+                    selectedAddresses: selectedAddresses,
+                    clearAddressIfPostalCodeNotFound: incrementAddress,
+                };
+                return fetchAPI(`${base}/api/checkout/pub/orderForm/${id}/attachments/shippingData`, {
+                    ...BASE_INIT,
+                    body: JSON.stringify(mappedBody),
+                    headers: {
+                        'content-type': 'application/json',
+                        cookie: ctx.headers.cookie,
+                    },
+                });
+            },
+            orderForm: ({ id, refreshOutdatedData = true, channel = ctx.storage.channel, }) => {
+                const { salesChannel } = channel;
+                const params = new URLSearchParams({
+                    refreshOutdatedData: refreshOutdatedData.toString(),
+                    sc: salesChannel,
+                });
+                const requestInit = ctx.headers
+                    ? {
+                        ...BASE_INIT,
+                        headers: {
+                            'content-type': 'application/json',
+                            cookie: ctx.headers.cookie,
+                        },
+                    }
+                    : BASE_INIT;
+                return fetchAPI(`${base}/api/checkout/pub/orderForm/${id}?${params.toString()}`, requestInit);
+            },
+            clearOrderFormMessages: ({ id }) => {
+                return fetchAPI(`${base}/api/checkout/pub/orderForm/${id}/messages/clear`, {
+                    ...BASE_INIT,
+                    body: '{}',
+                });
+            },
+            updateOrderFormItems: ({ id, orderItems, allowOutdatedData = 'paymentData', salesChannel = ctx.storage.channel.salesChannel, shouldSplitItem = true, }) => {
+                const params = new URLSearchParams({
+                    allowOutdatedData,
+                    sc: salesChannel,
+                });
+                const items = JSON.stringify({
+                    orderItems,
+                    noSplitItem: !shouldSplitItem,
+                });
+                const requestInit = ctx.headers
+                    ? {
+                        headers: {
+                            'content-type': 'application/json',
+                            cookie: ctx.headers.cookie,
+                        },
+                        body: items,
+                        method: 'PATCH',
+                    }
+                    : {
+                        headers: {
+                            'content-type': 'application/json',
+                        },
+                        body: items,
+                        method: 'PATCH',
+                    };
+                return fetchAPI(`${base}/api/checkout/pub/orderForm/${id}/items?${params}`, requestInit);
+            },
+            setCustomData: ({ id, appId, key, value, }) => {
+                return fetchAPI(`${base}/api/checkout/pub/orderForm/${id}/customData/${appId}/${key}`, {
+                    ...BASE_INIT,
+                    body: JSON.stringify({ value }),
+                    method: 'PUT',
+                });
+            },
+            region: async ({ postalCode, geoCoordinates, country, salesChannel, }) => {
+                const params = new URLSearchParams({
+                    country: country,
+                    sc: salesChannel ?? '',
+                });
+                postalCode
+                    ? params.append('postalCode', postalCode)
+                    : params.append('geoCoordinates', `${geoCoordinates?.longitude};${geoCoordinates?.latitude}`);
+                const url = `${base}/api/checkout/pub/regions/?${params.toString()}`;
+                return fetchAPI(url);
+            },
+            address: async ({ postalCode, country, }) => {
+                return fetchAPI(`${base}/api/checkout/pub/postal-code/${country}/${postalCode}`);
+            },
+        },
+        session: (search) => {
+            const params = new URLSearchParams(search);
+            params.set('items', 'profile.id,profile.email,profile.firstName,profile.lastName,store.channel,store.countryCode,store.cultureInfo,store.currencyCode,store.currencySymbol');
+            return fetchAPI(`${base}/api/sessions?${params.toString()}`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    cookie: ctx.headers.cookie,
+                },
+                body: '{}',
+            });
+        },
+        subscribeToNewsletter: (data) => {
+            return fetchAPI(`${base}/api/dataentities/NL/documents/`, {
+                ...BASE_INIT,
+                body: JSON.stringify({ ...data, isNewsletterOptIn: true }),
+                method: 'PATCH',
+            });
+        },
+    };
+};
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/clients/search/index.js
+
+const POLICY_KEY = 'trade-policy';
+const REGION_KEY = 'region-id';
+const CHANNEL_KEYS = new Set([POLICY_KEY, REGION_KEY]);
+const isFacetBoolean = (facet) => facet.type === 'TEXT';
+const IntelligentSearch = ({ account, environment, hideUnavailableItems }, ctx) => {
+    const base = `https://${account}.${environment}.com.br/api/io`;
+    const getPolicyFacet = () => {
+        const { salesChannel } = ctx.storage.channel;
+        if (!salesChannel) {
+            return null;
+        }
+        return {
+            key: POLICY_KEY,
+            value: salesChannel,
+        };
+    };
+    const getRegionFacet = () => {
+        const { regionId, seller } = ctx.storage.channel;
+        const sellerRegionId = seller
+            ? Buffer.from(`SW#${seller}`).toString('base64')
+            : null;
+        const facet = sellerRegionId ?? regionId;
+        if (!facet) {
+            return null;
+        }
+        return {
+            key: REGION_KEY,
+            value: facet,
+        };
+    };
+    const addDefaultFacets = (facets) => {
+        const withDefaultFacets = facets.filter(({ key }) => !CHANNEL_KEYS.has(key));
+        const policyFacet = facets.find(({ key }) => key === POLICY_KEY) ?? getPolicyFacet();
+        const regionFacet = facets.find(({ key }) => key === REGION_KEY) ?? getRegionFacet();
+        if (policyFacet !== null) {
+            withDefaultFacets.push(policyFacet);
+        }
+        if (regionFacet !== null) {
+            withDefaultFacets.push(regionFacet);
+        }
+        return withDefaultFacets;
+    };
+    const search = ({ query = '', page, count, sort = '', selectedFacets = [], type, fuzzy = 'auto', }) => {
+        const params = new URLSearchParams({
+            page: (page + 1).toString(),
+            count: count.toString(),
+            query,
+            sort,
+            fuzzy,
+            locale: ctx.storage.locale,
+        });
+        if (hideUnavailableItems !== undefined) {
+            params.append('hideUnavailableItems', hideUnavailableItems.toString());
+        }
+        const pathname = addDefaultFacets(selectedFacets)
+            .map(({ key, value }) => `${key}/${value}`)
+            .join('/');
+        return fetchAPI(`${base}/_v/api/intelligent-search/${type}/${pathname}?${params.toString()}`);
+    };
+    const products = (args) => search({ ...args, type: 'product_search' });
+    const suggestedTerms = (args) => {
+        const params = new URLSearchParams({
+            query: args.query?.toString() ?? '',
+            locale: ctx.storage.locale,
+        });
+        return fetchAPI(`${base}/_v/api/intelligent-search/search_suggestions?${params.toString()}`);
+    };
+    const topSearches = () => {
+        const params = new URLSearchParams({
+            locale: ctx.storage.locale,
+        });
+        return fetchAPI(`${base}/_v/api/intelligent-search/top_searches?${params.toString()}`);
+    };
+    const facets = (args) => search({ ...args, type: 'facets' });
+    return {
+        facets,
+        products,
+        suggestedTerms,
+        topSearches,
+    };
+};
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/clients/sp/index.js
+/**
+ * Client for SP, Intelligent search's analytics event API
+ * More info at: https://www.notion.so/vtexhandbook/Event-API-Documentation-48eee26730cf4d7f80f8fd7262231f84
+ */
+
+const THIRTY_MINUTES_S = 30 * 60;
+const ONE_YEAR_S = 365 * 24 * 3600;
+const randomUUID = () => (Math.random() * 1e6).toFixed(0);
+const timelapsed = (past) => (Date.now() - past) / 1e3;
+const createId = (expiresSecond) => {
+    let payload = randomUUID();
+    let createdAt = Date.now();
+    return () => {
+        if (timelapsed(createdAt) > expiresSecond) {
+            payload = randomUUID();
+            createdAt = Date.now();
+        }
+        return payload;
+    };
+};
+const user = {
+    anonymous: createId(ONE_YEAR_S),
+    session: createId(THIRTY_MINUTES_S),
+};
+const SP = ({ account }, _) => {
+    const base = `https://sp.vtex.com/event-api/v1/${account}/event`;
+    const sendEvent = (options) => {
+        return fetchAPI(base, {
+            method: 'POST',
+            body: JSON.stringify({
+                ...options,
+                agent: '@faststore/api',
+                anonymous: user.anonymous(), // 'zZlNhqz1vFJP6iPG5Oqtt'
+                session: user.session(), // 'Om1TNluGvgmSgU5OOTvkkd'
+            }),
+            headers: {
+                'content-type': 'application/json',
+            },
+        });
+    };
+    return {
+        sendEvent,
+    };
+};
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/clients/index.js
+
+
+
+const getClients = (options, ctx) => {
+    const search = IntelligentSearch(options, ctx);
+    const commerce = VtexCommerce(options, ctx);
+    const sp = SP(options, ctx);
+    return {
+        search,
+        commerce,
+        sp,
+    };
+};
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: ../api/node_modules/dataloader/index.js
+var dataloader = __webpack_require__(3404);
+var dataloader_default = /*#__PURE__*/__webpack_require__.n(dataloader);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/loaders/salesChannel.js
+
+const getSalesChannelLoader = (_, clients) => {
+    const loader = async (channels) => Promise.all(channels.map((sc) => clients.commerce.catalog.salesChannel(sc)));
+    return new (dataloader_default())(loader);
+};
+//# sourceMappingURL=salesChannel.js.map
+// EXTERNAL MODULE: external "p-limit"
+var external_p_limit_ = __webpack_require__(5471);
+var external_p_limit_default = /*#__PURE__*/__webpack_require__.n(external_p_limit_);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/loaders/simulation.js
+
+
+// Limits concurrent requests to the API per request cycle
+const CONCURRENT_REQUESTS_MAX = 1;
+const getSimulationLoader = (_, clients) => {
+    const limit = external_p_limit_default()(CONCURRENT_REQUESTS_MAX);
+    const loader = async (simulationArgs) => {
+        const allItems = simulationArgs.reduce((acc, { items }) => {
+            return [...acc, items];
+        }, []);
+        const items = [...allItems.flat()];
+        const simulation = await clients.commerce.checkout.simulation({
+            country: simulationArgs[0].country,
+            postalCode: simulationArgs[0].postalCode,
+            items,
+        });
+        // Sort and filter simulation since Checkout API may return
+        // items that we didn't ask for
+        const simulated = simulation.items.reduce((acc, item) => {
+            const index = item.requestIndex;
+            if (typeof index === 'number' && index < acc.length) {
+                acc[index] = item;
+            }
+            return acc;
+        }, Array(items.length).fill(null));
+        const itemsIndices = allItems.reduce((acc, curr) => [...acc, curr.length + acc[acc.length - 1]], [0]);
+        return allItems.map((__, index) => ({
+            ...simulation,
+            items: simulated
+                .slice(itemsIndices[index], itemsIndices[index + 1])
+                .filter((item) => Boolean(item)),
+        }));
+    };
+    const limited = async (allItems) => limit(loader, allItems);
+    return new (dataloader_default())(limited, {
+        maxBatchSize: 50,
+    });
+};
+//# sourceMappingURL=simulation.js.map
+// EXTERNAL MODULE: external "sanitize-html"
+var external_sanitize_html_ = __webpack_require__(6109);
+var external_sanitize_html_default = /*#__PURE__*/__webpack_require__.n(external_sanitize_html_);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/sanitizeHtml.js
+
+/**
+ * For now, we're using sanitize-html's default set
+ * of allowed tags and attributes, which don't even include img elements
+ *
+ * It is known many client depends on pontentially vulnerable tags, such as script tags
+ * We chose to be restrictive at first, and document those restrictions later.
+ *
+ * When expanding the set of allowed tags and attributes, please consider performance, privacy and security.
+ *
+ * This possibily breaks compatibility with Portal and Store Framework,
+ * which both allows an enormous amount of tags and attributes
+ *
+ * This was a thoughtful decision that can be reviewed in the future given
+ * research was made to back up those changes.
+ */
+const sanitizeHtml = (dirty, options) => external_sanitize_html_default()(dirty, options);
+//# sourceMappingURL=sanitizeHtml.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/enhanceSku.js
+
+function sanitizeProduct(product) {
+    return {
+        ...product,
+        description: product.description
+            ? sanitizeHtml(product.description)
+            : product.description,
+    };
+}
+const enhanceSku = (item, product) => ({
+    ...item,
+    isVariantOf: sanitizeProduct(product),
+});
+//# sourceMappingURL=enhanceSku.js.map
+// EXTERNAL MODULE: ../api/dist/esm/src/platforms/errors.js
+var errors = __webpack_require__(782);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/loaders/sku.js
+
+
+
+const getSkuLoader = (_, clients) => {
+    const loader = async (skuIds) => {
+        const { products } = await clients.search.products({
+            query: `sku:${skuIds.join(';')}`,
+            page: 0,
+            count: skuIds.length,
+        });
+        const skuBySkuId = products.reduce((acc, product) => {
+            for (const sku of product.items) {
+                acc[sku.itemId] = enhanceSku(sku, product);
+            }
+            return acc;
+        }, {});
+        const skus = skuIds.map((skuId) => skuBySkuId[skuId]);
+        const missingSkus = skuIds.filter((skuId) => !skuBySkuId[skuId]);
+        if (missingSkus.length > 0) {
+            throw new errors/* NotFoundError */.dR(`Search API did not found the following skus: ${missingSkus.join(',')}`);
+        }
+        return skus;
+    };
+    return new (dataloader_default())(loader, {
+        maxBatchSize: 99, // Max allowed batch size of Search API
+    });
+};
+//# sourceMappingURL=sku.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/loaders/collection.js
+
+
+
+// Limits concurrent requests to 20 so that they don't timeout
+const collection_CONCURRENT_REQUESTS_MAX = 20;
+const collectionPageTypes = new Set([
+    'brand',
+    'category',
+    'department',
+    'subcategory',
+    'collection',
+    'cluster',
+]);
+const isCollectionPageType = (x) => typeof x.pageType === 'string' &&
+    collectionPageTypes.has(x.pageType.toLowerCase());
+const getCollectionLoader = (_, clients) => {
+    const limit = external_p_limit_default()(collection_CONCURRENT_REQUESTS_MAX);
+    const loader = async (slugs) => {
+        return Promise.all(slugs.map((slug) => limit(async () => {
+            const page = await clients.commerce.catalog.portal.pagetype(slug);
+            if (isCollectionPageType(page)) {
+                return page;
+            }
+            throw new errors/* NotFoundError */.dR(`Catalog returned ${page.pageType} for slug: ${slug}. This usually happens when there is more than one category with the same name in the same category tree level.`);
+        })));
+    };
+    return new (dataloader_default())(loader, {
+        // DataLoader is being used to cache requests, not to batch them
+        batch: false,
+    });
+};
+//# sourceMappingURL=collection.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/loaders/index.js
+
+
+
+
+const getLoaders = (options, { clients }) => {
+    const skuLoader = getSkuLoader(options, clients);
+    const simulationLoader = getSimulationLoader(options, clients);
+    const collectionLoader = getCollectionLoader(options, clients);
+    const salesChannelLoader = getSalesChannelLoader(options, clients);
+    return {
+        skuLoader,
+        simulationLoader,
+        collectionLoader,
+        salesChannelLoader
+    };
+};
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/productStock.js
+const inStock = (offer) => offer.AvailableQuantity > 0;
+const price = (offer) => offer.spotPrice ?? 0;
+const sellingPrice = (offer) => offer.Price ?? 0;
+const availability = (available) => available ? 'https://schema.org/InStock' : 'https://schema.org/OutOfStock';
+// Smallest Available Spot Price First
+const bestOfferFirst = (a, b) => {
+    if (inStock(a) && !inStock(b)) {
+        return -1;
+    }
+    if (!inStock(a) && inStock(b)) {
+        return 1;
+    }
+    return price(a) - price(b);
+};
+const inStockOrderFormItem = (itemAvailability) => itemAvailability === 'available';
+//# sourceMappingURL=productStock.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/aggregateOffer.js
+
+const StoreAggregateOffer = {
+    highPrice: (offers) => {
+        const availableOffers = offers.filter(inStock);
+        const highOffer = availableOffers[availableOffers.length - 1];
+        return highOffer != null ? price(highOffer) : 0;
+    },
+    lowPrice: (offers) => {
+        const [lowOffer] = offers.filter(inStock);
+        return lowOffer ? price(lowOffer) : 0;
+    },
+    offerCount: (offers) => offers.length,
+    priceCurrency: async (_, __, ctx) => {
+        const { loaders: { salesChannelLoader }, storage: { channel } } = ctx;
+        const sc = await salesChannelLoader.load(channel.salesChannel);
+        return sc.CurrencyCode ?? '';
+    },
+    offers: (offers) => offers,
+};
+//# sourceMappingURL=aggregateOffer.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/aggregateRating.js
+// TODO: Add a review system integration
+const StoreAggregateRating = {
+    ratingValue: () => 5,
+    reviewCount: () => 0,
+};
+//# sourceMappingURL=aggregateRating.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/slugify.js
+/**
+ * VTEX catalog slugify function
+ *
+ * Copied from:
+ * https://github.com/vtex/rewriter/blob/1ce2010783e0586cab42534ce2fb7a983d8a3a84/node/clients/catalog.ts#L72
+ *
+ * Sometimes, we need to slugify strings for creating urls. An example is the
+ * brand urls, where we create them from the brand's name.
+ * This slugify function should match exactly what VTEX catalog generates. Any mismatch
+ * will lead to broken links.
+ * Hopefully, we had this function implemented on VTEX IO and we've been using it for
+ * years now. However, looking at the code, I think we can save lots of computing. I'm
+ * in a hurry for doing these tests now, so I'll leave a small TODO.
+ *
+ * TODO: Research for better ways of computing this slugify function. Things I'd try are:
+ * - Join those 3 regexs for special characters into a single one.
+ * - Replace the regexp of `removeDiacritics` function with a Map. We can make the complexity
+ * of this function be O(n) with n=string.length
+ *
+ */
+const from = 'ÁÄÂÀÃÅČÇĆĎÉĚËÈÊẼĔȆÍÌÎÏŇÑÓÖÒÔÕØŘŔŠŤÚŮÜÙÛÝŸŽáäâàãåčçćďéěëèêẽĕȇíìîïňñóöòôõøðřŕšťúůüùûýÿžþÞĐđßÆa';
+const to = 'AAAAAACCCDEEEEEEEEIIIINNOOOOOORRSTUUUUUYYZaaaaaacccdeeeeeeeeiiiinnooooooorrstuuuuuyyzbBDdBAa';
+const removeDiacritics = (str) => {
+    let newStr = str.slice(0);
+    for (let i = 0; i < from.length; i++) {
+        newStr = newStr.replace(new RegExp(from.charAt(i), 'g'), to.charAt(i));
+    }
+    return newStr;
+};
+const slugifySpecialCharacters = (str) => {
+    return str.replace(/[·/_,:]/, '-');
+};
+function slugify(str) {
+    const noCommas = str.replace(/,/g, '');
+    const replaced = noCommas.replace(/[*+~.()'"!:@&\[\]`/ %$#?{}|><=_^]/g, '-');
+    const slugified = slugifySpecialCharacters(removeDiacritics(replaced));
+    return slugified.toLowerCase();
+}
+//# sourceMappingURL=slugify.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/collection.js
+
+
+const isBrand = (x) => x.type === 'brand' ||
+    (isCollectionPageType(x) && x.pageType.toLowerCase() === 'brand');
+const isCollection = (x) => isCollectionPageType(x) && x.pageType.toLowerCase() === 'collection';
+const slugifyRoot = (root) => {
+    if (isBrand(root) || isCollection(root)) {
+        return slugify(root.name);
+    }
+    if (isCollectionPageType(root)) {
+        return new URL(`https://${root.url}`).pathname.slice(1).toLowerCase();
+    }
+    return new URL(root.url).pathname.slice(1).toLowerCase();
+};
+const StoreCollection = {
+    id: ({ id }) => id.toString(),
+    slug: (root) => slugifyRoot(root),
+    seo: (root) => isBrand(root) || isCollectionPageType(root)
+        ? {
+            title: root.title,
+            description: root.metaTagDescription,
+        }
+        : {
+            title: root.Title,
+            description: root.MetaTagDescription,
+        },
+    type: (root) => isBrand(root)
+        ? 'Brand'
+        : isCollectionPageType(root)
+            ? root.pageType
+            : root.level === 0
+                ? 'Department'
+                : 'Category',
+    meta: (root) => {
+        const slug = slugifyRoot(root);
+        return isBrand(root)
+            ? {
+                selectedFacets: [{ key: 'brand', value: slug }],
+            }
+            : isCollection(root)
+                ? {
+                    selectedFacets: [{ key: 'productclusterids', value: root.id }],
+                }
+                : {
+                    selectedFacets: slug.split('/').map((segment, index) => ({
+                        key: `category-${index + 1}`,
+                        value: segment,
+                    })),
+                };
+    },
+    breadcrumbList: async (root, _, ctx) => {
+        const { loaders: { collectionLoader }, } = ctx;
+        const slug = slugifyRoot(root);
+        /**
+         * Split slug into segments so we fetch all data for
+         * the breadcrumb. For instance, if we get `/foo/bar`
+         * we need all metadata for both `/foo` and `/bar` and
+         * thus we need to fetch pageType for `/foo` and `/bar`
+         */
+        const segments = slug.split('/').filter((segment) => Boolean(segment));
+        const slugs = segments.map((__, index) => segments.slice(0, index + 1).join('/'));
+        const collections = await Promise.all(slugs.map(async (s) => {
+            const collection = await collectionLoader.load(s);
+            return { slug: s, ...collection };
+        }));
+        return {
+            itemListElement: collections.map((collection, index) => ({
+                item: isCollection(collection)
+                    ? `/${collection.slug}`
+                    : new URL(`https://${collection.url}`).pathname.toLowerCase(),
+                name: collection.name,
+                position: index + 1,
+            })),
+            numberOfItems: collections.length,
+        };
+    },
+};
+//# sourceMappingURL=collection.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/facets.js
+
+const FACET_CROSS_SELLING_MAP = {
+    buy: "whoboughtalsobought",
+    view: "whosawalsosaw",
+    similars: "similars",
+    viewAndBought: "whosawalsobought",
+    accessories: "accessories",
+    suggestions: "suggestions",
+};
+/**
+ * Transform facets from the store to VTEX platform facets.
+ * For instance, the channel in Store becomes trade-policy and regionId in VTEX's realm
+ * */
+const transformSelectedFacet = ({ key, value }) => {
+    switch (key) {
+        case 'price': {
+            return { key, value: value.replace('-to-', ':') };
+        }
+        case 'channel':
+        case 'locale':
+        case "buy":
+        case "view":
+        case "similars":
+        case "viewAndBought":
+        case "accessories":
+        case "suggestions": {
+            return []; // remove this facet from search
+        }
+        default:
+            return { key, value };
+    }
+};
+const parseRange = (range) => {
+    const splitted = range.split(':').map(Number);
+    if (splitted.length !== 2 ||
+        Number.isNaN(splitted[0]) ||
+        Number.isNaN(splitted[1])) {
+        return null;
+    }
+    return splitted;
+};
+const isCrossSelling = (x) => typeof FACET_CROSS_SELLING_MAP[x] === "string";
+const findCrossSelling = (facets) => {
+    const filtered = facets?.filter((x) => isCrossSelling(x.key));
+    if (Array.isArray(filtered) && filtered.length > 1) {
+        throw new errors/* BadRequestError */.oY(`You passed ${filtered.length} cross selling facets but only one is allowed. Please leave one of the following facet: ${filtered.map(x => x.key).join(',')}`);
+    }
+    return filtered?.[0] ?? null;
+};
+const findSlug = (facets) => facets?.find((x) => x.key === 'slug')?.value ?? null;
+const findSkuId = (facets) => facets?.find((x) => x.key === 'id')?.value ?? null;
+const findLocale = (facets) => facets?.find((x) => x.key === 'locale')?.value ?? null;
+const findChannel = (facets) => facets?.find((facet) => facet.key === 'channel')?.value ?? null;
+//# sourceMappingURL=facets.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/orderStatistics.js
+/**
+ * More info at: https://en.wikipedia.org/wiki/Order_statistic
+ */
+// O(n) search to find the max of an array
+const min = (array, cmp) => {
+    let best = 0;
+    for (let curr = 1; curr < array.length; curr++) {
+        if (cmp(array[best], array[curr]) > 0) {
+            best = curr;
+        }
+    }
+    return array[best];
+};
+//# sourceMappingURL=orderStatistics.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/facet.js
+
+
+const StoreFacet = {
+    __resolveType: ({ type }) => type === 'TEXT' ? 'StoreFacetBoolean' : 'StoreFacetRange',
+};
+const StoreFacetBoolean = {
+    key: ({ key }) => key,
+    label: ({ name }) => name,
+    values: ({ values }) => values.sort((a, b) => a.name.localeCompare(b.name)),
+};
+const StoreFacetRange = {
+    key: ({ key }) => key,
+    label: ({ name }) => name,
+    min: ({ values, key }, _, { storage: { searchArgs } }) => {
+        /**
+         * Fetch the selected range the user queried.
+         *
+         * This is necessary because, differently from boolean facets, Search API does
+         * not return the selected values, making us have to implement it in here
+         */
+        const selectedRange = parseRange(searchArgs?.selectedFacets?.find((facet) => facet.key === key)?.value ??
+            '');
+        const facet = min(values, (a, b) => a.range.from - b.range.from);
+        const globalMin = facet?.range.from ?? 0;
+        return {
+            selected: selectedRange?.[0] ?? globalMin,
+            absolute: globalMin,
+        };
+    },
+    max: ({ values, key }, _, { storage: { searchArgs } }) => {
+        /**
+         * Fetch the selected range the user queried.
+         *
+         * This is necessary because, differently from boolean facets, Search API does
+         * not return the selected values, making us have to implement it in here
+         */
+        const selectedRange = parseRange(searchArgs?.selectedFacets?.find((facet) => facet.key === key)?.value ??
+            '');
+        const facet = min(values, (a, b) => b.range.to - a.range.to);
+        const globalMax = facet?.range.to ?? 0;
+        return {
+            selected: selectedRange?.[1] ?? globalMax,
+            absolute: globalMax,
+        };
+    },
+};
+//# sourceMappingURL=facet.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/faceValue.js
+const StoreFacetValueBoolean = {
+    value: ({ value }) => value,
+    label: ({ name }) => name || 'unknown',
+    selected: ({ selected }) => selected,
+    quantity: ({ quantity }) => quantity,
+};
+//# sourceMappingURL=faceValue.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/subscribeToNewsletter.js
+const subscribeToNewsletter = async (_, { data }, { clients: { commerce } }) => {
+    const response = await commerce.subscribeToNewsletter(data);
+    return { id: response?.Id };
+};
+//# sourceMappingURL=subscribeToNewsletter.js.map
+// EXTERNAL MODULE: external "fast-deep-equal"
+var external_fast_deep_equal_ = __webpack_require__(2404);
+var external_fast_deep_equal_default = /*#__PURE__*/__webpack_require__.n(external_fast_deep_equal_);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/channel.js
+class ChannelMarshal {
+    static parse(channelString) {
+        try {
+            const parsedChannel = JSON.parse(channelString);
+            return {
+                seller: parsedChannel.seller ?? '',
+                regionId: parsedChannel.regionId ?? '',
+                salesChannel: parsedChannel.salesChannel ?? '',
+            };
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error('Malformed channel string');
+        }
+    }
+    static stringify(channel) {
+        return JSON.stringify(channel);
+    }
+}
+//# sourceMappingURL=channel.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/contex.js
+
+const mutateChannelContext = (ctx, channelString) => {
+    ctx.storage.channel = ChannelMarshal.parse(channelString);
+};
+const mutateLocaleContext = (ctx, locale) => {
+    ctx.storage.locale = locale;
+};
+//# sourceMappingURL=contex.js.map
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6113);
+var external_crypto_default = /*#__PURE__*/__webpack_require__.n(external_crypto_);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/md5.js
+
+const md5 = (payload) => external_crypto_default().createHash('md5').update(payload).digest('hex');
+//# sourceMappingURL=md5.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/propertyValue.js
+
+const VALUE_REFERENCES = {
+    attachment: 'ATTACHMENT',
+    specification: 'SPECIFICATION',
+};
+function attachmentToPropertyValue(attachment) {
+    return {
+        name: attachment.name,
+        value: attachment.content,
+        valueReference: VALUE_REFERENCES.attachment,
+    };
+}
+function getPropertyId(item) {
+    return md5(`${item.name}:${JSON.stringify(item.value)}:${item.valueReference}`);
+}
+//# sourceMappingURL=propertyValue.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/shouldUpdateShippingData.js
+const shouldUpdateShippingData = (orderForm, session) => {
+    if (!hasSessionPostalCodeOrGeoCoordinates(session)) {
+        return { updateShipping: false, addressChanged: false };
+    }
+    if (!hasItems(orderForm)) {
+        return { updateShipping: false, addressChanged: false };
+    }
+    const [selectedAddress] = orderForm?.shippingData?.selectedAddresses ?? [];
+    if (checkPostalCode(selectedAddress, session.postalCode) ||
+        checkGeoCoordinates(selectedAddress, session.geoCoordinates) ||
+        checkAddressType(selectedAddress, session.addressType)) {
+        return { updateShipping: true, addressChanged: true };
+    }
+    // The logisticsInfo will always exist if there´s at least one item inside the cart
+    const { logisticsInfo } = orderForm.shippingData;
+    if (shouldUpdateDeliveryInfo(logisticsInfo, session)) {
+        return { updateShipping: true, addressChanged: false };
+    }
+    return { updateShipping: false, addressChanged: false };
+};
+// Validate if theres any postal Code or GeoCoordinates set at the session
+const hasSessionPostalCodeOrGeoCoordinates = (session) => {
+    return (!!session.postalCode ||
+        (session.geoCoordinates?.latitude && session.geoCoordinates?.longitude));
+};
+// Validate if theres a difference between the session postal code and orderForm postal code
+const checkPostalCode = (address, postalCode) => {
+    return typeof postalCode === 'string' && address?.postalCode !== postalCode;
+};
+// Validate if theres a difference between the session geoCoords and orderForm geoCoords
+const checkGeoCoordinates = (address, geoCoordinates) => {
+    return (typeof geoCoordinates?.latitude === 'number' &&
+        typeof geoCoordinates?.longitude === 'number' &&
+        (address?.geoCoordinates[0] !== geoCoordinates?.longitude ||
+            address?.geoCoordinates[1] !== geoCoordinates?.latitude));
+};
+const checkAddressType = (address, addressType) => {
+    return typeof addressType === 'string' && address?.addressType !== addressType;
+};
+// Validate if theres any item inside the orderForm
+const hasItems = (orderForm) => {
+    return orderForm.items.length !== 0;
+};
+const shouldUpdateDeliveryInfo = (logisticsInfo, session) => {
+    const deliveryChannel = session?.deliveryMode?.deliveryChannel;
+    const deliveryMethod = session?.deliveryMode?.deliveryMethod;
+    const { startDate, endDate } = session?.deliveryMode?.deliveryWindow || {};
+    return logisticsInfo.some(({ selectedDeliveryChannel, selectedSla, slas }) => {
+        const checkDeliveryChannel = deliveryChannel && selectedDeliveryChannel !== deliveryChannel;
+        const checkDeliveryMethod = deliveryMethod && selectedSla !== deliveryMethod;
+        return slas?.some((sla) => {
+            if ((checkDeliveryChannel && sla.deliveryChannel === deliveryChannel) ||
+                (checkDeliveryMethod && sla.id === deliveryMethod)) {
+                return true;
+            }
+            return (startDate &&
+                endDate &&
+                sla.deliveryChannel === deliveryChannel &&
+                sla.id === deliveryMethod &&
+                (!sla?.deliveryWindow ||
+                    sla?.deliveryWindow?.startDateUtc !== startDate ||
+                    sla?.deliveryWindow?.endDateUtc !== endDate) &&
+                sla.availableDeliveryWindows?.some((window) => window?.startDateUtc === startDate &&
+                    window?.endDateUtc === endDate));
+        });
+    });
+};
+//# sourceMappingURL=shouldUpdateShippingData.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/getAddressOrderForm.js
+const getAddressOrderForm = (orderForm, session, addressChanged) => {
+    const postalCode = session.postalCode;
+    const geoCoordinates = session.geoCoordinates;
+    const availableAddresses = orderForm?.shippingData?.availableAddresses ?? [];
+    const selectedAddresses = orderForm?.shippingData?.selectedAddresses ?? [];
+    // Validate if no change for the address was made and the deliveryMode has changed we can return the address from the orderForm
+    if (!addressChanged && selectedAddresses.length > 0) {
+        return [selectedAddresses[0]];
+    }
+    // Validate if the address from the session already exists at the availableAddresses from the OrderForm to avoid duplication
+    if (addressChanged && availableAddresses.length > 0) {
+        for (const address of availableAddresses) {
+            if (postalCode && geoCoordinates) {
+                const addressMatcher = address.postalCode === postalCode ||
+                    (address.geoCoordinates[0] === geoCoordinates.longitude &&
+                        address.geoCoordinates[1] === geoCoordinates.latitude);
+                if (addressMatcher) {
+                    return [address];
+                }
+            }
+            if (postalCode && !geoCoordinates) {
+                const addressMatcher = address.postalCode === postalCode;
+                if (addressMatcher) {
+                    return [address];
+                }
+            }
+            if (geoCoordinates && !postalCode) {
+                const addressMatcher = address.geoCoordinates[0] === geoCoordinates.longitude &&
+                    address.geoCoordinates[1] === geoCoordinates.latitude;
+                if (addressMatcher) {
+                    return [address];
+                }
+            }
+        }
+    }
+    return null;
+};
+//# sourceMappingURL=getAddressOrderForm.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/createNewAddress.js
+const createNewAddress = (session) => {
+    const postalCode = session.postalCode;
+    const geoCoordinates = session.geoCoordinates;
+    // If the address from the session has changed and it do not exist we will create the new one
+    const addressSession = {
+        addressType: session.addressType || null,
+        postalCode: postalCode || null,
+        city: null,
+        state: null,
+        country: session.country || null,
+        street: null,
+        number: null,
+        neighborhood: null,
+        complement: null,
+        reference: null,
+        geoCoordinates: [],
+    };
+    if (geoCoordinates) {
+        const latitude = typeof geoCoordinates === 'object' && 'latitude' in geoCoordinates
+            ? geoCoordinates.latitude
+            : null;
+        const longitude = typeof geoCoordinates === 'object' && 'longitude' in geoCoordinates
+            ? geoCoordinates.longitude
+            : null;
+        addressSession.geoCoordinates =
+            latitude !== null && longitude !== null ? [longitude, latitude] : [];
+    }
+    return [addressSession];
+};
+//# sourceMappingURL=createNewAddress.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/validateCart.js
+
+
+
+
+
+
+
+const isAttachment = (value) => value.valueReference === VALUE_REFERENCES.attachment;
+const getId = (item) => [
+    item.itemOffered.sku,
+    item.seller.identifier,
+    item.price < 0.01 ? 'Gift' : undefined,
+    item.itemOffered.additionalProperty
+        ?.filter(isAttachment)
+        .map(getPropertyId)
+        .join('-'),
+]
+    .filter(Boolean)
+    .join('::');
+const orderFormItemToOffer = (item, index) => ({
+    listPrice: item.listPrice / 100,
+    price: item.sellingPrice / 100,
+    quantity: item.quantity,
+    seller: { identifier: item.seller },
+    itemOffered: {
+        sku: item.id,
+        image: [],
+        name: item.name,
+        additionalProperty: item.attachments.map(attachmentToPropertyValue),
+    },
+    index,
+});
+const offerToOrderItemInput = (offer) => ({
+    quantity: offer.quantity,
+    seller: offer.seller.identifier,
+    id: offer.itemOffered.sku,
+    index: offer.index,
+    attachments: (offer.itemOffered.additionalProperty?.filter(isAttachment) ?? []).map((attachment) => ({
+        name: attachment.name,
+        content: attachment.value,
+    })),
+});
+const groupById = (offers) => offers.reduce((acc, item) => {
+    const id = getId(item);
+    if (!acc.has(id)) {
+        acc.set(id, []);
+    }
+    acc.get(id)?.push(item);
+    return acc;
+}, new Map());
+const equals = (storeOrder, orderForm) => {
+    const pick = (item, index) => ({
+        ...item,
+        itemOffered: {
+            sku: item.itemOffered.sku,
+        },
+        index,
+    });
+    const orderFormItems = orderForm.items.map(orderFormItemToOffer).map(pick);
+    const storeOrderItems = storeOrder.acceptedOffer.map(pick);
+    const isSameOrder = storeOrder.orderNumber === orderForm.orderFormId;
+    const orderItemsAreSync = external_fast_deep_equal_default()(orderFormItems, storeOrderItems);
+    return isSameOrder && orderItemsAreSync;
+};
+const joinItems = (form) => {
+    const itemsById = form.items.reduce((acc, item) => {
+        const id = getId(orderFormItemToOffer(item));
+        if (!acc[id]) {
+            acc[id] = [];
+        }
+        acc[id].push(item);
+        return acc;
+    }, {});
+    return {
+        ...form,
+        items: Object.values(itemsById).map((items) => {
+            const [item] = items;
+            const quantity = items.reduce((acc, i) => acc + i.quantity, 0);
+            const totalPrice = items.reduce((acc, i) => acc +
+                (i?.priceDefinition?.total ??
+                    (i?.quantity ?? 0) * (i?.sellingPrice ?? 0)), 0);
+            return {
+                ...item,
+                quantity,
+                sellingPrice: totalPrice / quantity,
+            };
+        }),
+    };
+};
+const orderFormToCart = async (form, skuLoader) => {
+    return {
+        order: {
+            orderNumber: form.orderFormId,
+            acceptedOffer: form.items.map(async (item) => ({
+                ...item,
+                product: await skuLoader.load(item.id),
+            })),
+        },
+        messages: form.messages.map(({ text, status }) => ({
+            text,
+            status: status.toUpperCase(),
+        })),
+    };
+};
+const getOrderFormEtag = ({ items }) => md5(JSON.stringify(items));
+const setOrderFormEtag = async (form, commerce) => {
+    try {
+        const orderForm = await commerce.checkout.setCustomData({
+            id: form.orderFormId,
+            appId: 'faststore',
+            key: 'cartEtag',
+            value: getOrderFormEtag(form),
+        });
+        return orderForm;
+    }
+    catch (err) {
+        console.error('Error while setting custom data to orderForm.\n Make sure to add the following custom app to the orderForm: \n{"fields":["cartEtag"],"id":"faststore","major":1}.\n More info at: https://developers.vtex.com/vtex-rest-api/docs/customizable-fields-with-checkout-api');
+        throw err;
+    }
+};
+/**
+ * Checks if cartEtag stored on customData is up to date
+ * @description If cartEtag is not up to date, this means that
+ * another system changed the cart, like Checkout UI or Order Placed
+ */
+const isOrderFormStale = (form) => {
+    const faststoreData = form.customData?.customApps.find((app) => app.id === 'faststore');
+    const oldEtag = faststoreData?.fields?.cartEtag;
+    if (oldEtag == null) {
+        return true;
+    }
+    const newEtag = getOrderFormEtag(form);
+    return newEtag !== oldEtag;
+};
+// Returns the regionalized orderForm
+const getOrderForm = async (id, { clients: { commerce } }) => {
+    return commerce.checkout.orderForm({
+        id,
+    });
+};
+const clearOrderFormMessages = async (id, { clients: { commerce } }) => {
+    return commerce.checkout.clearOrderFormMessages({
+        id,
+    });
+};
+const updateOrderFormShippingData = async (orderForm, session, { clients: { commerce } }) => {
+    // Stores that are not yet providing the session while validating the cart
+    // should not be able to update the shipping data
+    //
+    // This was causing errors while validating regionalizated carts
+    // because the following code was trying to change the shippingData to an undefined address/session
+    if (!session) {
+        return orderForm;
+    }
+    const { updateShipping, addressChanged } = shouldUpdateShippingData(orderForm, session);
+    if (updateShipping) {
+        // Check if the orderForm address matches the one from the session
+        const oldAddress = getAddressOrderForm(orderForm, session, addressChanged);
+        const address = oldAddress ? oldAddress : createNewAddress(session);
+        const selectedAddresses = address;
+        const hasDeliveryWindow = session.deliveryMode?.deliveryWindow
+            ? true
+            : false;
+        if (hasDeliveryWindow) {
+            // if you have a Delivery Window you have to first get the delivery window to set the desired after
+            await commerce.checkout.shippingData({
+                id: orderForm.orderFormId,
+                index: orderForm.items.length,
+                deliveryMode: session.deliveryMode,
+                selectedAddresses: selectedAddresses,
+            }, false);
+        }
+        return commerce.checkout.shippingData({
+            id: orderForm.orderFormId,
+            index: orderForm.items.length,
+            deliveryMode: session.deliveryMode,
+            selectedAddresses: selectedAddresses,
+        }, true);
+    }
+    return orderForm;
+};
+/**
+ * This resolver implements the optimistic cart behavior. The main idea in here
+ * is that we receive a cart from the UI (as query params) and we validate it with
+ * the commerce platform. If the cart is valid, we return null, if the cart is
+ * invalid according to the commerce platform, we return the new cart the UI should use
+ * instead.
+ *
+ * The algorithm is something like:
+ * 1. Fetch orderForm from VTEX
+ * 2. Compute delta changes between the orderForm and the UI's cart
+ * 3. Update the orderForm in VTEX platform accordingly
+ * 4. If any changes were made, send to the UI the new cart. Null otherwise
+ */
+const validateCart = async (_, { cart: { order }, session }, ctx) => {
+    const { orderNumber, acceptedOffer, shouldSplitItem } = order;
+    const { clients: { commerce }, loaders: { skuLoader }, } = ctx;
+    const channel = session?.channel;
+    const locale = session?.locale;
+    if (channel) {
+        mutateChannelContext(ctx, channel);
+    }
+    if (locale) {
+        mutateLocaleContext(ctx, locale);
+    }
+    // Step1: Get OrderForm from VTEX Commerce
+    const orderForm = await getOrderForm(orderNumber, ctx);
+    // Clear messages so it doesn't keep populating toasts on a loop
+    // In the next validateCart mutation it will only have messages if a new message is created on orderForm
+    if (orderForm.messages.length !== 0) {
+        await clearOrderFormMessages(orderNumber, ctx);
+    }
+    // Step1.5: Check if another system changed the orderForm with this orderNumber
+    // If so, this means the user interacted with this cart elsewhere and expects
+    // to see this new cart state instead of what's stored on the user's browser.
+    const isStale = isOrderFormStale(orderForm);
+    if (isStale && orderNumber) {
+        const newOrderForm = await setOrderFormEtag(orderForm, commerce).then(joinItems);
+        return orderFormToCart(newOrderForm, skuLoader);
+    }
+    // Step2: Process items from both browser and checkout so they have the same shape
+    const browserItemsById = groupById(acceptedOffer);
+    const originItemsById = groupById(orderForm.items.map(orderFormItemToOffer));
+    const originItems = Array.from(originItemsById.entries()); // items on the VTEX platform backend
+    const browserItems = Array.from(browserItemsById.entries()); // items on the user's browser
+    // Step3: Compute delta changes
+    const { itemsToAdd, itemsToUpdate } = browserItems.reduce((acc, [id, items]) => {
+        const maybeOriginItem = originItemsById.get(id);
+        // Adding new items to cart
+        if (!maybeOriginItem) {
+            items.forEach((item) => acc.itemsToAdd.push(item));
+            return acc;
+        }
+        // Update existing items
+        const [head, ...tail] = maybeOriginItem;
+        const totalQuantity = items.reduce((acc, curr) => acc + curr.quantity, 0);
+        // set total quantity to first item
+        acc.itemsToUpdate.push({
+            ...head,
+            quantity: totalQuantity,
+        });
+        // Remove all the rest
+        tail.forEach((item) => acc.itemsToUpdate.push({ ...item, quantity: 0 }));
+        return acc;
+    }, {
+        itemsToAdd: [],
+        itemsToUpdate: [],
+    });
+    const itemsToDelete = originItems
+        .filter(([id]) => !browserItemsById.has(id))
+        .flatMap(([, items]) => items.map((item) => ({ ...item, quantity: 0 })));
+    const changes = [...itemsToAdd, ...itemsToUpdate, ...itemsToDelete].map(offerToOrderItemInput);
+    if (changes.length === 0) {
+        return null;
+    }
+    // Step4: Apply delta changes to order form
+    const updatedOrderForm = await commerce.checkout
+        // update orderForm items
+        .updateOrderFormItems({
+        id: orderForm.orderFormId,
+        orderItems: changes,
+        shouldSplitItem,
+    })
+        // update orderForm shippingData
+        .then((form) => updateOrderFormShippingData(form, session, ctx))
+        // update orderForm etag so we know last time we touched this orderForm
+        .then((form) => setOrderFormEtag(form, commerce))
+        .then(joinItems);
+    const equalMessages = external_fast_deep_equal_default()(orderForm.messages, updatedOrderForm.messages);
+    // Step5: If no changes detected before/after updating orderForm, the order is validated
+    if (equals(order, updatedOrderForm) && equalMessages) {
+        return null;
+    }
+    // Step6: There were changes, convert orderForm to StoreCart
+    return orderFormToCart(updatedOrderForm, skuLoader);
+};
+//# sourceMappingURL=validateCart.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/validateSession.js
+
+
+const validateSession = async (_, { session: oldSession, search }, { clients }) => {
+    const channel = ChannelMarshal.parse(oldSession.channel ?? '');
+    const postalCode = String(oldSession.postalCode ?? '').replace(/\D/g, '');
+    const geoCoordinates = oldSession.geoCoordinates ?? null;
+    const country = oldSession.country ?? '';
+    const params = new URLSearchParams(search);
+    const salesChannel = params.get('sc') ?? channel.salesChannel;
+    params.set('sc', salesChannel);
+    const [regionData, sessionData] = await Promise.all([
+        postalCode || geoCoordinates
+            ? clients.commerce.checkout.region({
+                postalCode,
+                geoCoordinates,
+                country,
+                salesChannel,
+            })
+            : Promise.resolve(null),
+        clients.commerce.session(params.toString()).catch(() => null),
+    ]);
+    const profile = sessionData?.namespaces.profile ?? null;
+    const store = sessionData?.namespaces.store ?? null;
+    const region = regionData?.[0];
+    // Set seller only if it's inside a region
+    const seller = region?.sellers.find((seller) => channel.seller === seller.id);
+    const newSession = {
+        ...oldSession,
+        currency: {
+            code: store?.currencyCode.value ?? oldSession.currency.code,
+            symbol: store?.currencySymbol.value ?? oldSession.currency.symbol,
+        },
+        country: store?.countryCode.value ?? oldSession.country,
+        channel: ChannelMarshal.stringify({
+            salesChannel: store?.channel?.value ?? channel.salesChannel,
+            regionId: region?.id ?? channel.regionId,
+            seller: seller?.id,
+        }),
+        person: profile?.id
+            ? {
+                id: profile.id?.value ?? '',
+                email: profile.email?.value ?? '',
+                givenName: profile.firstName?.value ?? '',
+                familyName: profile.lastName?.value ?? '',
+            }
+            : null,
+    };
+    if (external_fast_deep_equal_default()(oldSession, newSession)) {
+        return null;
+    }
+    return newSession;
+};
+//# sourceMappingURL=validateSession.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/mutation.js
+
+
+
+const Mutation = {
+    validateCart: validateCart,
+    validateSession: validateSession,
+    subscribeToNewsletter: subscribeToNewsletter,
+};
+//# sourceMappingURL=mutation.js.map
+// EXTERNAL MODULE: external "graphql"
+var external_graphql_ = __webpack_require__(7343);
+// EXTERNAL MODULE: external "graphql/language"
+var language_ = __webpack_require__(6548);
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/objectOrString.js
+
+
+const ObjectOrString = new external_graphql_.GraphQLScalarType({
+    name: 'ObjectOrString',
+    description: 'A string or the string representation of an object (a stringified object).',
+    parseValue: toObjectOrString,
+    serialize: stringify,
+    parseLiteral(ast) {
+        if (ast.kind === language_.Kind.STRING) {
+            return getValueAsObjectOrString(ast.value);
+        }
+        return null;
+    },
+});
+function toObjectOrString(value) {
+    if (typeof value === 'string') {
+        return getValueAsObjectOrString(value);
+    }
+    return null;
+}
+function getValueAsObjectOrString(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        return value;
+    }
+}
+function stringify(value) {
+    if (typeof value === 'object') {
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    return null;
+}
+//# sourceMappingURL=objectOrString.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/offer.js
+
+const isSearchItem = (item) => 'Price' in item && 'seller' in item && 'product' in item;
+const isOrderFormItem = (item) => 'skuName' in item;
+const StoreOffer = {
+    priceCurrency: async (_, __, ctx) => {
+        const { loaders: { salesChannelLoader }, storage: { channel } } = ctx;
+        const sc = await salesChannelLoader.load(channel.salesChannel);
+        return sc.CurrencyCode ?? '';
+    },
+    priceValidUntil: (root) => {
+        if (isSearchItem(root)) {
+            return root.PriceValidUntil ?? '';
+        }
+        if (isOrderFormItem(root)) {
+            return root.priceValidUntil ?? '';
+        }
+        return null;
+    },
+    itemCondition: () => 'https://schema.org/NewCondition',
+    availability: async (root) => {
+        if (isSearchItem(root)) {
+            return availability(inStock(root));
+        }
+        if (isOrderFormItem(root)) {
+            return availability(inStockOrderFormItem(root.availability));
+        }
+        return null;
+    },
+    seller: (root, _, ctx) => {
+        if (isSearchItem(root)) {
+            return {
+                identifier: ctx.storage.channel?.seller || root.seller.sellerId || '',
+            };
+        }
+        if (isOrderFormItem(root)) {
+            return {
+                identifier: root.seller,
+            };
+        }
+        return null;
+    },
+    price: (root) => {
+        if (isSearchItem(root)) {
+            return price(root);
+        }
+        if (isOrderFormItem(root)) {
+            return root.sellingPrice / 1e2;
+        }
+        return null;
+    },
+    sellingPrice: (root) => {
+        if (isSearchItem(root)) {
+            return sellingPrice(root);
+        }
+        if (isOrderFormItem(root)) {
+            return root.sellingPrice / 1e2;
+        }
+        return null;
+    },
+    listPrice: (root) => {
+        if (isSearchItem(root)) {
+            return root.ListPrice ?? 0;
+        }
+        if (isOrderFormItem(root)) {
+            return root.listPrice / 1e2;
+        }
+        return null;
+    },
+    itemOffered: (root) => {
+        if (isSearchItem(root)) {
+            return root.product;
+        }
+        if (isOrderFormItem(root)) {
+            return {
+                ...root.product,
+                attachmentsValues: root.attachments,
+            };
+        }
+        return null;
+    },
+    quantity: (root) => {
+        if (isSearchItem(root)) {
+            return root.AvailableQuantity ?? 0;
+        }
+        if (isOrderFormItem(root)) {
+            return root.quantity;
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=offer.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/canonical.js
+const canonicalFromProduct = ({ linkText }) => `/${linkText}/p`;
+//# sourceMappingURL=canonical.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/enhanceCommercialOffer.js
+const enhanceCommercialOffer = ({ offer, seller, product, }) => ({
+    ...offer,
+    product,
+    seller,
+});
+//# sourceMappingURL=enhanceCommercialOffer.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/product.js
+
+
+
+
+
+const DEFAULT_IMAGE = {
+    imageText: 'image',
+    imageUrl: 'https://storecomponents.vtexassets.com/assets/faststore/images/image___117a6d3e229a96ad0e0d0876352566e2.svg',
+};
+const getSlug = (link, id) => `${link}-${id}`;
+const getPath = (link, id) => `/${getSlug(link, id)}/p`;
+const nonEmptyArray = (array) => Array.isArray(array) && array.length > 0 ? array : null;
+const StoreProduct = {
+    productID: ({ itemId }) => itemId,
+    name: ({ isVariantOf, name }) => name ?? isVariantOf.productName,
+    slug: ({ isVariantOf: { linkText }, itemId }) => getSlug(linkText, itemId),
+    description: ({ isVariantOf: { description } }) => description,
+    seo: ({ isVariantOf }) => ({
+        title: isVariantOf.productName,
+        description: isVariantOf.description,
+        canonical: canonicalFromProduct(isVariantOf),
+    }),
+    brand: ({ isVariantOf: { brand } }) => ({ name: brand }),
+    breadcrumbList: ({ isVariantOf: { categories, productName, linkText }, itemId, }) => {
+        return {
+            itemListElement: [
+                ...categories.reverse().map((categoryPath, index) => {
+                    const splitted = categoryPath.split('/');
+                    const name = splitted[splitted.length - 2];
+                    const item = splitted.map(slugify).join('/');
+                    return {
+                        name,
+                        item,
+                        position: index + 1,
+                    };
+                }),
+                {
+                    name: productName,
+                    item: getPath(linkText, itemId),
+                    position: categories.length + 1,
+                },
+            ],
+            numberOfItems: categories.length,
+        };
+    },
+    image: ({ images }) => (nonEmptyArray(images) ?? [DEFAULT_IMAGE]).map(({ imageUrl, imageText }) => ({
+        alternateName: imageText ?? '',
+        url: imageUrl.replace('vteximg.com.br', 'vtexassets.com'),
+    })),
+    sku: ({ itemId }) => itemId,
+    gtin: ({ referenceId }) => referenceId[0]?.Value ?? '',
+    review: () => [],
+    aggregateRating: () => ({}),
+    offers: (root) => root.sellers
+        .map((seller) => enhanceCommercialOffer({
+        offer: seller.commertialOffer,
+        seller,
+        product: root,
+    }))
+        .sort(bestOfferFirst),
+    isVariantOf: (root) => root,
+    additionalProperty: ({ 
+    // Search uses the name variations for specifications
+    variations: specifications = [], attachmentsValues = [], }) => {
+        const propertyValueSpecifications = specifications.flatMap(({ name, values }) => values.map((value) => ({
+            name,
+            value,
+            valueReference: VALUE_REFERENCES.specification,
+        })));
+        const propertyValueAttachments = attachmentsValues.map(attachmentToPropertyValue);
+        return [...propertyValueSpecifications, ...propertyValueAttachments];
+    },
+    releaseDate: ({ isVariantOf: { releaseDate } }) => releaseDate ?? ''
+};
+//# sourceMappingURL=product.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/productGroup.js
+
+
+const BLOCKED_SPECIFICATIONS = new Set(['allSpecifications']);
+const StoreProductGroup = {
+    hasVariant: (root) => root.isVariantOf.items.map((item) => enhanceSku(item, root.isVariantOf)),
+    productGroupID: ({ isVariantOf }) => isVariantOf.productId,
+    name: (root) => root.isVariantOf.productName,
+    skuVariants: (root) => root,
+    additionalProperty: ({ isVariantOf: { specificationGroups } }) => specificationGroups
+        // Filter sku specifications so we don't mix them with product specs.
+        .filter((specificationGroup) => !BLOCKED_SPECIFICATIONS.has(specificationGroup.name))
+        // Transform specs back into product specs.
+        .flatMap(({ specifications }) => specifications.flatMap(({ name, values }) => values.map((value) => ({
+        name,
+        value,
+        valueReference: VALUE_REFERENCES.specification,
+    })))),
+};
+//# sourceMappingURL=productGroup.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/propertyValue.js
+
+const StorePropertyValue = {
+    propertyID: (root) => getPropertyId(root),
+    name: ({ name }) => name,
+    value: ({ value }) => value,
+    valueReference: ({ valueReference }) => valueReference,
+};
+//# sourceMappingURL=propertyValue.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/sort.js
+const SORT_MAP = {
+    price_desc: 'price:desc',
+    price_asc: 'price:asc',
+    orders_desc: 'orders:desc',
+    name_desc: 'name:desc',
+    name_asc: 'name:asc',
+    release_desc: 'release:desc',
+    discount_desc: 'discount:desc',
+    score_desc: '',
+};
+//# sourceMappingURL=sort.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/sku.js
+
+
+/**
+ * This function implements Portal heuristics for returning the best sku for a product.
+ *
+ * The best sku is the one with the best (cheapest available) offer
+ * */
+const pickBestSku = (skus) => {
+    const offersBySku = skus.flatMap((sku) => sku.sellers.map((seller) => ({
+        offer: seller.commertialOffer,
+        sku,
+    })));
+    const best = min(offersBySku, ({ offer: o1 }, { offer: o2 }) => bestOfferFirst(o1, o2));
+    return best ? best.sku : skus[0];
+};
+const isValidSkuId = (skuId) => skuId !== '' && !Number.isNaN(Number(skuId));
+//# sourceMappingURL=sku.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/query.js
+
+
+
+
+
+
+
+
+const Query = {
+    product: async (_, { locator }, ctx) => {
+        // Insert channel in context for later usage
+        const channel = findChannel(locator);
+        const locale = findLocale(locator);
+        const id = findSkuId(locator);
+        const slug = findSlug(locator);
+        if (channel) {
+            mutateChannelContext(ctx, channel);
+        }
+        if (locale) {
+            mutateLocaleContext(ctx, locale);
+        }
+        const { loaders: { skuLoader }, clients: { commerce, search }, } = ctx;
+        try {
+            const skuId = id ?? slug?.split('-').pop() ?? '';
+            if (!isValidSkuId(skuId)) {
+                throw new Error('Invalid SkuId');
+            }
+            const sku = await skuLoader.load(skuId);
+            /**
+             * Here be dragons 🦄🦄🦄
+             *
+             * In some cases, the slug has a valid skuId for a different
+             * product. This condition makes sure that the fetched sku
+             * is the one we actually asked for
+             * */
+            if (slug &&
+                sku.isVariantOf.linkText &&
+                !slug.startsWith(sku.isVariantOf.linkText)) {
+                throw new Error(`Slug was set but the fetched sku does not satisfy the slug condition. slug: ${slug}, linkText: ${sku.isVariantOf.linkText}`);
+            }
+            return sku;
+        }
+        catch (err) {
+            if (slug == null) {
+                throw new errors/* BadRequestError */.oY('Missing slug or id');
+            }
+            const route = await commerce.catalog.portal.pagetype(`${slug}/p`);
+            if (route.pageType !== 'Product' || !route.id) {
+                throw new errors/* NotFoundError */.dR(`No product found for slug ${slug}`);
+            }
+            const { products: [product], } = await search.products({
+                page: 0,
+                count: 1,
+                query: `product:${route.id}`,
+            });
+            if (!product) {
+                throw new errors/* NotFoundError */.dR(`No product found for id ${route.id}`);
+            }
+            const sku = pickBestSku(product.items);
+            return enhanceSku(sku, product);
+        }
+    },
+    collection: (_, { slug }, ctx) => {
+        const { loaders: { collectionLoader }, } = ctx;
+        return collectionLoader.load(slug);
+    },
+    search: async (_, { first, after: maybeAfter, sort, term, selectedFacets }, ctx) => {
+        // Insert channel in context for later usage
+        const channel = findChannel(selectedFacets);
+        const locale = findLocale(selectedFacets);
+        const crossSelling = findCrossSelling(selectedFacets);
+        if (channel) {
+            mutateChannelContext(ctx, channel);
+        }
+        if (locale) {
+            mutateLocaleContext(ctx, locale);
+        }
+        let query = term;
+        /**
+         * In case we are using crossSelling, we need to modify the search
+         * we will be performing on our search engine. The idea in here
+         * is to use the cross selling API for fetching the productIds our
+         * search will return for us.
+         * Doing this two request workflow makes it possible to have cross
+         * selling with Search features, like pagination, internationalization
+         * etc
+         */
+        if (crossSelling) {
+            const products = await ctx.clients.commerce.catalog.products.crossselling({
+                type: FACET_CROSS_SELLING_MAP[crossSelling.key],
+                productId: crossSelling.value,
+            });
+            query = `product:${products
+                .map((x) => x.productId)
+                .slice(0, first)
+                .join(';')}`;
+        }
+        const after = maybeAfter ? Number(maybeAfter) : 0;
+        const searchArgs = {
+            page: Math.ceil(after / first),
+            count: first,
+            query: query ?? undefined,
+            sort: SORT_MAP[sort ?? 'score_desc'],
+            selectedFacets: selectedFacets?.flatMap(transformSelectedFacet) ?? [],
+        };
+        const productSearchPromise = ctx.clients.search.products(searchArgs);
+        return { searchArgs, productSearchPromise };
+    },
+    allProducts: async (_, { first, after: maybeAfter }, ctx) => {
+        const { clients: { search }, } = ctx;
+        const after = maybeAfter ? Number(maybeAfter) : 0;
+        const products = await search.products({
+            page: Math.ceil(after / first),
+            count: first,
+        });
+        const skus = products.products
+            .map((product) => product.items.map((sku) => enhanceSku(sku, product)))
+            .flat()
+            .filter((sku) => sku.sellers.length > 0);
+        return {
+            pageInfo: {
+                hasNextPage: products.pagination.after.length > 0,
+                hasPreviousPage: products.pagination.before.length > 0,
+                startCursor: '0',
+                endCursor: products.recordsFiltered.toString(),
+                totalCount: products.recordsFiltered,
+            },
+            // after + index is bigger than after+first itself because of the array flat() above
+            edges: skus.map((sku, index) => ({
+                node: sku,
+                cursor: (after + index).toString(),
+            })),
+        };
+    },
+    allCollections: async (_, { first, after: maybeAfter }, ctx) => {
+        const { clients: { commerce }, } = ctx;
+        const after = maybeAfter ? Number(maybeAfter) : 0;
+        const [brands, tree] = await Promise.all([
+            commerce.catalog.brand.list(),
+            commerce.catalog.category.tree(),
+        ]);
+        const categories = [];
+        const dfs = (node, level) => {
+            categories.push({ ...node, level });
+            for (const child of node.children) {
+                dfs(child, level + 1);
+            }
+        };
+        for (const node of tree) {
+            dfs(node, 0);
+        }
+        const collections = [
+            ...brands
+                .filter((brand) => brand.isActive)
+                .map((x) => ({ ...x, type: 'brand' })),
+            ...categories,
+        ];
+        const validCollections = collections
+            // Nullable slugs may cause one route to override the other
+            .filter((node) => Boolean(StoreCollection.slug(node, null, ctx, null)));
+        return {
+            pageInfo: {
+                hasNextPage: validCollections.length - after > first,
+                hasPreviousPage: after > 0,
+                startCursor: '0',
+                endCursor: (Math.min(first, validCollections.length - after) - 1).toString(),
+                totalCount: validCollections.length,
+            },
+            edges: validCollections
+                .slice(after, after + first)
+                .map((node, index) => ({
+                node,
+                cursor: (after + index).toString(),
+            })),
+        };
+    },
+    shipping: async (_, { country, items, postalCode }, ctx) => {
+        const { loaders: { simulationLoader }, clients: { commerce }, } = ctx;
+        const [simulation, address] = await Promise.all([
+            simulationLoader.load({ country, items, postalCode }),
+            commerce.checkout.address({ postalCode, country }),
+        ]);
+        return {
+            ...simulation,
+            address,
+        };
+    },
+    redirect: async (_, { term, selectedFacets }, ctx) => {
+        // Currently the search redirection can be done through a search term or filter (facet) so we limit the redirect query to always have one of these values otherwise we do not execute it.
+        // https://help.vtex.com/en/tracks/vtex-intelligent-search--19wrbB7nEQcmwzDPl1l4Cb/4Gd2wLQFbCwTsh8RUDwSoL?&utm_source=autocomplete
+        if (!term && (!selectedFacets || !selectedFacets.length)) {
+            return null;
+        }
+        const { redirect } = await ctx.clients.search.products({
+            page: 1,
+            count: 1,
+            query: term ?? undefined,
+            selectedFacets: selectedFacets?.flatMap(transformSelectedFacet) ?? [],
+        });
+        return {
+            url: redirect,
+        };
+    },
+    sellers: async (_, { postalCode, geoCoordinates, country, salesChannel }, ctx) => {
+        const { clients: { commerce }, } = ctx;
+        const regionData = await commerce.checkout.region({
+            postalCode,
+            geoCoordinates,
+            country,
+            salesChannel,
+        });
+        const region = regionData?.[0];
+        const { id, sellers } = region;
+        return {
+            id,
+            sellers,
+        };
+    },
+};
+//# sourceMappingURL=query.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/review.js
+const StoreReview = {
+    reviewRating: () => ({
+        ratingValue: 5,
+        bestRating: 5,
+    }),
+    author: () => ({
+        name: '',
+    }),
+};
+//# sourceMappingURL=review.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/searchResult.js
+
+
+const isRootFacet = (facet, isDepartment, isBrand) => isDepartment
+    ? facet.key === 'category-1'
+    : isBrand
+        ? facet.key === 'brand'
+        : false;
+const StoreSearchResult = {
+    suggestions: async (root, _, ctx) => {
+        const { clients: { search }, } = ctx;
+        const { searchArgs } = root;
+        // If there's no search query, suggest the most popular searches.
+        if (!searchArgs.query) {
+            const topSearches = await search.topSearches();
+            return {
+                terms: topSearches.searches.map((item) => ({
+                    value: item.term,
+                    count: item.count,
+                })),
+                products: [],
+            };
+        }
+        const { productSearchPromise } = root;
+        const [terms, productSearchResult] = await Promise.all([
+            search.suggestedTerms(searchArgs),
+            productSearchPromise,
+        ]);
+        const skus = productSearchResult.products
+            .map((product) => {
+            // What determines the presentation of the SKU is the price order
+            // https://help.vtex.com/pt/tutorial/ordenando-imagens-na-vitrine-e-na-pagina-de-produto--tutorials_278
+            const maybeSku = pickBestSku(product.items);
+            return maybeSku && enhanceSku(maybeSku, product);
+        })
+            .filter((sku) => !!sku);
+        const { searches } = terms;
+        return {
+            terms: searches.map((item) => ({ value: item.term, count: item.count })),
+            products: skus,
+        };
+    },
+    products: async ({ productSearchPromise }) => {
+        const productSearchResult = await productSearchPromise;
+        const skus = productSearchResult.products
+            .map((product) => {
+            // What determines the presentation of the SKU is the price order
+            // https://help.vtex.com/pt/tutorial/ordenando-imagens-na-vitrine-e-na-pagina-de-produto--tutorials_278
+            const maybeSku = pickBestSku(product.items);
+            return maybeSku && enhanceSku(maybeSku, product);
+        })
+            .filter((sku) => !!sku);
+        return {
+            pageInfo: {
+                hasNextPage: productSearchResult.pagination.after.length > 0,
+                hasPreviousPage: productSearchResult.pagination.before.length > 0,
+                startCursor: '0',
+                endCursor: productSearchResult.recordsFiltered.toString(),
+                totalCount: productSearchResult.recordsFiltered,
+            },
+            edges: skus.map((sku, index) => ({
+                node: sku,
+                cursor: index.toString(),
+            })),
+        };
+    },
+    facets: async ({ searchArgs }, _, ctx) => {
+        const { clients: { search: is }, } = ctx;
+        ctx.storage.searchArgs = searchArgs;
+        const { facets = [] } = await is.facets(searchArgs);
+        const isCollectionPage = !searchArgs.query;
+        const isDepartment = searchArgs.selectedFacets?.length
+            ? searchArgs.selectedFacets[0].key === 'category-1'
+            : false;
+        const isBrand = searchArgs.selectedFacets?.length
+            ? searchArgs.selectedFacets[0].key === 'brand'
+            : false;
+        const filteredFacets = facets
+            // Remove root facet on category and brand pages
+            // TODO: Hide category filters for category pages. E.g. /office/desks
+            .filter((facet) => !isCollectionPage || !isRootFacet(facet, isDepartment, isBrand));
+        return filteredFacets;
+    },
+    metadata: async ({ searchArgs, productSearchPromise }) => {
+        if (!searchArgs.query) {
+            return null;
+        }
+        const productSearchResult = await productSearchPromise;
+        return {
+            isTermMisspelled: productSearchResult.correction?.misspelled ?? false,
+            logicalOperator: productSearchResult.operator,
+        };
+    },
+};
+//# sourceMappingURL=searchResult.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/seo.js
+const StoreSeo = {
+    title: ({ title }) => title ?? '',
+    description: ({ description }) => description ?? '',
+    canonical: ({ canonical }) => canonical ?? '',
+    titleTemplate: () => '',
+};
+//# sourceMappingURL=seo.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/shippingSLA.js
+const units = ['bd', 'd', 'h', 'm'];
+const isUnit = (x) => units.includes(x);
+const localizedEstimates = {
+    bd: {
+        0: 'Today',
+        1: 'In 1 business day',
+        other: `Up to # business days`,
+    },
+    d: {
+        0: 'Today',
+        1: 'In 1 day',
+        other: 'Up to # days',
+    },
+    h: {
+        0: 'Now',
+        1: 'In 1 hour',
+        other: 'Up to # hours',
+    },
+    m: {
+        0: 'Now',
+        1: 'In 1 minute',
+        other: 'Up to # minutes',
+    },
+};
+/**
+ * Transforms estimate (e.g 3bd) into friendly format (e.g Up to 3 business days)
+ * based on https://github.com/vtex-apps/shipping-estimate-translator/blob/13e17055d6353dd3f3f4c31bae77ab049002809b/messages/en.json
+ */
+const getLocalizedEstimates = (estimate) => {
+    const [amount, unit] = [estimate.split(/\D+/)[0], estimate.split(/[0-9]+/)[1]];
+    const isAmountNumber = amount !== '' && !Number.isNaN(Number(amount));
+    const isUnitValid = isUnit(unit);
+    if (!isAmountNumber || !isUnitValid) {
+        return '';
+    }
+    const amountKey = Number(amount) < 2 ? Number(amount) : 'other';
+    return localizedEstimates[unit][amountKey].replace('#', amount) ?? '';
+};
+const ShippingSLA = {
+    carrier: (root) => root?.friendlyName ?? root?.name ?? '',
+    price: (root) => (root?.price ? root.price / 100 : root?.price),
+    localizedEstimates: (root) => root?.shippingEstimate ? getLocalizedEstimates(root.shippingEstimate) : '',
+};
+//# sourceMappingURL=shippingSLA.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/utils/skuVariants.js
+function findSkuVariantImage(availableImages) {
+    return (availableImages.find((imageProperties) => imageProperties.imageLabel === 'skuvariation') ?? availableImages[0]);
+}
+function createSlugsMap(variants, dominantVariantName, baseSlug) {
+    /**
+     * Maps property value combinations to their respective SKU's slug. Enables
+     * us to retrieve the slug for the SKU that matches the currently selected
+     * variations in O(1) time.
+     *
+     * Example: `'Color-Red-Size-40': 'classic-shoes-37'`
+     */
+    const slugsMap = {};
+    variants.forEach((variant) => {
+        const skuSpecificationProperties = variant.variations;
+        if (skuSpecificationProperties.length === 0) {
+            return;
+        }
+        // Make sure that the 'name-value' pair for the dominant variation
+        // is always the first one.
+        const dominantNameValue = `${dominantVariantName}-${skuSpecificationProperties.find((variationDetails) => variationDetails.name === dominantVariantName)?.values[0] ?? ''}`;
+        const skuVariantKey = skuSpecificationProperties.reduce((acc, property) => {
+            const shouldIgnore = property.name === dominantVariantName;
+            if (shouldIgnore) {
+                return acc;
+            }
+            return acc + `-${property.name}-${property.values[0]}`;
+        }, dominantNameValue);
+        slugsMap[skuVariantKey] = `${baseSlug}-${variant.itemId}`;
+    });
+    return slugsMap;
+}
+function getActiveSkuVariations(variations) {
+    const activeVariations = {};
+    variations.forEach((variation) => {
+        activeVariations[variation.name] = variation.values[0];
+    });
+    return activeVariations;
+}
+function getVariantsByName(skuSpecifications) {
+    const variants = {};
+    skuSpecifications?.forEach((specification) => {
+        variants[specification.field.originalName ?? specification.field.name] =
+            specification.values.map((value) => value.originalName ?? value.name);
+    });
+    return variants;
+}
+function compare(a, b) {
+    // Values are always represented as Strings, so we need to handle numbers
+    // in this special case.
+    if (!Number.isNaN(Number(a) - Number(b))) {
+        return Number(a) - Number(b);
+    }
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    return 0;
+}
+function sortVariants(variantsByName) {
+    const sortedVariants = variantsByName;
+    for (const variantProperty in variantsByName) {
+        variantsByName[variantProperty].sort((a, b) => compare(a.value, b.value));
+    }
+    return sortedVariants;
+}
+function getFormattedVariations(variants, dominantVariantName, dominantVariantValue) {
+    /**
+     * SKU options already formatted and indexed by their property name.
+     *
+     * Ex: {
+     *   `Size`: [
+     *     { label: '42', value: '42' },
+     *     { label: '41', value: '41' },
+     *     { label: '39', value: '39' },
+     *   ]
+     * }
+     */
+    const variantsByName = {};
+    const previouslySeenPropertyValues = new Set();
+    variants.forEach((variant) => {
+        if (variant.variations.length === 0) {
+            return;
+        }
+        const variantImageToUse = findSkuVariantImage(variant.images);
+        const dominantVariantEntry = variant.variations.find((variation) => variation.name === dominantVariantName);
+        const matchesDominantVariant = dominantVariantEntry?.values[0] === dominantVariantValue;
+        if (!matchesDominantVariant) {
+            const nameValueIdentifier = `${dominantVariantName}-${dominantVariantEntry?.values[0]}`;
+            if (!dominantVariantEntry ||
+                previouslySeenPropertyValues.has(nameValueIdentifier)) {
+                return;
+            }
+            previouslySeenPropertyValues.add(nameValueIdentifier);
+            const formattedVariant = {
+                src: variantImageToUse.imageUrl,
+                alt: variantImageToUse.imageLabel ?? '',
+                label: `${dominantVariantName}: ${dominantVariantEntry.values[0]}`,
+                value: dominantVariantEntry.values[0],
+            };
+            if (variantsByName[dominantVariantEntry.name]) {
+                variantsByName[dominantVariantEntry.name].push(formattedVariant);
+            }
+            else {
+                variantsByName[dominantVariantEntry.name] = [formattedVariant];
+            }
+            return;
+        }
+        variant.variations.forEach((variationProperty) => {
+            const nameValueIdentifier = `${variationProperty.name}-${variationProperty.values[0]}`;
+            if (previouslySeenPropertyValues.has(nameValueIdentifier)) {
+                return;
+            }
+            previouslySeenPropertyValues.add(nameValueIdentifier);
+            const formattedVariant = {
+                src: variantImageToUse.imageUrl,
+                alt: variantImageToUse.imageLabel ?? '',
+                label: `${variationProperty.name}: ${variationProperty.values[0]}`,
+                value: variationProperty.values[0],
+            };
+            if (variantsByName[variationProperty.name]) {
+                variantsByName[variationProperty.name].push(formattedVariant);
+            }
+            else {
+                variantsByName[variationProperty.name] = [formattedVariant];
+            }
+        });
+    });
+    return sortVariants(variantsByName);
+}
+//# sourceMappingURL=skuVariants.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/resolvers/skuVariations.js
+
+const SkuVariants = {
+    activeVariations: (root) => getActiveSkuVariations(root.variations),
+    allVariantsByName: (root) => getVariantsByName(root.isVariantOf.skuSpecifications),
+    slugsMap: (root, args) => createSlugsMap(root.isVariantOf.items, args.dominantVariantName ?? root.variations[0]?.name, root.isVariantOf.linkText),
+    availableVariations: (root, args) => {
+        const dominantVariantName = args.dominantVariantName ?? root.variations[0]?.name;
+        const activeVariations = getActiveSkuVariations(root.variations);
+        const activeDominantVariationValue = activeVariations[dominantVariantName];
+        const filteredFormattedVariations = getFormattedVariations(root.isVariantOf.items, dominantVariantName, activeDominantVariationValue);
+        return filteredFormattedVariations;
+    },
+};
+//# sourceMappingURL=skuVariations.js.map
+;// CONCATENATED MODULE: ../api/dist/esm/src/platforms/vtex/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const Resolvers = {
+    StoreCollection: StoreCollection,
+    StoreAggregateOffer: StoreAggregateOffer,
+    StoreProduct: StoreProduct,
+    StoreSeo: StoreSeo,
+    StoreFacet: StoreFacet,
+    StoreFacetBoolean: StoreFacetBoolean,
+    StoreFacetRange: StoreFacetRange,
+    StoreFacetValueBoolean: StoreFacetValueBoolean,
+    StoreOffer: StoreOffer,
+    StoreAggregateRating: StoreAggregateRating,
+    StoreReview: StoreReview,
+    StoreProductGroup: StoreProductGroup,
+    StoreSearchResult: StoreSearchResult,
+    StorePropertyValue: StorePropertyValue,
+    SkuVariants: SkuVariants,
+    ShippingSLA: ShippingSLA,
+    ObjectOrString: ObjectOrString,
+    Query: Query,
+    Mutation: Mutation,
+};
+const getContextFactory = (options) => (ctx) => {
+    ctx.storage = {
+        channel: ChannelMarshal.parse(options.channel),
+        flags: options.flags ?? {},
+        locale: options.locale,
+    };
+    ctx.clients = getClients(options, ctx);
+    ctx.loaders = getLoaders(options, ctx);
+    return ctx;
+};
+const getResolvers = (_) => Resolvers;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 941:
+/***/ ((__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) => {
+
+
+// UNUSED EXPORTS: getTelemetry
+
+// EXTERNAL MODULE: external "@opentelemetry/sdk-trace-base"
+var sdk_trace_base_ = __webpack_require__(1283);
+// EXTERNAL MODULE: external "@opentelemetry/resources"
+var resources_ = __webpack_require__(4161);
+// EXTERNAL MODULE: external "@opentelemetry/exporter-trace-otlp-grpc"
+var exporter_trace_otlp_grpc_ = __webpack_require__(5196);
+// EXTERNAL MODULE: external "@opentelemetry/sdk-logs"
+var sdk_logs_ = __webpack_require__(2793);
+// EXTERNAL MODULE: external "@opentelemetry/exporter-logs-otlp-grpc"
+var exporter_logs_otlp_grpc_ = __webpack_require__(6969);
+// EXTERNAL MODULE: external "@opentelemetry/api"
+var api_ = __webpack_require__(4691);
+// EXTERNAL MODULE: external "@opentelemetry/api-logs"
+var api_logs_ = __webpack_require__(8973);
+// EXTERNAL MODULE: external "graphql"
+var external_graphql_ = __webpack_require__(7343);
+;// CONCATENATED MODULE: ../api/dist/esm/src/telemetry/useFaststoreTelemetry.js
+
+
+
+
+
+
+var AttributeName;
+(function (AttributeName) {
+    AttributeName["EXECUTION_ERROR"] = "graphql.error";
+    AttributeName["EXECUTION_RESULT"] = "graphql.result";
+    AttributeName["RESOLVER_EXECUTION_ERROR"] = "graphql.resolver.error";
+    AttributeName["RESOLVER_EXCEPTION"] = "graphql.resolver.exception";
+    AttributeName["RESOLVER_FIELD_NAME"] = "graphql.resolver.fieldName";
+    AttributeName["RESOLVER_TYPE_NAME"] = "graphql.resolver.typeName";
+    AttributeName["RESOLVER_RESULT_TYPE"] = "graphql.resolver.resultType";
+    AttributeName["RESOLVER_ARGS"] = "graphql.resolver.args";
+    AttributeName["EXECUTION_OPERATION_NAME"] = "graphql.operation.name";
+    AttributeName["EXECUTION_OPERATION_TYPE"] = "graphql.operation.type";
+    AttributeName["EXECUTION_OPERATION_DOCUMENT"] = "graphql.document";
+    AttributeName["EXECUTION_VARIABLES"] = "graphql.variables";
+})(AttributeName || (AttributeName = {}));
+const tracingSpanSymbol = Symbol('OPEN_TELEMETRY_GRAPHQL');
+function getResolverSpanKey(path) {
+    const nodes = [];
+    // If the first node (after reversed, it will be the last one) is an integer, that is, identifies a list,
+    // we don't want to include it in the key. Note that this will only happen when analysing .prev paths in
+    // a list of elements. We just want to remove the initial node that is a integer, not all of them.
+    //
+    // Nodes with keys 6bc73341b2a183fc::product::image::0::url would not be able to find
+    // parents with key 6bc73341b2a183fc::product::image because of the "0" list index -
+    // it would search for 6bc73341b2a183fc::product::image::0
+    let currentPath = nodes.length === 0 && Number.isInteger(path.key) ? path.prev : path;
+    while (currentPath) {
+        nodes.push(currentPath.key);
+        currentPath = currentPath.prev;
+    }
+    return [...nodes].reverse().join('.');
+}
+const useFaststoreTelemetry_getFaststoreTelemetryPlugin = (tracingProvider, loggerProvider, serviceName, experimentalSendLogs) => {
+    return function useFaststoreTelemetry() {
+        const tracer = tracingProvider.getTracer(serviceName);
+        const logger = loggerProvider.getLogger(serviceName);
+        const resolverContextsByRootSpans = {};
+        return {
+            onPluginInit({ addPlugin }) {
+                addPlugin(
+                // eslint-disable-next-line
+                useOnResolve(({ info, context }) => {
+                    if (context &&
+                        typeof context === 'object' &&
+                        context[tracingSpanSymbol]) {
+                        tracer.getActiveSpanProcessor();
+                        const rootContextSpanId = context[tracingSpanSymbol].spanContext().spanId;
+                        const { fieldName, returnType, parentType, path } = info;
+                        const previousResolverSpanKey = path.prev && getResolverSpanKey(path.prev);
+                        let ctx = null;
+                        if (previousResolverSpanKey &&
+                            resolverContextsByRootSpans[rootContextSpanId][previousResolverSpanKey]) {
+                            ctx =
+                                resolverContextsByRootSpans[rootContextSpanId][previousResolverSpanKey];
+                        }
+                        else {
+                            ctx = openTelTrace.setSpan(openTelContext.active(), context[tracingSpanSymbol]);
+                            resolverContextsByRootSpans[rootContextSpanId] =
+                                resolverContextsByRootSpans[rootContextSpanId] ?? {};
+                        }
+                        const resolverIndexInList = Number.isInteger(path.prev?.key)
+                            ? `[${path.prev?.key}]`
+                            : '';
+                        const resolverSpan = tracer.startSpan(`${parentType.toString()}.${fieldName}${resolverIndexInList}`, {
+                            attributes: {
+                                [AttributeName.RESOLVER_FIELD_NAME]: fieldName,
+                                [AttributeName.RESOLVER_TYPE_NAME]: parentType.toString(),
+                                [AttributeName.RESOLVER_RESULT_TYPE]: returnType.toString(),
+                                'meta.span.path': getResolverSpanKey(path),
+                            },
+                        }, ctx);
+                        const resolverCtx = openTelTrace.setSpan(ctx, resolverSpan);
+                        resolverContextsByRootSpans[rootContextSpanId][getResolverSpanKey(path)] = resolverCtx;
+                        return ({ result }) => {
+                            if (result instanceof Error) {
+                                resolverSpan.setAttributes({
+                                    error: true,
+                                    'exception.category': AttributeName.RESOLVER_EXECUTION_ERROR,
+                                    'exception.message': result.message,
+                                    'exception.type': result.name,
+                                });
+                                resolverSpan.recordException(result);
+                            }
+                            resolverSpan.end();
+                        };
+                    }
+                    return () => { };
+                }));
+            },
+            onExecute({ args, extendContext }) {
+                const operationType = args.document.definitions
+                    .filter((def) => def.kind === Kind.OPERATION_DEFINITION)
+                    .map((def) => def.operation)?.[0];
+                // Span name according to Semantic Conventions
+                // https://github.com/open-telemetry/semantic-conventions
+                let spanName = 'GraphQL Operation';
+                if (operationType && args.operationName) {
+                    spanName = `${operationType} ${args.operationName}`;
+                }
+                else if (operationType && !args.operationName) {
+                    spanName = operationType;
+                }
+                const executionSpan = tracer.startSpan(spanName, {
+                    kind: SpanKind.SERVER,
+                    attributes: {
+                        [AttributeName.EXECUTION_OPERATION_NAME]: args.operationName ?? undefined,
+                        [AttributeName.EXECUTION_OPERATION_TYPE]: operationType ?? undefined,
+                        [AttributeName.EXECUTION_OPERATION_DOCUMENT]: print(args.document),
+                    },
+                });
+                const executeContext = openTelContext.active();
+                const resultCbs = {
+                    onExecuteDone({ result }) {
+                        if (isAsyncIterable(result)) {
+                            executionSpan.end();
+                            // eslint-disable-next-line no-console
+                            console.warn(`Plugin "newrelic" encountered a AsyncIterator which is not supported yet, so tracing data is not available for the operation.`);
+                            return;
+                        }
+                        const logRecord = {
+                            context: executeContext,
+                            attributes: {
+                                'service.name': 'faststore-api',
+                                'service.version': '1.12.38',
+                                'service.name_and_version': 'faststore-api@1.12.38',
+                                'vtex.search_index': 'faststore_beta_api',
+                                [AttributeName.EXECUTION_OPERATION_NAME]: args.operationName ?? undefined,
+                                [AttributeName.EXECUTION_OPERATION_DOCUMENT]: print(args.document),
+                                [AttributeName.EXECUTION_VARIABLES]: JSON.stringify(args.variableValues ?? {}),
+                            },
+                        };
+                        if (typeof result.data !== 'undefined' &&
+                            !(result.errors && result.errors.length > 0)) {
+                            logRecord.severityNumber = SeverityNumber.INFO;
+                            logRecord.severityText = 'Info';
+                            logRecord.attributes[AttributeName.EXECUTION_RESULT] =
+                                JSON.stringify(result);
+                        }
+                        if (result.errors && result.errors.length > 0) {
+                            logRecord.severityNumber = SeverityNumber.ERROR;
+                            logRecord.severityText = 'Error';
+                            logRecord.attributes[AttributeName.EXECUTION_ERROR] =
+                                JSON.stringify(result.errors);
+                            executionSpan.setAttributes({
+                                error: true,
+                                'exception.category': AttributeName.EXECUTION_ERROR,
+                                'exception.message': JSON.stringify(result.errors),
+                            });
+                        }
+                        if (experimentalSendLogs) {
+                            logger.emit(logRecord);
+                        }
+                        executionSpan.end();
+                    },
+                };
+                extendContext({
+                    [tracingSpanSymbol]: executionSpan,
+                });
+                return resultCbs;
+            },
+        };
+    };
+};
+//# sourceMappingURL=useFaststoreTelemetry.js.map
+// EXTERNAL MODULE: ../api/dist/esm/package.json
+var esm_package = __webpack_require__(2828);
+;// CONCATENATED MODULE: ../api/dist/esm/src/telemetry/index.js
+
+
+
+
+
+
+
+const FASTSTORE_API_VERSION = esm_package/* version */.i8;
+// TODO: These urls are hardcoded for now, but they should be configurable via ENV variables
+// They are only acessible from within the VTEX network, so they are not a security risk
+const TRACE_COLLECTOR_URL = 'opentelemetry-collector.vtex.systems';
+const TRACE_COLLECTOR_URL_DEV = 'opentelemetry-collector-beta.vtex.systems';
+const LOG_COLLECTOR_URL = 'opentelemetry-collector.vtex.systems';
+function getTelemetry(APIOptions, telemetryOptions) {
+    const honeycombCollectorOptions = {
+        url: telemetryOptions?.mode === 'dev'
+            ? TRACE_COLLECTOR_URL_DEV
+            : TRACE_COLLECTOR_URL,
+    };
+    const openSearchCollectorOptions = {
+        url: LOG_COLLECTOR_URL,
+    };
+    // Create a new tracer provider
+    const tracerProvider = new BasicTracerProvider({
+        resource: new Resource({
+            'service.name': 'faststore-api',
+            'service.version': FASTSTORE_API_VERSION,
+            'service.name_and_version': `faststore-api@${FASTSTORE_API_VERSION}`,
+            platform: APIOptions.platform,
+            [`${APIOptions.platform}.account`]: APIOptions.account,
+            [`${APIOptions.platform}.environment`]: APIOptions.environment,
+            // TODO: include the following properties in the logs
+            // [`${APIOptions.platform}.options.hideUnavailableItems`]:
+            //   APIOptions.hideUnavailableItems,
+            // [`${APIOptions.platform}.flags.enableOrderFormSync`]:
+            //   APIOptions.flags?.enableOrderFormSync,
+            // channel: APIOptions.channel,
+            locale: APIOptions.locale,
+        }),
+    });
+    const loggerProvider = new LoggerProvider();
+    // Create trace exporter
+    const honeycombExporter = new OTLPTraceExporter(honeycombCollectorOptions);
+    // Create log exporter
+    const openSearchExporter = new OTLPLogsExporter(openSearchCollectorOptions);
+    // Set up a span processor to export spans to Honeycomb
+    const honeyCombSpanProcessor = new SimpleSpanProcessor(honeycombExporter);
+    // Set up a log record processor to export spans to OpenSearch
+    const openSearchLogProcessor = new SimpleLogRecordProcessor(openSearchExporter);
+    // Register the span processor with the tracer provider
+    tracerProvider.addSpanProcessor(honeyCombSpanProcessor);
+    // Register the log record processor with the log provider
+    loggerProvider.addLogRecordProcessor(openSearchLogProcessor);
+    if (telemetryOptions?.mode === 'verbose' ||
+        telemetryOptions?.mode === 'dev') {
+        // Set up a console exporter for verbose mode
+        const consoleExporter = new ConsoleSpanExporter();
+        const verboseTraceProcessor = new SimpleSpanProcessor(consoleExporter);
+        // Set up processors for verbose mode
+        const consoleLogExporter = new ConsoleLogRecordExporter();
+        const veboseLogRecordExporter = new SimpleLogRecordProcessor(consoleLogExporter);
+        tracerProvider.addSpanProcessor(verboseTraceProcessor);
+        loggerProvider.addLogRecordProcessor(veboseLogRecordExporter);
+    }
+    const useFaststoreTelemetry = getFaststoreTelemetryPlugin(
+    // The @opentelemetry/sdk-trace-base was renamed from @opentelemetry/tracing but the
+    // envelop plugin doesn't support this change yet. This causes the class type to be incompatible,
+    // even if they are the same. https://github.com/n1ru4l/envelop/issues/1610
+    tracerProvider, loggerProvider, 'faststore-api', telemetryOptions?.experimentalSendLogs ?? false);
+    return { useFaststoreTelemetry };
+}
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 3999:
+/***/ ((module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.a(module, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+/* unused harmony export typeDefs */
+/* harmony import */ var graphql__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7343);
+/* harmony import */ var graphql__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(graphql__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5774);
+var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_1__]);
+_graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_1__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__)[0];
+
+
+// Empty string ('') is interpreted as the current dir. Referencing it as './' won't work.
+const typeDefs = (0,_graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_1__.loadFilesSync)('', { extensions: ['.graphql'] })
+    .map(graphql__WEBPACK_IMPORTED_MODULE_0__.print)
+    .join('\n');
+//# sourceMappingURL=index.js.map
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } });
+
+/***/ }),
+
+/***/ 9297:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+const resolvers = {};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (resolvers);
+
+/***/ }),
+
+/***/ 8299:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+const resolvers = {};
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (resolvers);
+
+/***/ }),
+
+/***/ 9685:
+/***/ ((module, __webpack_exports__, __webpack_require__) => {
+
+__webpack_require__.a(module, async (__webpack_handle_async_dependencies__, __webpack_async_result__) => { try {
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ execute)
+/* harmony export */ });
+/* unused harmony export getEnvelop */
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(1423);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _envelop_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(9664);
+/* harmony import */ var _envelop_graphql_jit__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(7886);
+/* harmony import */ var _envelop_parser_cache__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(4656);
+/* harmony import */ var _envelop_validation_cache__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(6093);
+/* harmony import */ var _faststore_api__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(7397);
+/* harmony import */ var graphql__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(7343);
+/* harmony import */ var graphql__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(graphql__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _graphql_tools_schema__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(6550);
+/* harmony import */ var _graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(5774);
+/* harmony import */ var _generated_graphql_persisted_json__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(6984);
+/* harmony import */ var _customizations_src_graphql_vtex_resolvers__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(8299);
+/* harmony import */ var _customizations_src_graphql_thirdParty_resolvers__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(9297);
+/* harmony import */ var _options__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(1001);
+var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([_envelop_core__WEBPACK_IMPORTED_MODULE_1__, _envelop_graphql_jit__WEBPACK_IMPORTED_MODULE_2__, _envelop_parser_cache__WEBPACK_IMPORTED_MODULE_3__, _envelop_validation_cache__WEBPACK_IMPORTED_MODULE_4__, _faststore_api__WEBPACK_IMPORTED_MODULE_5__, _graphql_tools_schema__WEBPACK_IMPORTED_MODULE_7__, _graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_8__]);
+([_envelop_core__WEBPACK_IMPORTED_MODULE_1__, _envelop_graphql_jit__WEBPACK_IMPORTED_MODULE_2__, _envelop_parser_cache__WEBPACK_IMPORTED_MODULE_3__, _envelop_validation_cache__WEBPACK_IMPORTED_MODULE_4__, _faststore_api__WEBPACK_IMPORTED_MODULE_5__, _graphql_tools_schema__WEBPACK_IMPORTED_MODULE_7__, _graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_8__] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);
+/* eslint-disable react-hooks/rules-of-hooks */
+
+
+
+
+
+
+
+
+
+
+
+
+
+const persistedQueries = new Map(Object.entries(_generated_graphql_persisted_json__WEBPACK_IMPORTED_MODULE_9__));
+const apiContextFactory = (0,_faststore_api__WEBPACK_IMPORTED_MODULE_5__/* .getContextFactory */ .E9)(_options__WEBPACK_IMPORTED_MODULE_10__/* .apiOptions */ .e);
+
+const formatError = err => {
+  if (err instanceof graphql__WEBPACK_IMPORTED_MODULE_6__.GraphQLError && (0,_faststore_api__WEBPACK_IMPORTED_MODULE_5__/* .isFastStoreError */ .T9)(err.originalError)) {
+    return err;
+  }
+
+  console.error(err);
+  return new graphql__WEBPACK_IMPORTED_MODULE_6__.GraphQLError('Sorry, something went wrong.');
+};
+
+function loadGeneratedSchema() {
+  return (0,_graphql_tools_load_files__WEBPACK_IMPORTED_MODULE_8__.loadFilesSync)(path__WEBPACK_IMPORTED_MODULE_0___default().join(process.cwd(), '@generated', 'graphql'), {
+    extensions: ['graphql']
+  });
+}
+
+function getFinalAPISchema() {
+  const generatedSchema = loadGeneratedSchema();
+  const nativeResolvers = (0,_faststore_api__WEBPACK_IMPORTED_MODULE_5__/* .getResolvers */ .yd)(_options__WEBPACK_IMPORTED_MODULE_10__/* .apiOptions */ .e);
+  return (0,_graphql_tools_schema__WEBPACK_IMPORTED_MODULE_7__.makeExecutableSchema)({
+    typeDefs: generatedSchema,
+    resolvers: [nativeResolvers, _customizations_src_graphql_vtex_resolvers__WEBPACK_IMPORTED_MODULE_11__/* ["default"] */ .Z, _customizations_src_graphql_thirdParty_resolvers__WEBPACK_IMPORTED_MODULE_12__/* ["default"] */ .Z]
+  });
+}
+
+const getEnvelop = async () => (0,_envelop_core__WEBPACK_IMPORTED_MODULE_1__.envelop)({
+  plugins: [(0,_envelop_core__WEBPACK_IMPORTED_MODULE_1__.useSchema)(getFinalAPISchema()), (0,_envelop_core__WEBPACK_IMPORTED_MODULE_1__.useExtendContext)(apiContextFactory), (0,_envelop_core__WEBPACK_IMPORTED_MODULE_1__.useMaskedErrors)({
+    formatError
+  }), (0,_envelop_graphql_jit__WEBPACK_IMPORTED_MODULE_2__.useGraphQlJit)(), (0,_envelop_validation_cache__WEBPACK_IMPORTED_MODULE_4__.useValidationCache)(), (0,_envelop_parser_cache__WEBPACK_IMPORTED_MODULE_3__.useParserCache)()]
+});
+const envelopPromise = getEnvelop();
+const execute = async (options, envelopContext = {
+  headers: {}
+}) => {
+  const {
+    operationName,
+    variables,
+    query: maybeQuery
+  } = options;
+  const query = maybeQuery ?? persistedQueries.get(operationName);
+
+  if (query == null) {
+    throw new Error(`No query found for operationName: ${operationName}`);
+  }
+
+  const enveloped = await envelopPromise;
+  const {
+    parse,
+    contextFactory,
+    execute: run,
+    schema
+  } = enveloped(envelopContext);
+  const contextValue = await contextFactory(envelopContext);
+  const {
+    data,
+    errors
+  } = await run({
+    schema,
+    document: parse(query),
+    variableValues: variables,
+    contextValue,
+    operationName
+  });
+  return {
+    data,
+    errors,
+    extensions: {
+      cacheControl: contextValue.cacheControl
+    }
+  };
+};
+__webpack_async_result__();
+} catch(e) { __webpack_async_result__(e); } });
+
+/***/ }),
+
+/***/ 1001:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "e": () => (/* binding */ apiOptions)
+/* harmony export */ });
+/* harmony import */ var _faststore_config__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(7183);
+/* harmony import */ var _faststore_config__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_faststore_config__WEBPACK_IMPORTED_MODULE_0__);
+
+const apiOptions = {
+  platform: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().platform),
+  account: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().api.storeId),
+  environment: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().api.environment),
+  hideUnavailableItems: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().api.hideUnavailableItems),
+  incrementAddress: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().api.incrementAddress),
+  channel: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().session.channel),
+  locale: (_faststore_config__WEBPACK_IMPORTED_MODULE_0___default().session.locale),
+  flags: {
+    enableOrderFormSync: true
+  }
+};
+
+/***/ }),
+
+/***/ 2828:
+/***/ ((module) => {
+
+module.exports = JSON.parse('{"u2":"@faststore/api","i8":"2.2.44"}');
+
+/***/ }),
+
+/***/ 6984:
+/***/ ((module) => {
+
+module.exports = JSON.parse('{"ServerCollectionPageQuery":"query ServerCollectionPageQuery($slug: String!) {\\n  collection(slug: $slug) {\\n    id\\n    seo {\\n      title\\n      description\\n    }\\n    breadcrumbList {\\n      itemListElement {\\n        item\\n        name\\n        position\\n      }\\n    }\\n    meta {\\n      selectedFacets {\\n        key\\n        value\\n      }\\n    }\\n  }\\n}\\n","ServerProductQuery":"query ServerProductQuery($locator: [IStoreSelectedFacet!]!) {\\n  product(locator: $locator) {\\n    id: productID\\n    seo {\\n      title\\n      description\\n      canonical\\n    }\\n    brand {\\n      name\\n    }\\n    sku\\n    gtin\\n    name\\n    description\\n    releaseDate\\n    breadcrumbList {\\n      itemListElement {\\n        item\\n        name\\n        position\\n      }\\n    }\\n    image {\\n      url\\n      alternateName\\n    }\\n    offers {\\n      lowPrice\\n      highPrice\\n      priceCurrency\\n      offers {\\n        availability\\n        price\\n        priceValidUntil\\n        priceCurrency\\n        itemCondition\\n        seller {\\n          identifier\\n        }\\n        listPrice\\n      }\\n    }\\n    isVariantOf {\\n      productGroupID\\n      name\\n      skuVariants {\\n        activeVariations\\n        slugsMap\\n        availableVariations\\n      }\\n    }\\n    additionalProperty {\\n      propertyID\\n      name\\n      value\\n      valueReference\\n    }\\n  }\\n}\\n","ValidateCartMutation":"mutation ValidateCartMutation($cart: IStoreCart!, $session: IStoreSession!) {\\n  validateCart(cart: $cart, session: $session) {\\n    order {\\n      orderNumber\\n      acceptedOffer {\\n        seller {\\n          identifier\\n        }\\n        quantity\\n        price\\n        listPrice\\n        itemOffered {\\n          sku\\n          name\\n          image {\\n            url\\n            alternateName\\n          }\\n          brand {\\n            name\\n          }\\n          isVariantOf {\\n            productGroupID\\n            name\\n            skuVariants {\\n              activeVariations\\n              slugsMap\\n              availableVariations\\n            }\\n          }\\n          gtin\\n          additionalProperty {\\n            propertyID\\n            name\\n            value\\n            valueReference\\n          }\\n        }\\n      }\\n    }\\n    messages {\\n      text\\n      status\\n    }\\n  }\\n}\\n","SubscribeToNewsletter":"mutation SubscribeToNewsletter($data: IPersonNewsletter!) {\\n  subscribeToNewsletter(data: $data) {\\n    id\\n  }\\n}\\n","ClientManyProductsQuery":"query ClientManyProductsQuery($first: Int!, $after: String, $sort: StoreSort!, $term: String!, $selectedFacets: [IStoreSelectedFacet!]!) {\\n  search(\\n    first: $first\\n    after: $after\\n    sort: $sort\\n    term: $term\\n    selectedFacets: $selectedFacets\\n  ) {\\n    products {\\n      pageInfo {\\n        totalCount\\n      }\\n      edges {\\n        node {\\n          id: productID\\n          slug\\n          sku\\n          brand {\\n            brandName: name\\n            name\\n          }\\n          name\\n          gtin\\n          isVariantOf {\\n            productGroupID\\n            name\\n          }\\n          image {\\n            url\\n            alternateName\\n          }\\n          offers {\\n            lowPrice\\n            offers {\\n              availability\\n              price\\n              listPrice\\n              quantity\\n              seller {\\n                identifier\\n              }\\n            }\\n          }\\n        }\\n      }\\n    }\\n  }\\n}\\n","ClientProductGalleryQuery":"query ClientProductGalleryQuery($first: Int!, $after: String!, $sort: StoreSort!, $term: String!, $selectedFacets: [IStoreSelectedFacet!]!) {\\n  search(\\n    first: $first\\n    after: $after\\n    sort: $sort\\n    term: $term\\n    selectedFacets: $selectedFacets\\n  ) {\\n    products {\\n      pageInfo {\\n        totalCount\\n      }\\n    }\\n    facets {\\n      ... on StoreFacetRange {\\n        key\\n        label\\n        min {\\n          selected\\n          absolute\\n        }\\n        max {\\n          selected\\n          absolute\\n        }\\n        __typename\\n      }\\n      ... on StoreFacetBoolean {\\n        key\\n        label\\n        values {\\n          label\\n          value\\n          selected\\n          quantity\\n        }\\n        __typename\\n      }\\n    }\\n    metadata {\\n      isTermMisspelled\\n      logicalOperator\\n    }\\n  }\\n}\\n","ClientProductQuery":"query ClientProductQuery($locator: [IStoreSelectedFacet!]!) {\\n  product(locator: $locator) {\\n    id: productID\\n    sku\\n    name\\n    gtin\\n    description\\n    isVariantOf {\\n      name\\n      productGroupID\\n      skuVariants {\\n        activeVariations\\n        slugsMap\\n        availableVariations\\n      }\\n    }\\n    image {\\n      url\\n      alternateName\\n    }\\n    brand {\\n      name\\n    }\\n    offers {\\n      lowPrice\\n      offers {\\n        availability\\n        price\\n        listPrice\\n        seller {\\n          identifier\\n        }\\n      }\\n    }\\n    additionalProperty {\\n      propertyID\\n      name\\n      value\\n      valueReference\\n    }\\n  }\\n}\\n","ClientSearchSuggestionsQuery":"query ClientSearchSuggestionsQuery($term: String!, $selectedFacets: [IStoreSelectedFacet!]) {\\n  search(first: 5, term: $term, selectedFacets: $selectedFacets) {\\n    suggestions {\\n      terms {\\n        value\\n      }\\n      products {\\n        id: productID\\n        slug\\n        sku\\n        brand {\\n          brandName: name\\n          name\\n        }\\n        name\\n        gtin\\n        isVariantOf {\\n          productGroupID\\n          name\\n        }\\n        image {\\n          url\\n          alternateName\\n        }\\n        offers {\\n          lowPrice\\n          offers {\\n            availability\\n            price\\n            listPrice\\n            quantity\\n            seller {\\n              identifier\\n            }\\n          }\\n        }\\n      }\\n    }\\n    products {\\n      pageInfo {\\n        totalCount\\n      }\\n    }\\n    metadata {\\n      isTermMisspelled\\n      logicalOperator\\n    }\\n  }\\n}\\n","ClientTopSearchSuggestionsQuery":"query ClientTopSearchSuggestionsQuery($term: String!, $selectedFacets: [IStoreSelectedFacet!]) {\\n  search(first: 5, term: $term, selectedFacets: $selectedFacets) {\\n    suggestions {\\n      terms {\\n        value\\n      }\\n    }\\n  }\\n}\\n","ValidateSession":"mutation ValidateSession($session: IStoreSession!, $search: String!) {\\n  validateSession(session: $session, search: $search) {\\n    locale\\n    channel\\n    country\\n    addressType\\n    postalCode\\n    deliveryMode {\\n      deliveryChannel\\n      deliveryMethod\\n      deliveryWindow {\\n        startDate\\n        endDate\\n      }\\n    }\\n    geoCoordinates {\\n      latitude\\n      longitude\\n    }\\n    currency {\\n      code\\n      symbol\\n    }\\n    person {\\n      id\\n      email\\n      givenName\\n      familyName\\n    }\\n  }\\n}\\n","ClientShippingSimulationQuery":"query ClientShippingSimulationQuery($postalCode: String!, $country: String!, $items: [IShippingItem!]!) {\\n  shipping(items: $items, postalCode: $postalCode, country: $country) {\\n    address {\\n      city\\n      neighborhood\\n      state\\n    }\\n    logisticsInfo {\\n      slas {\\n        carrier\\n        price\\n        availableDeliveryWindows {\\n          startDateUtc\\n          endDateUtc\\n          price\\n          listPrice\\n        }\\n        shippingEstimate\\n        localizedEstimates\\n      }\\n    }\\n  }\\n}\\n"}');
+
+/***/ })
+
+};
+;