@shopify/hydrogen 2024.7.3 → 2024.7.5

package/dist/development/index.cjs

@@ -511,7 +511,7 @@ var errorOnce = (string) => {
 };
 
 // src/version.ts
-var LIB_VERSION = "2024.7.3";
+var LIB_VERSION = "2024.7.5";
 
 // src/utils/graphql.ts
 function minifyQuery(string) {
@@ -2968,6 +2968,7 @@ CartForm.ACTIONS = {
   BuyerIdentityUpdate: "BuyerIdentityUpdate",
   Create: "Create",
   DiscountCodesUpdate: "DiscountCodesUpdate",
+  GiftCardCodesUpdate: "GiftCardCodesUpdate",
   LinesAdd: "LinesAdd",
   LinesRemove: "LinesRemove",
   LinesUpdate: "LinesUpdate",
@@ -3007,6 +3008,7 @@ var MINIMAL_CART_FRAGMENT = `#graphql
   fragment CartApiMutation on Cart {
     id
     totalQuantity
+    checkoutUrl
   }
 `;
 
@@ -3358,6 +3360,42 @@ var CART_DISCOUNT_CODE_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT)
   ${USER_ERROR_FRAGMENT}
 `;
 
+// src/cart/queries/cartGiftCardCodeUpdateDefault.ts
+function cartGiftCardCodesUpdateDefault(options) {
+  return async (giftCardCodes, optionalParams) => {
+    const uniqueCodes = giftCardCodes.filter((value, index, array) => {
+      return array.indexOf(value) === index;
+    });
+    const { cartGiftCardCodesUpdate, errors: errors2 } = await options.storefront.mutate(CART_GIFT_CARD_CODE_UPDATE_MUTATION(options.cartFragment), {
+      variables: {
+        cartId: options.getCartId(),
+        giftCardCodes: uniqueCodes,
+        ...optionalParams
+      }
+    });
+    return formatAPIResult(cartGiftCardCodesUpdate, errors2);
+  };
+}
+var CART_GIFT_CARD_CODE_UPDATE_MUTATION = (cartFragment = MINIMAL_CART_FRAGMENT) => `#graphql
+  mutation cartGiftCardCodesUpdate(
+    $cartId: ID!
+    $giftCardCodes: [String!]!
+    $language: LanguageCode
+    $country: CountryCode
+  ) @inContext(country: $country, language: $language) {
+    cartGiftCardCodesUpdate(cartId: $cartId, giftCardCodes: $giftCardCodes) {
+      cart {
+        ...CartApiMutation
+      }
+      userErrors {
+        ...CartApiError
+      }
+    }
+  }
+  ${cartFragment}
+  ${USER_ERROR_FRAGMENT}
+`;
+
 // src/cart/queries/cartBuyerIdentityUpdateDefault.ts
 function cartBuyerIdentityUpdateDefault(options) {
   return async (buyerIdentity, optionalParams) => {
@@ -3646,6 +3684,12 @@ function createCartHandler(options) {
         optionalParams
       ) : await cartCreate({ discountCodes }, optionalParams);
     },
+    updateGiftCardCodes: async (giftCardCodes, optionalParams) => {
+      return cartId || optionalParams?.cartId ? await cartGiftCardCodesUpdateDefault(mutateOptions)(
+        giftCardCodes,
+        optionalParams
+      ) : await cartCreate({ giftCardCodes }, optionalParams);
+    },
     updateBuyerIdentity: async (buyerIdentity, optionalParams) => {
       return cartId || optionalParams?.cartId ? await cartBuyerIdentityUpdateDefault(mutateOptions)(
         buyerIdentity,
@@ -3758,6 +3802,10 @@ function useOptimisticCart(cart) {
   if (isOptimistic) {
     optimisticCart.isOptimistic = isOptimistic;
   }
+  optimisticCart.totalQuantity = cartLines.reduce(
+    (sum, line) => sum + line.quantity,
+    0
+  );
   return optimisticCart;
 }
 function VariantSelector({
@@ -3972,10 +4020,16 @@ function createCSPHeader(nonce, props) {
       );
     }
   }
-  if (combinedDirectives.scriptSrc instanceof Array && !combinedDirectives.scriptSrc.includes(nonceString)) {
-    combinedDirectives.scriptSrc.push(nonceString);
-  } else if (combinedDirectives.defaultSrc instanceof Array && !combinedDirectives.defaultSrc.includes(nonceString)) {
-    combinedDirectives.defaultSrc.push(nonceString);
+  if (combinedDirectives.scriptSrc instanceof Array) {
+    combinedDirectives.scriptSrc = [
+      ...combinedDirectives.scriptSrc.filter((ss) => !ss.startsWith(`'nonce`)),
+      nonceString
+    ];
+  } else if (combinedDirectives.defaultSrc instanceof Array) {
+    combinedDirectives.defaultSrc = [
+      ...combinedDirectives.defaultSrc.filter((ss) => !ss.startsWith(`'nonce`)),
+      nonceString
+    ];
   }
   return cspBuilder__default.default({
     directives: combinedDirectives
@@ -3994,7 +4048,6 @@ function addCspDirective(currentValue, value) {
 var Script = react.forwardRef(
   (props, ref) => {
     const { waitForHydration, src, ...rest } = props;
-    if (!src) throw new Error("Script components require a `src` prop");
     if (waitForHydration) return /* @__PURE__ */ jsxRuntime.jsx(LazyScript, { src, options: rest });
     const nonce = useNonce();
     return /* @__PURE__ */ jsxRuntime.jsx(
@@ -4013,6 +4066,10 @@ function LazyScript({
   src,
   options
 }) {
+  if (!src)
+    throw new Error(
+      "`waitForHydration` with the Script component requires a `src` prop"
+    );
   hydrogenReact.useLoadScript(src, {
     attributes: options
   });
@@ -4131,15 +4188,33 @@ function useCustomerPrivacy(props) {
     onReady,
     ...consentConfig
   } = props;
-  const loadedEvent = react.useRef(false);
-  const scriptStatus = hydrogenReact.useLoadScript(
-    withPrivacyBanner ? CONSENT_API_WITH_BANNER : CONSENT_API,
-    {
-      attributes: {
-        id: "customer-privacy-api"
-      }
+  hydrogenReact.useLoadScript(withPrivacyBanner ? CONSENT_API_WITH_BANNER : CONSENT_API, {
+    attributes: {
+      id: "customer-privacy-api"
     }
-  );
+  });
+  const { observing, setLoaded } = useApisLoaded({
+    withPrivacyBanner,
+    onLoaded: onReady
+  });
+  const config = react.useMemo(() => {
+    const { checkoutDomain, storefrontAccessToken } = consentConfig;
+    if (!checkoutDomain) logMissingConfig("checkoutDomain");
+    if (!storefrontAccessToken) logMissingConfig("storefrontAccessToken");
+    if (storefrontAccessToken.startsWith("shpat_") || storefrontAccessToken.length !== 32) {
+      console.error(
+        `[h2:error:useCustomerPrivacy] It looks like you passed a private access token, make sure to use the public token`
+      );
+    }
+    const config2 = {
+      checkoutRootDomain: checkoutDomain,
+      storefrontAccessToken,
+      storefrontRootDomain: parseStoreDomain(checkoutDomain),
+      country: consentConfig.country,
+      locale: consentConfig.locale
+    };
+    return config2;
+  }, [consentConfig, parseStoreDomain, logMissingConfig]);
   react.useEffect(() => {
     const consentCollectedHandler = (event) => {
       if (onVisitorConsentCollected) {
@@ -4158,54 +4233,166 @@ function useCustomerPrivacy(props) {
     };
   }, [onVisitorConsentCollected]);
   react.useEffect(() => {
-    if (scriptStatus !== "done" || loadedEvent.current) return;
-    loadedEvent.current = true;
-    const { checkoutDomain, storefrontAccessToken } = consentConfig;
-    if (!checkoutDomain) logMissingConfig("checkoutDomain");
-    if (!storefrontAccessToken) logMissingConfig("storefrontAccessToken");
-    if (storefrontAccessToken.startsWith("shpat_") || storefrontAccessToken.length !== 32) {
-      console.error(
-        `[h2:error:useCustomerPrivacy] It looks like you passed a private access token, make sure to use the public token`
-      );
-    }
-    const config = {
-      checkoutRootDomain: checkoutDomain,
-      storefrontAccessToken
+    if (!withPrivacyBanner || observing.current.privacyBanner) return;
+    observing.current.privacyBanner = true;
+    let customPrivacyBanner = void 0;
+    const privacyBannerWatcher = {
+      configurable: true,
+      get() {
+        return customPrivacyBanner;
+      },
+      set(value) {
+        if (typeof value === "object" && value !== null && "showPreferences" in value && "loadBanner" in value) {
+          const privacyBanner = value;
+          privacyBanner.loadBanner(config);
+          customPrivacyBanner = overridePrivacyBannerMethods({
+            privacyBanner,
+            config
+          });
+          setLoaded.privacyBanner();
+        }
+      }
     };
-    if (checkoutDomain) {
-      let storefrontRootDomain = window.document.location.host;
-      const checkoutDomainParts = checkoutDomain.split(".").reverse();
-      const currentDomainParts = storefrontRootDomain.split(".").reverse();
-      const sameDomainParts = [];
-      checkoutDomainParts.forEach((part, index) => {
-        if (part === currentDomainParts[index]) {
-          sameDomainParts.push(part);
+    Object.defineProperty(window, "privacyBanner", privacyBannerWatcher);
+  }, [
+    withPrivacyBanner,
+    config,
+    overridePrivacyBannerMethods,
+    setLoaded.privacyBanner
+  ]);
+  react.useEffect(() => {
+    if (observing.current.customerPrivacy) return;
+    observing.current.customerPrivacy = true;
+    let customCustomerPrivacy = null;
+    let customShopify = void 0;
+    Object.defineProperty(window, "Shopify", {
+      configurable: true,
+      get() {
+        return customShopify;
+      },
+      set(value) {
+        if (typeof value === "object" && value !== null && Object.keys(value).length === 0) {
+          customShopify = value;
+          Object.defineProperty(window.Shopify, "customerPrivacy", {
+            configurable: true,
+            get() {
+              return customCustomerPrivacy;
+            },
+            set(value2) {
+              if (typeof value2 === "object" && value2 !== null && "setTrackingConsent" in value2) {
+                const customerPrivacy = value2;
+                customCustomerPrivacy = {
+                  ...customerPrivacy,
+                  setTrackingConsent: overrideCustomerPrivacySetTrackingConsent(
+                    { customerPrivacy, config }
+                  )
+                };
+                customShopify = {
+                  ...customShopify,
+                  customerPrivacy: customCustomerPrivacy
+                };
+                setLoaded.customerPrivacy();
+              }
+            }
+          });
         }
-      });
-      storefrontRootDomain = sameDomainParts.reverse().join(".");
-      if (storefrontRootDomain) {
-        config.storefrontRootDomain = storefrontRootDomain;
       }
+    });
+  }, [
+    config,
+    overrideCustomerPrivacySetTrackingConsent,
+    setLoaded.customerPrivacy
+  ]);
+  const result = {
+    customerPrivacy: getCustomerPrivacy()
+  };
+  if (withPrivacyBanner) {
+    result.privacyBanner = getPrivacyBanner();
+  }
+  return result;
+}
+function useApisLoaded({
+  withPrivacyBanner,
+  onLoaded
+}) {
+  const observing = react.useRef({ customerPrivacy: false, privacyBanner: false });
+  const [apisLoaded, setApisLoaded] = react.useState(
+    withPrivacyBanner ? [false, false] : [false]
+  );
+  const loaded = apisLoaded.every(Boolean);
+  const setLoaded = {
+    customerPrivacy: () => {
+      if (withPrivacyBanner) {
+        setApisLoaded((prev) => [true, prev[1]]);
+      } else {
+        setApisLoaded(() => [true]);
+      }
+    },
+    privacyBanner: () => {
+      if (!withPrivacyBanner) {
+        return;
+      }
+      setApisLoaded((prev) => [prev[0], true]);
     }
-    if (withPrivacyBanner && window?.privacyBanner) {
-      window.privacyBanner?.loadBanner(config);
+  };
+  react.useEffect(() => {
+    if (loaded && onLoaded) {
+      onLoaded();
     }
-    if (!window.Shopify?.customerPrivacy) return;
-    const originalSetTrackingConsent = window.Shopify.customerPrivacy.setTrackingConsent;
-    function overrideSetTrackingConsent(consent, callback) {
-      originalSetTrackingConsent(
-        {
-          ...consent,
-          headlessStorefront: true,
-          ...config
-        },
-        callback
-      );
+  }, [loaded, onLoaded]);
+  return { observing, setLoaded };
+}
+function parseStoreDomain(checkoutDomain) {
+  if (typeof window === "undefined") return;
+  const host = window.document.location.host;
+  const checkoutDomainParts = checkoutDomain.split(".").reverse();
+  const currentDomainParts = host.split(".").reverse();
+  const sameDomainParts = [];
+  checkoutDomainParts.forEach((part, index) => {
+    if (part === currentDomainParts[index]) {
+      sameDomainParts.push(part);
     }
-    window.Shopify.customerPrivacy.setTrackingConsent = overrideSetTrackingConsent;
-    onReady && onReady();
-  }, [scriptStatus, withPrivacyBanner, consentConfig]);
-  return;
+  });
+  return sameDomainParts.reverse().join(".");
+}
+function overrideCustomerPrivacySetTrackingConsent({
+  customerPrivacy,
+  config
+}) {
+  const original = customerPrivacy.setTrackingConsent;
+  function updatedSetTrackingConsent(consent, callback) {
+    original(
+      {
+        ...consent,
+        headlessStorefront: true,
+        ...config
+      },
+      callback
+    );
+  }
+  return updatedSetTrackingConsent;
+}
+function overridePrivacyBannerMethods({
+  privacyBanner,
+  config
+}) {
+  const originalLoadBanner = privacyBanner.loadBanner;
+  const originalShowPreferences = privacyBanner.showPreferences;
+  function loadBanner(userConfig) {
+    if (typeof userConfig === "object") {
+      originalLoadBanner({ ...config, ...userConfig });
+      return;
+    }
+    originalLoadBanner(config);
+  }
+  function showPreferences(userConfig) {
+    if (typeof userConfig === "object") {
+      originalShowPreferences({ ...config, ...userConfig });
+      return;
+    }
+    originalShowPreferences(config);
+  }
+  return { loadBanner, showPreferences };
 }
 function getCustomerPrivacy() {
   try {
@@ -4214,6 +4401,13 @@ function getCustomerPrivacy() {
     return null;
   }
 }
+function getPrivacyBanner() {
+  try {
+    return window && window?.privacyBanner ? window.privacyBanner : null;
+  } catch (e) {
+    return null;
+  }
+}
 function getCustomerPrivacyRequired() {
   const customerPrivacy = getCustomerPrivacy();
   if (!customerPrivacy) {
@@ -4232,30 +4426,19 @@ function ShopifyAnalytics({
   const [shopifyReady, setShopifyReady] = react.useState(false);
   const [privacyReady, setPrivacyReady] = react.useState(false);
   const init = react.useRef(false);
+  const { checkoutDomain, storefrontAccessToken, language } = consent;
   const { ready: shopifyAnalyticsReady } = register2("Internal_Shopify_Analytics");
-  const { ready: customerPrivacyReady } = register2(
-    "Internal_Shopify_CustomerPrivacy"
-  );
-  const analyticsReady = () => {
-    shopifyReady && privacyReady && onReady();
-  };
-  const setCustomerPrivacyReady = () => {
-    setPrivacyReady(true);
-    customerPrivacyReady();
-    analyticsReady();
-  };
-  const { checkoutDomain, storefrontAccessToken, withPrivacyBanner } = consent;
   useCustomerPrivacy({
+    ...consent,
+    locale: language,
     checkoutDomain: !checkoutDomain ? "mock.shop" : checkoutDomain,
     storefrontAccessToken: !storefrontAccessToken ? "abcdefghijklmnopqrstuvwxyz123456" : storefrontAccessToken,
-    withPrivacyBanner,
-    onVisitorConsentCollected: setCustomerPrivacyReady,
-    onReady: () => {
-      setTimeout(setCustomerPrivacyReady, 3e3);
-    }
+    onVisitorConsentCollected: () => setPrivacyReady(true),
+    onReady: () => setPrivacyReady(true)
   });
   hydrogenReact.useShopifyCookies({
-    hasUserConsent: shopifyReady && privacyReady ? canTrack() : true,
+    hasUserConsent: privacyReady ? canTrack() : true,
+    // must be initialized with true
     domain,
     checkoutDomain
   });
@@ -4267,10 +4450,14 @@ function ShopifyAnalytics({
     subscribe2(AnalyticsEvent.COLLECTION_VIEWED, collectionViewHandler);
     subscribe2(AnalyticsEvent.SEARCH_VIEWED, searchViewHandler);
     subscribe2(AnalyticsEvent.PRODUCT_ADD_TO_CART, productAddedToCartHandler);
-    shopifyAnalyticsReady();
     setShopifyReady(true);
-    analyticsReady();
-  }, [subscribe2, shopifyAnalyticsReady]);
+  }, [subscribe2]);
+  react.useEffect(() => {
+    if (shopifyReady && privacyReady) {
+      shopifyAnalyticsReady();
+      onReady();
+    }
+  }, [shopifyReady, privacyReady, onReady]);
   return null;
 }
 function logMissingConfig2(fieldName) {
@@ -4591,12 +4778,12 @@ function CartAnalytics({
   }, [cart, prevCart, publish2, shop, customData, canTrack]);
   return null;
 }
-var PERF_KIT_UNSTABLE = "https://cdn.shopify.com/shopifycloud/perf-kit/shopify-perf-kit-1bd852a.min.js";
+var PERF_KIT_URL = "https://cdn.shopify.com/shopifycloud/perf-kit/shopify-perf-kit-1.0.0.min.js";
 function PerfKit({ shop }) {
   const loadedEvent = react.useRef(false);
   const { subscribe: subscribe2, register: register2 } = useAnalytics();
   const { ready } = register2("Internal_Shopify_Perf_Kit");
-  const scriptStatus = hydrogenReact.useLoadScript(PERF_KIT_UNSTABLE, {
+  const scriptStatus = hydrogenReact.useLoadScript(PERF_KIT_URL, {
     attributes: {
       id: "perfkit",
       "data-application": "hydrogen",
@@ -4640,7 +4827,9 @@ var defaultAnalyticsContext = {
   subscribe: () => {
   },
   register: () => ({ ready: () => {
-  } })
+  } }),
+  customerPrivacy: null,
+  privacyBanner: null
 };
 var AnalyticsContext = react.createContext(
   defaultAnalyticsContext
@@ -4719,7 +4908,7 @@ function AnalyticsProvider({
 }) {
   const listenerSet = react.useRef(false);
   const { shop } = useShopAnalytics(shopProp);
-  const [consentLoaded, setConsentLoaded] = react.useState(
+  const [analyticsLoaded, setAnalyticsLoaded] = react.useState(
     customCanTrack ? true : false
   );
   const [carts, setCarts] = react.useState({ cart: null, prevCart: null });
@@ -4746,6 +4935,15 @@ function AnalyticsProvider({
         );
         errorOnce(errorMsg);
       }
+      if (!consent?.country) {
+        consent.country = "US";
+      }
+      if (!consent?.language) {
+        consent.language = "EN";
+      }
+      if (consent.withPrivacyBanner === void 0) {
+        consent.withPrivacyBanner = true;
+      }
     }
   }
   const value = react.useMemo(() => {
@@ -4757,13 +4955,13 @@ function AnalyticsProvider({
       },
       shop,
       subscribe,
-      register
+      register,
+      customerPrivacy: getCustomerPrivacy(),
+      privacyBanner: getPrivacyBanner()
     };
   }, [
-    consentLoaded,
-    canTrack(),
+    analyticsLoaded,
     canTrack,
-    JSON.stringify(canTrack),
     carts,
     carts.cart?.updatedAt,
     carts.prevCart,
@@ -4772,7 +4970,9 @@ function AnalyticsProvider({
     customData,
     shop,
     register,
-    JSON.stringify(registers)
+    JSON.stringify(registers),
+    getCustomerPrivacy,
+    getPrivacyBanner
   ]);
   return /* @__PURE__ */ jsxRuntime.jsxs(AnalyticsContext.Provider, { value, children: [
     children,
@@ -4784,7 +4984,7 @@ function AnalyticsProvider({
         consent,
         onReady: () => {
           listenerSet.current = true;
-          setConsentLoaded(true);
+          setAnalyticsLoaded(true);
           setCanTrack(() => shopifyCanTrack);
         },
         domain: cookieDomain
@@ -4953,12 +5153,284 @@ function getStorefrontHeaders(request) {
     purpose: getHeader(request, "purpose")
   };
 }
+
+// src/sitemap/sitemap.ts
+var SITEMAP_INDEX_PREFIX = `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+`;
+var SITEMAP_INDEX_SUFFIX = `
+</sitemapindex>`;
+var SITEMAP_PREFIX = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">`;
+var SITEMAP_SUFFIX = `</urlset>`;
+async function getSitemapIndex(options) {
+  const {
+    storefront,
+    request,
+    types = [
+      "products",
+      "pages",
+      "collections",
+      "metaObjects",
+      "articles",
+      "blogs"
+    ],
+    customChildSitemaps = []
+  } = options;
+  if (!request || !request.url)
+    throw new Error("A request object is required to generate a sitemap index");
+  if (!storefront || !storefront.query)
+    throw new Error(
+      "A storefront client is required to generate a sitemap index"
+    );
+  const data = await storefront.query(SITEMAP_INDEX_QUERY, {
+    storefrontApiVersion: "unstable"
+  });
+  if (!data) {
+    throw new Response("No data found", { status: 404 });
+  }
+  const baseUrl = new URL(request.url).origin;
+  const body = SITEMAP_INDEX_PREFIX + types.map((type) => {
+    if (!data[type]) {
+      throw new Error(
+        `[h2:sitemap:error] No data found for type ${type}. Check types passed to \`getSitemapIndex\``
+      );
+    }
+    return getSiteMapLinks(type, data[type].pagesCount.count, baseUrl);
+  }).join("\n") + customChildSitemaps.map(
+    (url) => "  <sitemap><loc>" + (baseUrl + (url.startsWith("/") ? url : "/" + url)) + "</loc></sitemap>"
+  ).join("\n") + SITEMAP_INDEX_SUFFIX;
+  return new Response(body, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": `max-age=${60 * 60 * 24}`
+    }
+  });
+}
+async function getSitemap(options) {
+  const {
+    storefront,
+    request,
+    params,
+    getLink,
+    locales = [],
+    getChangeFreq,
+    noItemsFallback = "/"
+  } = options;
+  if (!params)
+    throw new Error(
+      "[h2:sitemap:error] Remix params object is required to generate a sitemap"
+    );
+  if (!request || !request.url)
+    throw new Error("A request object is required to generate a sitemap");
+  if (!storefront || !storefront.query)
+    throw new Error("A storefront client is required to generate a index");
+  if (!getLink)
+    throw new Error(
+      "A `getLink` function to generate each resource is required to build a sitemap"
+    );
+  if (!params.type || !params.page)
+    throw new Response("No data found", { status: 404 });
+  const type = params.type;
+  const query = QUERIES[type];
+  if (!query) throw new Response("Not found", { status: 404 });
+  const data = await storefront.query(query, {
+    variables: {
+      page: parseInt(params.page, 10)
+    },
+    storefrontApiVersion: "unstable"
+  });
+  const baseUrl = new URL(request.url).origin;
+  let body = "";
+  if (!data?.sitemap?.resources?.items?.length) {
+    body = SITEMAP_PREFIX + `
+  <url><loc>${baseUrl + noItemsFallback}</loc></url>
+` + SITEMAP_SUFFIX;
+  } else {
+    body = SITEMAP_PREFIX + data.sitemap.resources.items.map((item) => {
+      return renderUrlTag({
+        getChangeFreq,
+        url: getLink({
+          type: item.type ?? type,
+          baseUrl,
+          handle: item.handle
+        }),
+        type,
+        getLink,
+        updatedAt: item.updatedAt,
+        handle: item.handle,
+        metaobjectType: item.type,
+        locales,
+        baseUrl
+      });
+    }).join("\n") + SITEMAP_SUFFIX;
+  }
+  return new Response(body, {
+    headers: {
+      "Content-Type": "application/xml",
+      "Cache-Control": `max-age=${60 * 60 * 24}`
+    }
+  });
+}
+function getSiteMapLinks(resource, count, baseUrl) {
+  let links = ``;
+  for (let i = 1; i <= count; i++) {
+    links += `  <sitemap><loc>${baseUrl}/sitemap/${resource}/${i}.xml</loc></sitemap>
+`;
+  }
+  return links;
+}
+function renderUrlTag({
+  url,
+  updatedAt,
+  locales,
+  type,
+  getLink,
+  baseUrl,
+  handle,
+  getChangeFreq,
+  metaobjectType
+}) {
+  return `<url>
+  <loc>${url}</loc>
+  <lastmod>${updatedAt}</lastmod>
+  <changefreq>${getChangeFreq ? getChangeFreq({ type: metaobjectType ?? type, handle }) : "weekly"}</changefreq>
+${locales.map(
+    (locale) => renderAlternateTag(
+      getLink({ type: metaobjectType ?? type, baseUrl, handle, locale }),
+      locale
+    )
+  ).join("\n")}
+</url>
+  `.trim();
+}
+function renderAlternateTag(url, locale) {
+  return `  <xhtml:link rel="alternate" hreflang="${locale}" href="${url}" />`;
+}
+var PRODUCT_SITEMAP_QUERY = `#graphql
+    query SitemapProducts($page: Int!) {
+      sitemap(type: PRODUCT) {
+        resources(page: $page) {
+          items {
+            handle
+            updatedAt
+          }
+        }
+      }
+    }
+`;
+var COLLECTION_SITEMAP_QUERY = `#graphql
+    query SitemapCollections($page: Int!) {
+      sitemap(type: COLLECTION) {
+        resources(page: $page) {
+          items {
+            handle
+            updatedAt
+          }
+        }
+      }
+    }
+`;
+var ARTICLE_SITEMAP_QUERY = `#graphql
+    query SitemapArticles($page: Int!) {
+      sitemap(type: ARTICLE) {
+        resources(page: $page) {
+          items {
+            handle
+            updatedAt
+          }
+        }
+      }
+    }
+`;
+var PAGE_SITEMAP_QUERY = `#graphql
+    query SitemapPages($page: Int!) {
+      sitemap(type: PAGE) {
+        resources(page: $page) {
+          items {
+            handle
+            updatedAt
+          }
+        }
+      }
+    }
+`;
+var BLOG_SITEMAP_QUERY = `#graphql
+    query SitemapBlogs($page: Int!) {
+      sitemap(type: BLOG) {
+        resources(page: $page) {
+          items {
+            handle
+            updatedAt
+          }
+        }
+      }
+    }
+`;
+var METAOBJECT_SITEMAP_QUERY = `#graphql
+    query SitemapMetaobjects($page: Int!) {
+      sitemap(type: METAOBJECT_PAGE) {
+        resources(page: $page) {
+          items {
+            handle
+            updatedAt
+            ... on SitemapResourceMetaobject {
+              type
+            }
+          }
+        }
+      }
+    }
+`;
+var SITEMAP_INDEX_QUERY = `#graphql
+query SitemapIndex {
+  products: sitemap(type: PRODUCT) {
+    pagesCount {
+      count
+    }
+  }
+  collections: sitemap(type: COLLECTION) {
+    pagesCount {
+      count
+    }
+  }
+  articles: sitemap(type: ARTICLE) {
+    pagesCount {
+      count
+    }
+  }
+  pages: sitemap(type: PAGE) {
+    pagesCount {
+      count
+    }
+  }
+  blogs: sitemap(type: BLOG) {
+    pagesCount {
+      count
+    }
+  }
+  metaObjects: sitemap(type: METAOBJECT_PAGE) {
+    pagesCount {
+      count
+    }
+  }
+}
+`;
+var QUERIES = {
+  products: PRODUCT_SITEMAP_QUERY,
+  articles: ARTICLE_SITEMAP_QUERY,
+  collections: COLLECTION_SITEMAP_QUERY,
+  pages: PAGE_SITEMAP_QUERY,
+  blogs: BLOG_SITEMAP_QUERY,
+  metaObjects: METAOBJECT_SITEMAP_QUERY
+};
 //! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartCreate
 //! @see https://shopify.dev/docs/api/storefront/latest/queries/cart
 //! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartLinesAdd
 //! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartLinesUpdate
 //! @see: https://shopify.dev/docs/api/storefront/latest/mutations/cartLinesRemove
 //! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartDiscountCodesUpdate
+//! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartGiftCardCodesUpdate
 //! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartBuyerIdentityUpdate
 //! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartNoteUpdate
 //! @see https://shopify.dev/docs/api/storefront/latest/mutations/cartSelectedDeliveryOptionsUpdate
@@ -5070,6 +5542,7 @@ exports.cartCreateDefault = cartCreateDefault;
 exports.cartDiscountCodesUpdateDefault = cartDiscountCodesUpdateDefault;
 exports.cartGetDefault = cartGetDefault;
 exports.cartGetIdDefault = cartGetIdDefault;
+exports.cartGiftCardCodesUpdateDefault = cartGiftCardCodesUpdateDefault;
 exports.cartLinesAddDefault = cartLinesAddDefault;
 exports.cartLinesRemoveDefault = cartLinesRemoveDefault;
 exports.cartLinesUpdateDefault = cartLinesUpdateDefault;
@@ -5094,6 +5567,8 @@ exports.getSeoMeta = getSeoMeta;
 exports.getShopAnalytics = getShopAnalytics;
 exports.graphiqlLoader = graphiqlLoader;
 exports.storefrontRedirect = storefrontRedirect;
+exports.unstable__getSitemap = getSitemap;
+exports.unstable__getSitemapIndex = getSitemapIndex;
 exports.useAnalytics = useAnalytics;
 exports.useCustomerPrivacy = useCustomerPrivacy;
 exports.useNonce = useNonce;