@anker-in/shopify-react 0.1.1-beta.0

package/dist/hooks/index.js

@@ -0,0 +1,2890 @@
+'use strict';
+
+var react = require('react');
+var useSWRMutation = require('swr/mutation');
+var shopifySdk = require('@anker-in/shopify-sdk');
+var Cookies5 = require('js-cookie');
+var jsxRuntime = require('react/jsx-runtime');
+var Decimal2 = require('decimal.js');
+var useSWR = require('swr');
+var ahooks = require('ahooks');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var useSWRMutation__default = /*#__PURE__*/_interopDefault(useSWRMutation);
+var Cookies5__default = /*#__PURE__*/_interopDefault(Cookies5);
+var Decimal2__default = /*#__PURE__*/_interopDefault(Decimal2);
+var useSWR__default = /*#__PURE__*/_interopDefault(useSWR);
+
+// src/hooks/cart/use-create-cart.ts
+var ShopifyContext = react.createContext(null);
+function useShopify() {
+  const context = react.useContext(ShopifyContext);
+  if (!context) {
+    throw new Error("useShopify must be used within a ShopifyProvider");
+  }
+  return context;
+}
+
+// src/hooks/cart/types/auto-free-gift.ts
+var RuleType = /* @__PURE__ */ ((RuleType2) => {
+  RuleType2[RuleType2["AUTO_FREE_GIFT"] = 1] = "AUTO_FREE_GIFT";
+  RuleType2[RuleType2["BUNDLE"] = 2] = "BUNDLE";
+  RuleType2[RuleType2["VOLUME_DISCOUNT"] = 3] = "VOLUME_DISCOUNT";
+  RuleType2[RuleType2["ORDER_DISCOUNT"] = 4] = "ORDER_DISCOUNT";
+  RuleType2[RuleType2["PRICE_DISCOUNT"] = 5] = "PRICE_DISCOUNT";
+  return RuleType2;
+})(RuleType || {});
+var BuyRuleType = /* @__PURE__ */ ((BuyRuleType2) => {
+  BuyRuleType2[BuyRuleType2["BUY_GET_GIFT"] = 1] = "BUY_GET_GIFT";
+  BuyRuleType2[BuyRuleType2["SPEND_GET_GIFT"] = 2] = "SPEND_GET_GIFT";
+  return BuyRuleType2;
+})(BuyRuleType || {});
+var SpendMoneyType = /* @__PURE__ */ ((SpendMoneyType2) => {
+  SpendMoneyType2[SpendMoneyType2["ORIGIN_PRICE"] = 1] = "ORIGIN_PRICE";
+  SpendMoneyType2[SpendMoneyType2["DISCOUNT_PRICE"] = 2] = "DISCOUNT_PRICE";
+  return SpendMoneyType2;
+})(SpendMoneyType || {});
+
+// src/hooks/cart/const.ts
+var currencyCodeMapping = {
+  us: "USD",
+  ca: "CAD",
+  gb: "GBP",
+  eu: "EUR",
+  au: "AUD",
+  nz: "NZD",
+  de: "EUR",
+  fr: "EUR",
+  es: "EUR",
+  it: "EUR",
+  nl: "EUR",
+  pl: "EUR",
+  ro: "EUR"
+};
+var defaultSWRMutationConfiguration = {
+  throwOnError: false
+};
+var CUSTOMER_ATTRIBUTE_KEY = "_discounts_function_env";
+var CUSTOMER_SCRIPT_GIFT_KEY = "_giveaway_gradient_gifts";
+var CODE_AMOUNT_KEY = "_sku_code_money";
+var SCRIPT_CODE_AMOUNT_KEY = "_code_money";
+var MAIN_PRODUCT_CODE = ["WS24", "WSTD", "WS7D", "WSCP", "WSPE", "WSPD"];
+
+// src/hooks/cart/utils/index.ts
+var getQuery = () => {
+  const url = typeof window !== "undefined" ? window.location.search : "";
+  const theRequest = {};
+  if (url.indexOf("?") != -1) {
+    const str = url.substr(1), strs = str.split("&");
+    for (let i = 0; i < strs.length; i++) {
+      const parts = strs[i]?.split("=");
+      const key = parts?.[0];
+      const value = parts?.[1];
+      if (key && value) {
+        theRequest[key] = decodeURIComponent(value);
+      }
+    }
+  }
+  return theRequest;
+};
+function atobID(id) {
+  if (id && typeof id === "string" && id.includes("/")) {
+    return id.split("/").pop()?.split("?")?.shift();
+  } else {
+    return id;
+  }
+}
+function btoaID(id, type = "ProductVariant") {
+  return `gid://shopify/${type}/${id}`;
+}
+var getMatchedMainProductSubTotal = (cartData, variant_list, main_product) => {
+  const isAllStoreVariant = main_product?.all_store_variant ?? false;
+  const matchedList = cartData?.lineItems?.filter((line) => {
+    const { is_gift } = getDiscountEnvAttributeValue(line.customAttributes);
+    return isAllStoreVariant ? !is_gift : variant_list?.find((item) => {
+      return !is_gift && atobID(line.variantId) === item;
+    });
+  });
+  return matchedList?.reduce((acc, line) => {
+    return acc + (main_product?.spend_money_type === 1 /* ORIGIN_PRICE */ ? Number(line.subtotalAmount) || 0 : Number(line.totalAmount) || 0);
+  }, 0) || 0;
+};
+var getDiscountEnvAttributeValue = (attributes = []) => {
+  const attr = attributes.find((attr2) => attr2.key === CUSTOMER_ATTRIBUTE_KEY);
+  return safeParseJson(attr?.value ?? "") ?? {};
+};
+var isAttributesEqual = (attrs1 = [], attrs2 = []) => {
+  if (attrs1.length !== attrs2.length) return false;
+  const sorted1 = [...attrs1].sort((a, b) => a.key.localeCompare(b.key));
+  const sorted2 = [...attrs2].sort((a, b) => a.key.localeCompare(b.key));
+  return sorted1.every(
+    (attr, i) => attr.key === sorted2[i]?.key && attr.value === sorted2[i]?.value
+  );
+};
+var safeParseJson = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch (err) {
+    return {};
+  }
+};
+var containsAll = (source, requiredItems = []) => {
+  if (!requiredItems?.length) return true;
+  const sourceSet = new Set(source);
+  return requiredItems.every((item) => sourceSet.has(item));
+};
+var containsNone = (source, forbiddenItems = []) => {
+  if (!forbiddenItems?.length) return true;
+  const sourceSet = new Set(source);
+  return !forbiddenItems.some((item) => sourceSet.has(item));
+};
+function preCheck(rule_conditions, userTags, currentDealsTypes) {
+  if (!Array.isArray(rule_conditions)) return false;
+  if (rule_conditions.length === 0) return true;
+  return rule_conditions.some((rule) => {
+    const tagsAreValid = containsAll(userTags, rule.with_user_tags) && containsNone(userTags, rule.without_user_tags);
+    const paramsAreValid = containsAll(currentDealsTypes, rule.with_special_url_params) && containsNone(currentDealsTypes, rule.without_special_url_params);
+    return tagsAreValid && paramsAreValid;
+  });
+}
+var formatScriptAutoFreeGiftCache = null;
+var formatScriptAutoFreeGift = ({
+  scriptAutoFreeGiftResult,
+  gradient_gifts,
+  locale
+}) => {
+  const cacheKey = JSON.stringify({
+    freeGiftLevel: scriptAutoFreeGiftResult?.freeGiftLevel ? {
+      items: scriptAutoFreeGiftResult.freeGiftLevel.giveawayProducts?.map((item) => ({
+        handle: item.handle,
+        sku: item.sku,
+        quantity: 1
+      })) || []
+    } : null,
+    giftProductsLength: scriptAutoFreeGiftResult?.giftProductsResult?.length || 0,
+    giftProductsIds: scriptAutoFreeGiftResult?.giftProductsResult?.map((p) => p.id).sort() || [],
+    gradientGiftsId: gradient_gifts?.id || gradient_gifts?.name || "",
+    locale
+  });
+  if (formatScriptAutoFreeGiftCache && formatScriptAutoFreeGiftCache.key === cacheKey) {
+    return formatScriptAutoFreeGiftCache.result;
+  }
+  const result = scriptAutoFreeGiftResult?.freeGiftLevel?.giveawayProducts?.filter(
+    (item) => scriptAutoFreeGiftResult?.giftProductsResult?.some(
+      (product) => product.handle === item.handle
+    )
+  ).map((item, index) => {
+    const product = scriptAutoFreeGiftResult?.giftProductsResult?.find(
+      (product2) => product2.handle === item.handle
+    );
+    const variants = product?.variants;
+    const variant = Array.isArray(variants) ? variants.find((v) => v.sku === item.sku) : void 0;
+    const query = getQuery();
+    const utmCampaign = Cookies5__default.default.get("utm_campaign") || query?.utm_campaign;
+    const addUTMFreeItem = gradient_gifts.activityAvailableQuery && utmCampaign?.includes(gradient_gifts.activityAvailableQuery);
+    let points_subscribe = false;
+    if (locale === "au") {
+      const isPointsSubscribe = Cookies5__default.default.get("points_subscribe");
+      points_subscribe = !!isPointsSubscribe;
+    }
+    const customAttributes = [
+      {
+        key: "_giveaway_gradient_gifts",
+        value: "_giveaway_gradient_gifts"
+      },
+      ...points_subscribe ? [
+        { key: "_amount_upgrade_multiple", value: "1.2" },
+        { key: "_amount_upgrade_value", value: "40" }
+      ] : [],
+      ...addUTMFreeItem && gradient_gifts?.activityQroperty ? [
+        {
+          key: gradient_gifts.activityQroperty,
+          value: gradient_gifts.activityQroperty
+        }
+      ] : []
+    ];
+    const line = {
+      id: product?.id + "_" + index,
+      variantId: String(variant?.id),
+      productId: String(product?.id),
+      name: product?.name || product?.title || "",
+      quantity: 1,
+      discounts: [],
+      path: product?.handle || "",
+      variant,
+      totalAmount: 0,
+      subtotalAmount: new Decimal2__default.default(
+        typeof variant?.price === "object" ? variant?.price?.amount || 0 : variant?.price || 0
+      ).toNumber(),
+      options: [],
+      discountAllocations: [],
+      product,
+      customAttributes,
+      freeGiftVariant: void 0,
+      relatedVariant: void 0
+    };
+    return {
+      line,
+      isSoldOut: !variant?.availableForSale
+    };
+  }) || [];
+  formatScriptAutoFreeGiftCache = {
+    key: cacheKey,
+    result
+  };
+  return result;
+};
+var formatFunctionAutoFreeGiftCache = null;
+var formatFunctionAutoFreeGift = ({
+  qualifyingGift,
+  giftProductsResult,
+  locale
+}) => {
+  const cacheKey = JSON.stringify({
+    qualifyingGift: qualifyingGift ? {
+      spend: qualifyingGift.tier?.spend_sum_money,
+      items: qualifyingGift.itemsToAdd?.map((item) => ({
+        variantId: item.variant.id,
+        handle: item.variant.handle,
+        sku: item.variant.sku,
+        quantity: item.quantity ?? 1,
+        attributes: item.attributes
+      })) || []
+    } : null,
+    giftProductsLength: giftProductsResult?.length || 0,
+    giftProductsIds: giftProductsResult?.map((p) => p.id).sort() || [],
+    locale
+  });
+  if (formatFunctionAutoFreeGiftCache && formatFunctionAutoFreeGiftCache.key === cacheKey) {
+    return formatFunctionAutoFreeGiftCache.result;
+  }
+  const result = qualifyingGift?.itemsToAdd?.map((item, index) => {
+    const product = giftProductsResult?.find((product2) => product2.handle === item.variant.handle);
+    const variants = product?.variants;
+    const variant = Array.isArray(variants) ? variants.find((v) => v.sku === item.variant.sku) : void 0;
+    console.log("qualifyingGift variant", product, variant);
+    const line = {
+      id: product?.id + "_" + index,
+      variantId: String(variant?.id),
+      productId: String(product?.id),
+      name: product?.name || product?.title || "",
+      quantity: 1,
+      discounts: [],
+      path: product?.handle || "",
+      variant,
+      totalAmount: 0,
+      subtotalAmount: new Decimal2__default.default(
+        typeof variant?.price === "object" ? variant?.price?.amount || 0 : variant?.price || 0
+      ).toNumber(),
+      options: [],
+      discountAllocations: [],
+      product,
+      customAttributes: item.attributes,
+      freeGiftVariant: void 0,
+      relatedVariant: void 0
+    };
+    return {
+      line,
+      isSoldOut: !variant?.availableForSale
+    };
+  }) || [];
+  formatFunctionAutoFreeGiftCache = {
+    key: cacheKey,
+    result
+  };
+  return result;
+};
+var useCalcAutoFreeGift = (cart, autoFreeGiftConfig, customer) => {
+  const tags = react.useMemo(() => customer?.tags || [], [customer?.tags]);
+  const isCustomerLoading = react.useMemo(() => !customer ? true : false, [customer]);
+  const dealsType = "";
+  const { client, locale } = useShopify();
+  const giftProductsCache = react.useRef(null);
+  const { activeCampaign, subtotal } = react.useMemo(() => {
+    for (const campaign of autoFreeGiftConfig) {
+      const { rule_conditions = [], rule_result } = campaign;
+      const { spend_get_reward } = rule_result || {};
+      const isPreCheckPassed = preCheck(rule_conditions, tags, []);
+      if (isPreCheckPassed && spend_get_reward) {
+        const matchedSubtotal = getMatchedMainProductSubTotal(
+          cart,
+          spend_get_reward.main_product?.variant_list?.map((v) => v.variant_id) || [],
+          {
+            spend_money_type: spend_get_reward.main_product?.spend_money_type || 1,
+            variant_id_list: spend_get_reward.main_product?.variant_list?.map((v) => v.variant_id) || [],
+            all_store_variant: spend_get_reward.main_product?.all_store_variant || false
+          }
+        );
+        if (matchedSubtotal > 0) {
+          return { activeCampaign: campaign, subtotal: matchedSubtotal };
+        }
+      }
+    }
+    return { activeCampaign: null, subtotal: 0 };
+  }, [autoFreeGiftConfig, cart, tags, dealsType]);
+  const { qualifyingGift, nextTierGoal } = react.useMemo(() => {
+    if (!activeCampaign || !activeCampaign.rule_result?.spend_get_reward?.gift_product) {
+      return { qualifyingGift: null, nextTierGoal: null };
+    }
+    const giftTiers = activeCampaign.rule_result.spend_get_reward.gift_product;
+    const qualifyingTier = [...giftTiers].reverse().find((tier) => subtotal >= Number(tier.spend_sum_money));
+    const nextGoal = giftTiers.find((tier) => subtotal < Number(tier.spend_sum_money));
+    if (!qualifyingTier) {
+      return { qualifyingGift: null, nextTierGoal: nextGoal || null };
+    }
+    const formattedGift = {
+      tier: qualifyingTier,
+      itemsToAdd: qualifyingTier.reward_list?.map((reward) => {
+        const giftProduct = reward?.variant_list?.[0];
+        if (!giftProduct) return null;
+        return {
+          variant: {
+            id: btoaID(giftProduct.variant_id),
+            handle: giftProduct.handle,
+            sku: giftProduct.sku
+          },
+          quantity: reward?.get_unit || 1,
+          attributes: [
+            {
+              key: CUSTOMER_ATTRIBUTE_KEY,
+              value: JSON.stringify({
+                is_gift: true,
+                rule_id: activeCampaign.rule_id,
+                spend_sum_money: qualifyingTier.spend_sum_money
+              })
+            }
+          ]
+        };
+      }).filter((item) => item !== null)
+    };
+    return { qualifyingGift: formattedGift, nextTierGoal: nextGoal || null };
+  }, [activeCampaign, subtotal]);
+  const giftHandles = react.useMemo(() => {
+    const giftVariant = autoFreeGiftConfig.map(
+      (item) => item.rule_result?.spend_get_reward?.gift_product?.map(
+        (v) => v.reward_list.map((reward) => reward.variant_list.map((variant) => variant.handle))
+      ).flat()
+    ).flat();
+    return giftVariant.flat(2).filter(Boolean);
+  }, [autoFreeGiftConfig]);
+  const shouldFetch = react.useMemo(() => {
+    if (!giftHandles.length) return false;
+    if (giftProductsCache.current && JSON.stringify(giftProductsCache.current.giftHandles) === JSON.stringify(giftHandles)) {
+      return false;
+    }
+    return true;
+  }, [giftHandles]);
+  const { data: giftProductsResult } = useSWR__default.default(shouldFetch ? giftHandles : null, async () => {
+    const res = await shopifySdk.getProductsByHandles(client, {
+      handles: giftHandles,
+      locale
+    });
+    const result = Array.isArray(res) ? res : [];
+    giftProductsCache.current = {
+      data: result,
+      giftHandles: [...giftHandles]
+    };
+    return result;
+  });
+  const finalGiftProductsResult = react.useMemo(() => {
+    if (giftProductsCache.current && !shouldFetch) {
+      return giftProductsCache.current.data || void 0;
+    }
+    return giftProductsResult;
+  }, [giftProductsResult, shouldFetch]);
+  return {
+    qualifyingGift,
+    nextTierGoal,
+    activeCampaign,
+    isLoading: isCustomerLoading,
+    giftProductsResult: finalGiftProductsResult
+  };
+};
+var useScriptAutoFreeGift = ({
+  campaign,
+  _giveaway,
+  cart,
+  locale: providedLocale
+}) => {
+  const { client, locale: contextLocale } = useShopify();
+  const locale = providedLocale || contextLocale;
+  const [points_subscribe, set_points_subscribe] = react.useState(false);
+  const giftProductsCache = react.useRef(null);
+  react.useEffect(() => {
+    if (locale === "au") {
+      const isPointsSubscribe = Cookies5__default.default.get("points_subscribe");
+      set_points_subscribe(!!isPointsSubscribe);
+    }
+  }, [locale]);
+  const [upgrade_multiple, upgrade_value] = react.useMemo(() => {
+    let upgrade_multiple2 = 1;
+    let upgrade_value2 = 0;
+    if (points_subscribe) {
+      upgrade_multiple2 = 1.2;
+      upgrade_value2 = 40;
+    }
+    cart?.lineItems?.forEach(({ customAttributes }) => {
+      customAttributes?.forEach(({ key, value }) => {
+        if (key === "_amount_upgrade_multiple") upgrade_multiple2 = Number(value) || 1;
+        if (key === "_amount_upgrade_value") upgrade_value2 = Number(value) || 0;
+      });
+    });
+    return [upgrade_multiple2, upgrade_value2];
+  }, [cart?.lineItems, points_subscribe]);
+  const breakpoints = react.useMemo(() => {
+    if (!campaign) return [];
+    return (campaign.breakpoints || []).map((item) => ({
+      breakpoint: new Decimal2__default.default(item.breakpoint).minus(new Decimal2__default.default(upgrade_value)).dividedBy(new Decimal2__default.default(upgrade_multiple)).toFixed(2, Decimal2__default.default.ROUND_DOWN),
+      giveawayProducts: item.giveawayProducts || []
+    }));
+  }, [campaign, upgrade_multiple, upgrade_value]);
+  const giftHandles = react.useMemo(
+    () => (
+      // 使用 Set 去重，然后拼接字符串
+      [
+        ...new Set(
+          breakpoints.flatMap((b) => b.giveawayProducts.map((p) => p.handle)).filter(Boolean)
+        )
+      ]
+    ),
+    [breakpoints]
+  );
+  const shouldFetch = react.useMemo(() => {
+    if (!giftHandles.length) return false;
+    if (giftProductsCache.current && JSON.stringify(giftProductsCache.current.giftHandles) === JSON.stringify(giftHandles)) {
+      return false;
+    }
+    return true;
+  }, [giftHandles]);
+  const involvedLines = react.useMemo(() => {
+    if (!campaign) return [];
+    return (cart?.lineItems || []).filter((line) => {
+      const isNotGift = line?.totalAmount && Number(line.totalAmount) > 0 && line.customAttributes?.every(
+        (item) => item.key !== _giveaway
+      );
+      const hasCampaignTag = line.product?.tags?.some(
+        (tag) => campaign.includeTags?.includes(tag.trim()) && line.variant?.availableForSale
+      );
+      return isNotGift && hasCampaignTag;
+    });
+  }, [cart?.lineItems, campaign, _giveaway]);
+  const involvedSubTotal = react.useMemo(() => {
+    if (!campaign) return new Decimal2__default.default(0);
+    return involvedLines.reduce((prev, item) => {
+      const amount = campaign.useTotalAmount ? item.totalAmount : item.subtotalAmount;
+      return new Decimal2__default.default(prev).plus(new Decimal2__default.default(amount || 0));
+    }, new Decimal2__default.default(0));
+  }, [involvedLines, campaign]);
+  const [freeGiftLevel, nextFreeGiftLevel] = react.useMemo(() => {
+    const sortedLevels = [...breakpoints].sort(
+      (a, b) => Number(b.breakpoint) - Number(a.breakpoint)
+    );
+    const levelIndex = sortedLevels.findIndex(
+      (level) => involvedSubTotal.gte(new Decimal2__default.default(level.breakpoint)) && involvedLines.length > 0
+    );
+    if (levelIndex === -1) {
+      return [
+        null,
+        sortedLevels.length > 0 ? sortedLevels[sortedLevels.length - 1] ?? null : null
+      ];
+    }
+    const currentLevel = sortedLevels[levelIndex] ?? null;
+    const nextLevel = levelIndex > 0 ? sortedLevels[levelIndex - 1] ?? null : null;
+    return [currentLevel, nextLevel];
+  }, [breakpoints, involvedSubTotal, involvedLines.length]);
+  const { data: giftProductsResult } = useSWR__default.default(shouldFetch ? giftHandles : null, async () => {
+    const res = await shopifySdk.getProductsByHandles(client, {
+      handles: giftHandles,
+      locale
+    });
+    const result = Array.isArray(res) ? res : [];
+    giftProductsCache.current = {
+      data: result,
+      giftHandles: [...giftHandles]
+    };
+    return result;
+  });
+  const finalGiftProductsResult = react.useMemo(() => {
+    if (giftProductsCache.current && !shouldFetch) {
+      return giftProductsCache.current.data || void 0;
+    }
+    return giftProductsResult;
+  }, [giftProductsResult, shouldFetch]);
+  const reorder = react.useCallback(
+    (a, b) => {
+      const getPriority = (item) => {
+        if (item.customAttributes?.some(
+          (attribute) => attribute.key === _giveaway
+        ))
+          return 0;
+        if (item.product?.tags?.some((tag) => campaign?.includeTags?.includes(tag)))
+          return 1;
+        return 2;
+      };
+      return getPriority(b) - getPriority(a);
+    },
+    [campaign?.includeTags, _giveaway]
+  );
+  return {
+    involvedLines,
+    reorder,
+    disableCodeRemove: involvedLines.length > 0,
+    nextFreeGiftLevel,
+    freeGiftLevel,
+    involvedSubTotal,
+    giftProductsResult: finalGiftProductsResult
+  };
+};
+var CartContext = react.createContext(null);
+function useCartContext() {
+  const context = react.useContext(CartContext);
+  if (!context) {
+    throw new Error("useCartContext must be used within a CartProvider");
+  }
+  return context;
+}
+
+// src/hooks/cart/use-create-cart.ts
+function useCreateCart(options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const { mutateCart, metafieldIdentifiers } = useCartContext();
+  const createNewCart = react.useCallback(
+    async (_key, { arg }) => {
+      let newCart = await shopifySdk.createCart(client, {
+        ...arg,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      if (newCart) {
+        const unApplicableCodes = newCart.discountCodes.filter((item) => !item.applicable).map((item) => item.code);
+        if (unApplicableCodes.length > 0) {
+          newCart = await shopifySdk.updateCartCodes(client, {
+            cartId: newCart.id,
+            discountCodes: newCart.discountCodes.filter((item) => item.applicable).map((item) => item.code),
+            metafieldIdentifiers,
+            cookieAdapter: cartCookieAdapter
+          });
+        }
+      }
+      if (newCart) {
+        mutateCart(newCart);
+      }
+      return newCart;
+    },
+    [client, locale, cartCookieAdapter, mutateCart, metafieldIdentifiers]
+  );
+  return useSWRMutation__default.default("create-cart", createNewCart, options);
+}
+function useAddCartLines(options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const { mutateCart, metafieldIdentifiers } = useCartContext();
+  const addLines = react.useCallback(
+    async (_key, { arg }) => {
+      let updatedCart = await shopifySdk.addCartLines(client, {
+        ...arg,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      if (updatedCart) {
+        const unApplicableCodes = updatedCart.discountCodes.filter((item) => !item.applicable).map((item) => item.code);
+        if (unApplicableCodes.length > 0) {
+          updatedCart = await shopifySdk.updateCartCodes(client, {
+            cartId: updatedCart.id,
+            discountCodes: updatedCart.discountCodes.filter((item) => item.applicable).map((item) => item.code),
+            metafieldIdentifiers,
+            cookieAdapter: cartCookieAdapter
+          });
+        }
+      }
+      if (updatedCart) {
+        mutateCart(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutateCart, metafieldIdentifiers]
+  );
+  return useSWRMutation__default.default("add-cart-lines", addLines, options);
+}
+
+// src/tracking/ga.ts
+var gaTrack = (data) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  window.dataLayer = window?.dataLayer || [];
+  if (!Array.isArray(window.dataLayer)) {
+    return;
+  }
+  try {
+    window?.dataLayer?.push({ event_parameters: null });
+    window?.dataLayer?.push(data || {});
+  } catch (error) {
+    console.error("GA tracking error:", error);
+  }
+};
+var trackAddToCartGA = ({
+  lineItems = [],
+  gtmParams = {},
+  brand
+}) => {
+  if (!lineItems.length || !lineItems[0]?.variant) {
+    return;
+  }
+  const { variant } = lineItems[0];
+  const currencyCode = variant?.price?.currencyCode;
+  const totalPrice = lineItems.reduce((sum, item) => {
+    const price = parseFloat(item.variant?.price?.amount || "0");
+    return sum + price;
+  }, 0);
+  gaTrack({
+    event: "ga4Event",
+    event_name: "add_to_cart",
+    event_parameters: {
+      page_group: gtmParams?.pageGroup,
+      currency: currencyCode,
+      value: totalPrice,
+      position: gtmParams?.position || "",
+      items: lineItems.map(({ variant: variant2, quantity }) => ({
+        item_id: variant2?.sku,
+        item_name: variant2?.product?.title || variant2?.product?.name,
+        item_brand: brand || gtmParams?.brand || "",
+        item_category: variant2?.product?.productType || "",
+        item_variant: variant2?.title || variant2?.name,
+        price: variant2?.finalPrice?.amount ?? variant2?.price?.amount,
+        quantity: quantity || 1
+      })),
+      ...gtmParams?.ga4Params
+    }
+  });
+};
+var trackBuyNowGA = ({
+  lineItems = [],
+  gtmParams = {},
+  brand
+}) => {
+  if (!lineItems.length || !lineItems[0]?.variant) {
+    return;
+  }
+  const { variant } = lineItems[0];
+  const currencyCode = variant.price?.currencyCode;
+  const totalPrice = lineItems.reduce((sum, item) => {
+    const price = parseFloat(item.finalPrice?.amount || item.variant?.price?.amount || "0");
+    const quantity = item.quantity || 1;
+    return sum + price * quantity;
+  }, 0);
+  gaTrack({
+    event: "ga4Event",
+    event_name: "begin_checkout",
+    event_parameters: {
+      page_group: gtmParams?.pageGroup,
+      position: gtmParams?.position,
+      currency: currencyCode,
+      value: totalPrice,
+      items: lineItems.map((item) => ({
+        item_id: item.variant?.sku,
+        item_name: item.variant?.product?.title || item.variant?.title,
+        item_brand: item.variant?.product?.vendor || brand || gtmParams?.brand || "",
+        item_category: item.variant?.product?.productType || "",
+        item_variant: item.variant?.title,
+        price: item.finalPrice?.amount || item.variant?.price?.amount,
+        quantity: item.quantity || 1
+      })),
+      ...gtmParams?.ga4Params
+    }
+  });
+};
+
+// src/tracking/fbq.ts
+var trackAddToCartFBQ = ({ lineItems = [] }) => {
+  if (typeof window === "undefined" || !window.fbq) {
+    return;
+  }
+  if (lineItems.length && lineItems[0]?.variant) {
+    const { variant, quantity, finalPrice } = lineItems[0];
+    try {
+      window.fbq("track", "AddToCart", {
+        value: finalPrice?.amount || variant?.price?.amount,
+        num_items: quantity,
+        currency: variant?.price?.currencyCode,
+        content_name: variant?.product?.title,
+        content_type: "product_group",
+        content_ids: String(variant?.id),
+        content_category: variant?.product?.metafields?.global?.trafficType || "public"
+      });
+    } catch (error) {
+      console.error("FBQ tracking error:", error);
+    }
+  }
+};
+var trackBuyNowFBQ = ({ trackConfig }) => {
+  if (typeof window === "undefined") {
+    return;
+  }
+  try {
+    if (trackConfig?.fbqBuyNowEvent && window.fbq) {
+      window.fbq("trackCustom", trackConfig.fbqBuyNowEvent);
+    }
+    if (trackConfig?.gtagBuyNowLabel && trackConfig?.gtagId && window.gtag) {
+      window.gtag("event", trackConfig.gtagBuyNowConversion || "conversion", {
+        send_to: `${trackConfig.gtagId}/${trackConfig.gtagBuyNowLabel}`
+      });
+    }
+  } catch (error) {
+    console.error("Buy Now tracking error:", error);
+  }
+};
+function useApplyCartCodes(options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const { mutateCart, cart, metafieldIdentifiers } = useCartContext();
+  const applyCodes = react.useCallback(
+    async (_key, { arg }) => {
+      const { cartId: providedCartId, discountCodes, replaceExistingCodes } = arg;
+      if (!discountCodes?.length) {
+        throw new Error("Invalid input used for this operation: Miss discountCode");
+      }
+      const cartId = providedCartId ? void 0 : providedCartId || cart?.id;
+      if (!cartId) {
+        return void 0;
+      }
+      const updatedCart = await shopifySdk.updateCartCodes(client, {
+        cartId,
+        discountCodes: replaceExistingCodes ? discountCodes : [
+          ...discountCodes,
+          ...cart?.discountCodes?.filter((item) => item.applicable).map((item) => item.code) || []
+        ],
+        cookieAdapter: cartCookieAdapter,
+        metafieldIdentifiers
+      });
+      if (updatedCart) {
+        mutateCart(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutateCart, cart]
+  );
+  return useSWRMutation__default.default("apply-codes", applyCodes, options);
+}
+function useRemoveCartCodes(options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const { mutateCart, cart, metafieldIdentifiers } = useCartContext();
+  const removeCodes = react.useCallback(
+    async (_key, { arg }) => {
+      const { cartId: providedCartId, discountCodes } = arg;
+      const cartId = providedCartId ? void 0 : providedCartId || cart?.id;
+      const codes = cart?.discountCodes?.filter((code) => !!code.applicable) || [];
+      const leftCodes = codes.filter((code) => discountCodes?.length ? !discountCodes.includes(code.code) : code.code).map((code) => code.code);
+      const updatedCart = await shopifySdk.updateCartCodes(client, {
+        cartId,
+        discountCodes: leftCodes,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      if (updatedCart) {
+        mutateCart(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutateCart, cart]
+  );
+  return useSWRMutation__default.default("remove-codes", removeCodes, options);
+}
+
+// src/hooks/cart/use-add-to-cart.ts
+function useAddToCart({ withTrack = true, brand } = {}, swrOptions) {
+  const { client, locale, cartCookieAdapter, userAdapter } = useShopify();
+  const { mutateCart, cart, metafieldIdentifiers } = useCartContext();
+  const { trigger: applyCartCodes } = useApplyCartCodes();
+  const { trigger: removeInvalidCodes } = useRemoveCartCodes();
+  const { trigger: addCartLines2 } = useAddCartLines();
+  const addToCart = react.useCallback(
+    async (_key, { arg }) => {
+      const {
+        lineItems,
+        cartId: providedCartId,
+        discountCodes,
+        gtmParams = {},
+        buyerIdentity,
+        needCreateCart = false,
+        onCodesInvalid,
+        replaceExistingCodes
+      } = arg;
+      if (!lineItems || lineItems.length === 0) {
+        return;
+      }
+      const lines = lineItems.map((item) => ({
+        merchandiseId: item.variant?.id || "",
+        quantity: item.quantity || 1,
+        attributes: item.attributes
+      })).filter((item) => item.merchandiseId && item.quantity);
+      if (lines.length === 0) {
+        return;
+      }
+      const cartId = needCreateCart ? void 0 : providedCartId || cart?.id;
+      let resultCart = await addCartLines2({
+        cartId,
+        lines,
+        buyerIdentity
+      });
+      if (!resultCart) {
+        return void 0;
+      }
+      if (resultCart.discountCodes && resultCart.discountCodes.length > 0) {
+        const unapplicableCodes = resultCart.discountCodes.filter((item) => !item.applicable).map((item) => item.code);
+        if (unapplicableCodes.length > 0) {
+          if (onCodesInvalid) {
+            const handledCart = await onCodesInvalid(resultCart, unapplicableCodes);
+            if (handledCart) {
+              resultCart = handledCart;
+            }
+          } else {
+            await removeInvalidCodes({
+              discountCodes: unapplicableCodes
+            });
+          }
+        }
+      }
+      if (discountCodes && discountCodes.length > 0) {
+        applyCartCodes({
+          replaceExistingCodes,
+          discountCodes
+        });
+      }
+      if (withTrack && resultCart.lineItems) {
+        const trackingLineItems = resultCart.lineItems.map((line) => ({
+          variant: {
+            id: line.variant.id,
+            sku: line.variant.sku || "",
+            title: line.variant.name,
+            price: {
+              amount: String(line.variant.price),
+              currencyCode: resultCart.currency.code
+            },
+            product: line.product ? {
+              title: line.product.title || line.name,
+              productType: line.product.productType,
+              vendor: line.product.vendor
+            } : void 0
+          },
+          quantity: line.quantity
+        }));
+        trackAddToCartGA({
+          lineItems: trackingLineItems,
+          gtmParams: { ...gtmParams, brand },
+          brand
+        });
+        trackAddToCartFBQ({ lineItems: trackingLineItems });
+      }
+      return resultCart;
+    },
+    [client, locale, cartCookieAdapter, userAdapter, cart, withTrack, brand]
+  );
+  return useSWRMutation__default.default("add-to-cart", addToCart, swrOptions);
+}
+function useUpdateCartLines(options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const { mutateCart, metafieldIdentifiers } = useCartContext();
+  const updateLines = react.useCallback(
+    async (_key, { arg }) => {
+      const updatedCart = await shopifySdk.updateCartLines(client, {
+        ...arg,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      if (updatedCart) {
+        mutateCart(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutateCart]
+  );
+  return useSWRMutation__default.default("update-cart-lines", updateLines, options);
+}
+function useRemoveCartLines(options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const { mutateCart, metafieldIdentifiers } = useCartContext();
+  const removeLines = react.useCallback(
+    async (_key, { arg }) => {
+      const { autoRemoveInvalidCodes = true, onCodesRemoved, cartId, lineIds } = arg;
+      let updatedCart = await shopifySdk.removeCartLines(client, {
+        cartId,
+        lineIds,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      if (updatedCart && autoRemoveInvalidCodes) {
+        const unApplicableCodes = updatedCart.discountCodes.filter((item) => !item.applicable).map((item) => item.code);
+        if (unApplicableCodes.length > 0) {
+          if (onCodesRemoved) {
+            const handledCart = await onCodesRemoved(updatedCart, unApplicableCodes);
+            if (handledCart) {
+              updatedCart = handledCart;
+            }
+          } else {
+            updatedCart = await shopifySdk.updateCartCodes(client, {
+              cartId: updatedCart.id,
+              discountCodes: updatedCart.discountCodes.filter((item) => item.applicable).map((item) => item.code),
+              metafieldIdentifiers,
+              cookieAdapter: cartCookieAdapter
+            }) || updatedCart;
+          }
+        }
+      }
+      if (updatedCart) {
+        mutateCart(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutateCart]
+  );
+  return useSWRMutation__default.default("remove-cart-lines", removeLines, options);
+}
+function useUpdateCartAttributes(mutate, metafieldIdentifiers, options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const updateAttributes = react.useCallback(
+    async (_key, { arg }) => {
+      const updatedCart = await shopifySdk.updateCartAttributes(client, {
+        ...arg,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      console.log("useUpdateCartAttributes updatedCart", updatedCart);
+      if (updatedCart) {
+        mutate(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutate]
+  );
+  return useSWRMutation__default.default("update-cart-attributes", updateAttributes, options);
+}
+function useBuyNow({ withTrack = true, brand } = {}, swrOptions) {
+  const { client, locale, cartCookieAdapter, userAdapter } = useShopify();
+  const isLoggedIn = userAdapter?.isLoggedIn || false;
+  const buyNow = react.useCallback(
+    async (_key, { arg }) => {
+      const {
+        lineItems,
+        discountCodes,
+        gtmParams = {},
+        buyerIdentity,
+        fbqTrackConfig,
+        customAttributes,
+        metafieldIdentifiers,
+        redirectToCheckout
+      } = arg;
+      if (!lineItems || lineItems.length === 0) {
+        return;
+      }
+      const lines = lineItems.map((item) => ({
+        merchandiseId: item.variant?.id || item.variantId || "",
+        quantity: item.quantity || 1,
+        attributes: item.attributes
+      })).filter((item) => item.merchandiseId && item.quantity);
+      if (lines.length === 0) {
+        return;
+      }
+      const resultCart = await shopifySdk.createCart(client, {
+        lines,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter,
+        buyerIdentity,
+        discountCodes,
+        customAttributes
+      });
+      if (!resultCart) {
+        throw new Error("Failed to create cart for buy now");
+      }
+      if (withTrack && resultCart.lineItems) {
+        const trackingLineItems = resultCart.lineItems.map((line) => ({
+          variant: {
+            id: line.variantId,
+            sku: line.variant.sku || "",
+            title: line.variant.name,
+            price: {
+              amount: String(line.variant.price),
+              currencyCode: resultCart.currency.code
+            },
+            product: line.product ? {
+              title: line.product.title || line.name,
+              productType: line.product.productType,
+              vendor: line.product.vendor
+            } : void 0
+          },
+          quantity: line.quantity
+        }));
+        trackBuyNowGA({
+          lineItems: trackingLineItems,
+          gtmParams: { ...gtmParams, brand },
+          brand
+        });
+        if (fbqTrackConfig) {
+          trackBuyNowFBQ({ trackConfig: fbqTrackConfig });
+        }
+      }
+      if (redirectToCheckout) {
+        if (resultCart.url) {
+          if (typeof window !== "undefined") {
+            window.location.href = resultCart.url;
+          }
+        } else {
+          throw new Error("Failed to get checkout URL");
+        }
+      }
+      return resultCart;
+    },
+    [client, locale, isLoggedIn, cartCookieAdapter, withTrack, brand]
+  );
+  return useSWRMutation__default.default("buy-now", buyNow, swrOptions);
+}
+
+// src/hooks/cart/types/order-discount.ts
+var OrderDiscountType = /* @__PURE__ */ ((OrderDiscountType2) => {
+  OrderDiscountType2[OrderDiscountType2["PERCENTAGE"] = 1] = "PERCENTAGE";
+  OrderDiscountType2[OrderDiscountType2["FIXED_AMOUNT"] = 2] = "FIXED_AMOUNT";
+  OrderDiscountType2[OrderDiscountType2["REDUCE_PRICE"] = 3] = "REDUCE_PRICE";
+  return OrderDiscountType2;
+})(OrderDiscountType || {});
+var OrderBasePriceType = /* @__PURE__ */ ((OrderBasePriceType2) => {
+  OrderBasePriceType2[OrderBasePriceType2["ORIGIN_PRICE"] = 1] = "ORIGIN_PRICE";
+  OrderBasePriceType2[OrderBasePriceType2["MIN_DISCOUNTED_PRICE"] = 2] = "MIN_DISCOUNTED_PRICE";
+  return OrderBasePriceType2;
+})(OrderBasePriceType || {});
+
+// src/hooks/cart/feature/use-calc-order-discount.ts
+var useCalcOrderDiscount = (cart, orderDiscountConfig, customer) => {
+  const tags = react.useMemo(() => customer?.tags || [], [customer?.tags]);
+  const isCustomerLoading = react.useMemo(() => !customer ? true : false, [customer]);
+  const dealsType = "";
+  const { activeCampaign, subtotal } = react.useMemo(() => {
+    for (const campaign of orderDiscountConfig) {
+      const { rule_conditions = [], result_detail } = campaign;
+      const { main_product, order_discount_conf } = result_detail || {};
+      const isPreCheckPassed = preCheck(rule_conditions, tags, []);
+      if (isPreCheckPassed && main_product && order_discount_conf) {
+        const matchedSubtotal = getMatchedMainProductSubTotal(
+          cart,
+          main_product?.variant_list?.map((v) => v.variant_id) || [],
+          {
+            spend_money_type: order_discount_conf.base_price === 2 /* MIN_DISCOUNTED_PRICE */ ? 2 : 1,
+            // 根据基础价格类型设置
+            variant_id_list: main_product?.variant_list?.map((v) => v.variant_id) || [],
+            all_store_variant: main_product?.all_store_variant || false
+          }
+        );
+        if (matchedSubtotal > 0) {
+          return { activeCampaign: campaign, subtotal: matchedSubtotal };
+        }
+      }
+    }
+    return { activeCampaign: null, subtotal: 0 };
+  }, [orderDiscountConfig, cart, tags, dealsType]);
+  const { qualifyingDiscount, nextTierGoal, discountAmount } = react.useMemo(() => {
+    if (!activeCampaign || !activeCampaign.result_detail?.order_discount_conf?.tiered_discounts) {
+      return {
+        qualifyingDiscount: null,
+        nextTierGoal: null,
+        discountAmount: 0
+      };
+    }
+    const tieredDiscounts = activeCampaign.result_detail.order_discount_conf.tiered_discounts;
+    const qualifyingTier = [...tieredDiscounts].reverse().find((tier) => subtotal >= Number(tier.amount));
+    const nextGoal = tieredDiscounts.find((tier) => subtotal < Number(tier.amount));
+    if (!qualifyingTier) {
+      return {
+        qualifyingDiscount: null,
+        nextTierGoal: nextGoal || null,
+        discountAmount: 0
+      };
+    }
+    let calculatedDiscount = 0;
+    switch (qualifyingTier.discount_type) {
+      case 1 /* PERCENTAGE */:
+        calculatedDiscount = subtotal * qualifyingTier.discount / 100;
+        break;
+      case 2 /* FIXED_AMOUNT */:
+        calculatedDiscount = qualifyingTier.discount;
+        break;
+      case 3 /* REDUCE_PRICE */:
+        calculatedDiscount = Math.min(subtotal, qualifyingTier.discount);
+        break;
+      default:
+        calculatedDiscount = 0;
+    }
+    return {
+      qualifyingDiscount: qualifyingTier,
+      nextTierGoal: nextGoal || null,
+      discountAmount: calculatedDiscount
+    };
+  }, [activeCampaign, subtotal]);
+  return {
+    qualifyingDiscount,
+    nextTierGoal,
+    activeCampaign,
+    discountAmount,
+    cartTotalForDiscount: subtotal,
+    isLoading: isCustomerLoading
+  };
+};
+function useHasPlusMemberInCart({
+  memberSetting,
+  cart
+}) {
+  const { plus_monthly_product, plus_annual_product } = memberSetting || {};
+  return react.useMemo(() => {
+    if (!cart?.lineItems) {
+      return {
+        hasPlusMember: false,
+        hasMonthlyPlus: false,
+        hasAnnualPlus: false
+      };
+    }
+    const monthlyPlusItem = cart.lineItems.find(
+      (item) => item.product?.handle === plus_monthly_product?.handle && item.variant?.sku === plus_monthly_product?.sku
+    );
+    const annualPlusItem = cart.lineItems.find(
+      (item) => item.product?.handle === plus_annual_product?.handle && item.variant?.sku === plus_annual_product?.sku
+    );
+    const hasMonthlyPlus = !!monthlyPlusItem;
+    const hasAnnualPlus = !!annualPlusItem;
+    const hasPlusMember = hasMonthlyPlus || hasAnnualPlus;
+    return {
+      hasPlusMember,
+      hasMonthlyPlus,
+      hasAnnualPlus,
+      monthlyPlusItem,
+      annualPlusItem
+    };
+  }, [cart?.lineItems, plus_monthly_product, plus_annual_product]);
+}
+
+// src/hooks/cart/feature/use-cart-attributes.ts
+var getReferralAttributes = () => {
+  const inviteCode = Cookies5__default.default.get("invite_code");
+  const playModeId = Cookies5__default.default.get("playModeId");
+  const popup = Cookies5__default.default.get("_popup");
+  if (inviteCode && playModeId) {
+    return popup ? [
+      { key: "_invite_code", value: inviteCode ? inviteCode : "" },
+      { key: "_play_mode_id", value: playModeId ? playModeId : "" },
+      { key: "_popup", value: popup }
+    ] : [
+      { key: "_invite_code", value: inviteCode ? inviteCode : "" },
+      { key: "_play_mode_id", value: playModeId ? playModeId : "" }
+    ];
+  }
+  return [];
+};
+var useCartAttributes = ({
+  profile,
+  customer,
+  cart,
+  memberSetting
+}) => {
+  const [currentUrl, setCurrentUrl] = react.useState("");
+  const { hasPlusMember } = useHasPlusMemberInCart({
+    memberSetting,
+    cart
+  });
+  console.log("memberSetting", memberSetting);
+  console.log("hasPlusMember", hasPlusMember);
+  react.useEffect(() => {
+    setCurrentUrl(window.location.href);
+  }, []);
+  const userType = react.useMemo(() => {
+    let userInfo = Cookies5__default.default.get("userInfo");
+    if (userInfo) {
+      userInfo = JSON.parse(userInfo);
+      let arr = typeof userInfo?.id == "string" && userInfo?.id.split("/");
+      userInfo.setId = arr[arr.length - 1];
+    }
+    const customerInfo = userInfo || customer;
+    if (!customerInfo) {
+      return "new_user_unlogin";
+    }
+    if (customer) {
+      const { orders = {} } = customer;
+      if (orders?.edges?.length === 1) {
+        return "old_user_orders_once";
+      } else if (orders?.edges?.length > 1) {
+        return "old_user_orders_twice";
+      }
+    }
+    return "new_user_login";
+  }, [customer]);
+  const memberAttributes = react.useMemo(() => {
+    return [
+      {
+        key: "_token",
+        value: profile?.token
+        //是否登录
+      },
+      {
+        key: "_member_type",
+        value: hasPlusMember ? "2" : profile?.memberType
+        //：0(游客)，1(普通会员)，2(付费会员)
+      },
+      {
+        key: "_user_type",
+        value: userType
+        // n
+      },
+      {
+        key: "_is_login",
+        value: profile?.token ? "true" : "false"
+      }
+    ];
+  }, [profile?.memberType, profile?.token, userType, hasPlusMember]);
+  const functionAttributes = react.useMemo(() => {
+    return [
+      cart?.discountCodes && {
+        key: "_discounts_function_env",
+        value: JSON.stringify({
+          discount_code: cart?.discountCodes.map((item) => item.code),
+          user_tags: customer?.tags || []
+        })
+      }
+    ];
+  }, [cart]);
+  const presellAttributes = react.useMemo(() => {
+    return [
+      {
+        key: "_presale",
+        value: cart?.lineItems.some((item) => item?.variant?.metafields?.presell === "presell")
+      }
+    ];
+  }, [cart]);
+  const weightAttributes = react.useMemo(() => {
+    return [
+      {
+        key: "_weight",
+        value: cart?.lineItems.reduce((acc, item) => {
+          return new Decimal2__default.default(acc).plus(item.variant.weight ?? 0).toNumber();
+        }, 0).toString()
+      },
+      {
+        key: "_app_source_name",
+        value: "dtc"
+      }
+    ];
+  }, [cart]);
+  const trackingAttributes = react.useMemo(() => {
+    return [
+      {
+        key: "utm_params",
+        value: currentUrl
+      }
+    ];
+  }, [currentUrl]);
+  return react.useMemo(
+    () => ({
+      attributes: [
+        ...memberAttributes,
+        ...functionAttributes,
+        ...presellAttributes,
+        ...weightAttributes,
+        ...trackingAttributes,
+        ...getReferralAttributes()
+      ].filter((item) => item?.value)
+    }),
+    [memberAttributes, functionAttributes, presellAttributes, weightAttributes, trackingAttributes]
+  );
+};
+var DEFAULT_MIN = 1;
+var DEFAULT_MAX = 999;
+var useCartItemQuantityLimit = ({
+  cart,
+  cartItem,
+  config
+}) => {
+  const quantityLimit = react.useMemo(() => {
+    if (config?.handle) {
+      const cartItemQuantityLimit = config?.handle?.[cartItem?.product?.handle || ""];
+      const sameHandleTotalQuantity = cart?.lineItems.reduce((acc, item) => {
+        if (item.product?.handle === cartItem?.product?.handle && item.variant.sku !== cartItem.variant.sku) {
+          acc += item.quantity;
+        }
+        return acc;
+      }, 0) || 0;
+      return {
+        min: cartItemQuantityLimit?.min || DEFAULT_MIN,
+        max: cartItemQuantityLimit?.max ? cartItemQuantityLimit?.max - sameHandleTotalQuantity : DEFAULT_MAX
+      };
+    } else if (config?.sku) {
+      const cartItemQuantityLimit = config?.sku?.[cartItem?.variant?.sku];
+      return {
+        min: cartItemQuantityLimit?.min || DEFAULT_MIN,
+        max: cartItemQuantityLimit?.max || DEFAULT_MAX
+      };
+    }
+    return {
+      min: DEFAULT_MIN,
+      max: DEFAULT_MAX
+    };
+  }, [cartItem, cart]);
+  return quantityLimit;
+};
+var useUpdateLineCodeAmountAttributes = ({
+  cart,
+  mutateCart,
+  isCartLoading,
+  setLoadingState,
+  metafieldIdentifiers
+}) => {
+  const { client, cartCookieAdapter } = useShopify();
+  const mainProductDiscountCodes = react.useMemo(
+    () => cart?.discountCodes.filter(
+      ({ code, applicable }) => applicable && MAIN_PRODUCT_CODE.some((codePrefix) => code.startsWith(codePrefix))
+    ).map(({ code }) => code),
+    [cart]
+  );
+  const linesNeedUpdate = react.useMemo(
+    () => cart?.lineItems.map((line) => {
+      const attrNeedUpdate = [];
+      const attrNeedDelete = [];
+      const codeDiscount = line.discountAllocations?.find(
+        (allocation) => mainProductDiscountCodes?.includes(allocation.code)
+      );
+      const hasFunctionEnvAttribute = line.customAttributes?.find(
+        (attr) => attr.key === CUSTOMER_ATTRIBUTE_KEY
+      );
+      const functionEnvValue = getDiscountEnvAttributeValue(line.customAttributes);
+      const hasSameFunctionEnvAttribute = Number(functionEnvValue.discounted_amount) === Number(line.totalAmount);
+      if (!hasSameFunctionEnvAttribute && hasFunctionEnvAttribute) {
+        attrNeedUpdate.push({
+          key: CUSTOMER_ATTRIBUTE_KEY,
+          value: JSON.stringify({
+            ...functionEnvValue,
+            discounted_amount: Number(line.totalAmount)
+          })
+        });
+      }
+      const codeDiscountAmount = codeDiscount?.amount || 0;
+      const hasCodeAmountAttribute = line.customAttributes?.find(
+        (attr) => attr.key === CODE_AMOUNT_KEY || attr.key === SCRIPT_CODE_AMOUNT_KEY
+      );
+      const hasSameCodeAmountAttribute = line.customAttributes?.find(
+        (attr) => attr.key === CODE_AMOUNT_KEY && attr.value === String(codeDiscountAmount)
+      ) && line.customAttributes?.find(
+        (attr) => attr.key === SCRIPT_CODE_AMOUNT_KEY && attr.value === String(codeDiscountAmount)
+      );
+      if (codeDiscount && !hasSameCodeAmountAttribute) {
+        attrNeedUpdate.push({
+          key: CODE_AMOUNT_KEY,
+          value: String(codeDiscountAmount)
+        });
+        attrNeedUpdate.push({
+          key: SCRIPT_CODE_AMOUNT_KEY,
+          value: String(codeDiscountAmount)
+        });
+      } else if (!codeDiscount && hasCodeAmountAttribute) {
+        attrNeedDelete.push(CODE_AMOUNT_KEY);
+        attrNeedDelete.push(SCRIPT_CODE_AMOUNT_KEY);
+      }
+      return {
+        line,
+        attrNeedUpdate,
+        attrNeedDelete
+      };
+    }).filter(
+      ({ attrNeedUpdate, attrNeedDelete }) => attrNeedUpdate.length || attrNeedDelete.length
+    ).map(({ line, attrNeedUpdate, attrNeedDelete }) => {
+      if (attrNeedUpdate.length) {
+        return {
+          id: line.id,
+          attributes: [
+            ...line.customAttributes?.filter(
+              (attr) => !attrNeedUpdate.some((updateAttr) => updateAttr.key === attr.key)
+            ) || [],
+            ...attrNeedUpdate
+          ]
+        };
+      } else if (attrNeedDelete.length) {
+        return {
+          id: line.id,
+          attributes: line.customAttributes?.filter(
+            (attr) => !attrNeedDelete.includes(attr.key)
+          ) || []
+        };
+      } else {
+        return {
+          id: line.id,
+          attributes: line.customAttributes || []
+        };
+      }
+    }),
+    [cart?.lineItems, mainProductDiscountCodes]
+  );
+  const { loading } = ahooks.useRequest(
+    async () => {
+      if (linesNeedUpdate?.length && !isCartLoading) {
+        const result = await shopifySdk.updateCartLines(client, {
+          cartId: cart?.id || "",
+          lines: linesNeedUpdate,
+          metafieldIdentifiers,
+          cookieAdapter: cartCookieAdapter
+        });
+        if (result) {
+          mutateCart(result);
+        }
+      }
+    },
+    {
+      throttleWait: 3e3,
+      // 3 秒内只触发最后一次更新
+      throttleTrailing: true,
+      refreshDeps: [linesNeedUpdate, isCartLoading]
+    }
+  );
+  react.useEffect(() => {
+    setLoadingState((prev) => {
+      return {
+        ...prev,
+        editLineCodeAmountLoading: loading
+      };
+    });
+  }, [loading, setLoadingState]);
+};
+
+// src/hooks/cart/types/price-discount.ts
+var PriceDiscountType = /* @__PURE__ */ ((PriceDiscountType2) => {
+  PriceDiscountType2[PriceDiscountType2["PERCENTAGE"] = 1] = "PERCENTAGE";
+  PriceDiscountType2[PriceDiscountType2["FIXED_AMOUNT"] = 2] = "FIXED_AMOUNT";
+  return PriceDiscountType2;
+})(PriceDiscountType || {});
+var PriceBasePriceType = /* @__PURE__ */ ((PriceBasePriceType2) => {
+  PriceBasePriceType2[PriceBasePriceType2["MIN_DISCOUNTED_PRICE"] = 1] = "MIN_DISCOUNTED_PRICE";
+  PriceBasePriceType2[PriceBasePriceType2["MIN_TOTAL_PRICE"] = 2] = "MIN_TOTAL_PRICE";
+  return PriceBasePriceType2;
+})(PriceBasePriceType || {});
+function useProduct(options = {}) {
+  const { client, locale } = useShopify();
+  const { handle, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    handle ? ["product", locale, handle, metafieldIdentifiers] : null,
+    () => shopifySdk.getProduct(client, {
+      handle,
+      locale,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useAllProducts(options = {}) {
+  const { client, locale } = useShopify();
+  const { first, query, sortKey, reverse, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    ["all-products", locale, first, query, sortKey, reverse, metafieldIdentifiers],
+    () => shopifySdk.getAllProducts(client, {
+      locale,
+      first,
+      query,
+      sortKey,
+      reverse,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useProductsByHandles(options = {}) {
+  const { client, locale } = useShopify();
+  const { handles: originHandles, metafieldIdentifiers, ...swrOptions } = options;
+  const handles = new Set(originHandles || []);
+  const sortedHandles = handles ? [...handles].sort() : void 0;
+  return useSWR__default.default(
+    sortedHandles && sortedHandles.length > 0 ? ["products-by-handles", locale, sortedHandles.join(","), metafieldIdentifiers] : null,
+    () => {
+      const handlesArray = [...handles];
+      if (handlesArray?.length === 0) {
+        throw new Error("Handles are required");
+      }
+      return shopifySdk.getProductsByHandles(client, {
+        handles: [...handles],
+        locale,
+        metafieldIdentifiers
+      });
+    },
+    swrOptions || {
+      revalidateOnFocus: false
+    }
+  );
+}
+function getFirstAvailableVariant(product) {
+  const availableVariant = product.variants.find((v) => v.availableForSale);
+  return availableVariant || product.variants[0];
+}
+function getVariantFromSelectedOptions(product, selectedOptions) {
+  return product.variants.find((variant) => {
+    return variant.selectedOptions.every((option) => {
+      return selectedOptions[option.name] === option.value;
+    });
+  });
+}
+function useVariant({
+  product,
+  selectedOptions
+}) {
+  const [variant, setVariant] = react.useState(
+    product ? getFirstAvailableVariant(product) : void 0
+  );
+  react.useEffect(() => {
+    if (!product) {
+      setVariant(void 0);
+      return;
+    }
+    const newVariant = getVariantFromSelectedOptions(product, selectedOptions);
+    if (newVariant && newVariant.id !== variant?.id) {
+      setVariant(newVariant);
+    } else if (!newVariant) {
+      setVariant(getFirstAvailableVariant(product));
+    }
+  }, [selectedOptions, product, variant?.id]);
+  return variant;
+}
+var FAKE_PRICE = 999999999e-2;
+function formatPrice({
+  amount,
+  currencyCode,
+  locale,
+  maximumFractionDigits,
+  minimumFractionDigits,
+  removeTrailingZeros
+}) {
+  const formatter = new Intl.NumberFormat(locale, {
+    style: "currency",
+    currency: currencyCode,
+    maximumFractionDigits: maximumFractionDigits ?? 2,
+    minimumFractionDigits: minimumFractionDigits ?? 2
+  });
+  let formatted = formatter.format(amount);
+  if (removeTrailingZeros) {
+    formatted = formatted.replace(/\.00$/, "");
+  }
+  return formatted;
+}
+function formatVariantPrice({
+  amount,
+  baseAmount,
+  currencyCode,
+  locale,
+  maximumFractionDigits,
+  minimumFractionDigits,
+  removeTrailingZeros
+}) {
+  return {
+    price: formatPrice({
+      amount,
+      currencyCode,
+      locale,
+      maximumFractionDigits,
+      minimumFractionDigits,
+      removeTrailingZeros
+    }),
+    basePrice: formatPrice({
+      amount: baseAmount,
+      currencyCode,
+      locale,
+      maximumFractionDigits,
+      minimumFractionDigits,
+      removeTrailingZeros
+    })
+  };
+}
+function usePrice({
+  amount,
+  baseAmount,
+  currencyCode,
+  soldOutDescription = "",
+  maximumFractionDigits,
+  minimumFractionDigits,
+  removeTrailingZeros
+}) {
+  const { locale } = useShopify();
+  const value = react.useMemo(() => {
+    if (typeof amount !== "number" || !currencyCode) {
+      return "";
+    }
+    if (soldOutDescription && amount >= FAKE_PRICE) {
+      return soldOutDescription;
+    }
+    return baseAmount ? formatVariantPrice({
+      amount,
+      baseAmount,
+      currencyCode,
+      locale,
+      maximumFractionDigits,
+      minimumFractionDigits,
+      removeTrailingZeros
+    }) : formatPrice({
+      amount,
+      currencyCode,
+      locale,
+      maximumFractionDigits,
+      minimumFractionDigits,
+      removeTrailingZeros
+    });
+  }, [
+    amount,
+    baseAmount,
+    currencyCode,
+    locale,
+    maximumFractionDigits,
+    minimumFractionDigits,
+    soldOutDescription,
+    removeTrailingZeros
+  ]);
+  const result = react.useMemo(() => {
+    const free = Boolean(amount && amount <= 0);
+    return typeof value === "string" ? { price: value, basePrice: value, free } : { ...value, free };
+  }, [value, amount]);
+  return result;
+}
+function optionsConstructor(selectedOptions) {
+  return selectedOptions.reduce((acc, option) => {
+    acc[option.name] = option.value;
+    return acc;
+  }, {});
+}
+function decodeShopifyId(gid) {
+  try {
+    const base64 = gid.split("/").pop() || "";
+    return atob(base64);
+  } catch {
+    return gid;
+  }
+}
+function useSelectedOptions(product, sku) {
+  const [options, setOptions] = react.useState({});
+  react.useEffect(() => {
+    if (!product || !product.variants.length) {
+      setOptions({});
+      return;
+    }
+    let variant = product.variants[0];
+    if (typeof window !== "undefined") {
+      const searchParams = new URLSearchParams(window.location.search);
+      const variantIdParam = searchParams.get("variant");
+      if (variantIdParam) {
+        const foundVariant = product.variants.find((v) => {
+          if (sku) return v.sku === sku;
+          return v.id === variantIdParam || v.id.includes(variantIdParam) || decodeShopifyId(v.id) === variantIdParam;
+        });
+        if (foundVariant) {
+          variant = foundVariant;
+        }
+      }
+    }
+    if (variant) {
+      const newOptions = optionsConstructor(variant.selectedOptions);
+      setOptions(newOptions);
+    }
+  }, [product, sku]);
+  return [options, setOptions];
+}
+function decodeShopifyId2(gid) {
+  try {
+    const parts = gid.split("/");
+    return parts[parts.length - 1] || gid;
+  } catch {
+    return gid;
+  }
+}
+function useProductUrl(otherQuery) {
+  const { routerAdapter } = useShopify();
+  return react.useCallback(
+    ({ product, variant }) => {
+      if (!product) return "";
+      const queryParams = new URLSearchParams();
+      if (variant?.id) {
+        const variantId = decodeShopifyId2(variant.id);
+        if (variantId) {
+          queryParams.set("variant", variantId);
+        }
+      }
+      if (otherQuery) {
+        Object.entries(otherQuery).forEach(([key, value]) => {
+          queryParams.set(key, value);
+        });
+      }
+      const queryString = queryParams.toString();
+      const path = `/products/${product.handle}${queryString ? `?${queryString}` : ""}`;
+      if (routerAdapter?.getLocalizedPath) {
+        return routerAdapter.getLocalizedPath(path);
+      }
+      return path;
+    },
+    [routerAdapter, otherQuery]
+  );
+}
+function decodeShopifyId3(gid) {
+  try {
+    const parts = gid.split("/");
+    return parts[parts.length - 1] || gid;
+  } catch {
+    return gid;
+  }
+}
+function useUpdateVariantQuery(variant) {
+  react.useEffect(() => {
+    if (!variant || typeof window === "undefined") {
+      return;
+    }
+    const searchParams = new URLSearchParams(window.location.search);
+    const currentVariantId = searchParams.get("variant");
+    const newVariantId = decodeShopifyId3(variant.id);
+    if (newVariantId && currentVariantId !== newVariantId) {
+      searchParams.set("variant", newVariantId);
+      const newUrl = `${window.location.pathname}?${searchParams.toString()}${window.location.hash}`;
+      window.history.replaceState({}, "", newUrl);
+    }
+  }, [variant]);
+}
+function getVariantMediaList({
+  product,
+  variant
+}) {
+  if (variant.image?.url) {
+    const variantMediaId = variant.image.url;
+    const variantMedia = product.media.filter((media) => {
+      if (media.mediaContentType === "IMAGE" && media.previewImage) {
+        return media.previewImage?.url === variantMediaId;
+      }
+      return false;
+    });
+    if (variantMedia.length > 0) {
+      const otherMedia = product.media.filter((media) => {
+        if (media.mediaContentType === "IMAGE" && media.previewImage) {
+          return media.previewImage.url !== variantMediaId;
+        }
+        return true;
+      });
+      return [...variantMedia, ...otherMedia];
+    }
+  }
+  return product.media;
+}
+function useVariantMedia({
+  product,
+  variant
+}) {
+  const [imageList, setImageList] = react.useState([]);
+  const [sceneList, setSceneList] = react.useState([]);
+  const [videoList, setVideoList] = react.useState([]);
+  react.useEffect(() => {
+    if (!product || !variant) {
+      setImageList([]);
+      setSceneList([]);
+      setVideoList([]);
+      return;
+    }
+    const mediaList = getVariantMediaList({ product, variant });
+    const images = mediaList.filter((media) => media.mediaContentType === "IMAGE");
+    const videos = mediaList.filter(
+      (media) => media.mediaContentType === "VIDEO" || media.mediaContentType === "EXTERNAL_VIDEO"
+    );
+    setImageList(images.length > 0 && images[0] ? [images[0]] : []);
+    setSceneList(images.length > 1 ? images.slice(1) : []);
+    setVideoList(videos);
+  }, [product, variant]);
+  return {
+    productList: imageList,
+    sceneList,
+    videoList
+  };
+}
+function useCollection(options = {}) {
+  const { client, locale } = useShopify();
+  const { handle, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    handle ? ["collection", locale, handle, metafieldIdentifiers] : null,
+    () => shopifySdk.getCollection(client, {
+      handle,
+      locale,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useAllCollections(options = {}) {
+  const { client, locale } = useShopify();
+  const { first, query, sortKey, reverse, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    ["all-collections", locale, first, query, sortKey, reverse, metafieldIdentifiers],
+    () => shopifySdk.getAllCollections(client, {
+      locale,
+      first,
+      query,
+      sortKey,
+      reverse,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useCollections(options = {}) {
+  const { client, locale } = useShopify();
+  const { first, after, query, sortKey, reverse, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    ["collections", locale, first, after, query, sortKey, reverse, metafieldIdentifiers],
+    () => shopifySdk.getCollections(client, {
+      locale,
+      first,
+      after,
+      query,
+      sortKey,
+      reverse,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useBlog(options = {}) {
+  const { client, locale } = useShopify();
+  const { handle, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    handle ? ["blog", locale, handle, metafieldIdentifiers] : null,
+    () => shopifySdk.getBlog(client, { handle, locale, metafieldIdentifiers }),
+    swrOptions
+  );
+}
+function useAllBlogs(options = {}) {
+  const { client, locale } = useShopify();
+  const { first, query, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    ["all-blogs", locale, first, query, metafieldIdentifiers],
+    () => shopifySdk.getAllBlogs(client, {
+      locale,
+      first,
+      query,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useArticle(options = {}) {
+  const { client, locale } = useShopify();
+  const { blogHandle, articleHandle, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    blogHandle && articleHandle ? ["article", locale, blogHandle, articleHandle, metafieldIdentifiers] : null,
+    () => shopifySdk.getArticle(client, {
+      blogHandle,
+      articleHandle,
+      locale,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useArticles(options = {}) {
+  const { client, locale } = useShopify();
+  const { first, query, sortKey, reverse, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    ["articles", locale, first, query, sortKey, reverse, metafieldIdentifiers],
+    () => shopifySdk.getArticles(client, {
+      locale,
+      first,
+      query,
+      sortKey,
+      reverse,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+function useArticlesInBlog(options = {}) {
+  const { client, locale } = useShopify();
+  const { blogHandle, first, sortKey, reverse, metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    blogHandle ? ["articles-in-blog", locale, blogHandle, first, sortKey, reverse, metafieldIdentifiers] : null,
+    () => shopifySdk.getArticlesInBlog(client, {
+      blogHandle,
+      locale,
+      first,
+      sortKey,
+      reverse,
+      metafieldIdentifiers
+    }),
+    swrOptions
+  );
+}
+async function performSearch(client, locale, searchQuery, first = 20, types = ["PRODUCT", "ARTICLE", "PAGE"]) {
+  if (!searchQuery) {
+    return void 0;
+  }
+  const query = (
+    /* GraphQL */
+    `
+    query search($query: String!, $first: Int!, $types: [SearchType!])
+    @inContext(language: $language) {
+      search(query: $query, first: $first, types: $types, unavailableProducts: HIDE) {
+        totalCount
+        edges {
+          node {
+            ... on Article {
+              __typename
+              id
+              handle
+              title
+              excerpt
+              image {
+                url
+                altText
+              }
+            }
+            ... on Page {
+              __typename
+              id
+              handle
+              title
+            }
+            ... on Product {
+              __typename
+              id
+              handle
+              title
+              description
+              featuredImage {
+                url
+                altText
+              }
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  `
+  );
+  const data = await client.query(query, {
+    query: searchQuery,
+    first,
+    types
+  });
+  if (!data || !data.search) {
+    return void 0;
+  }
+  const items = data.search.edges?.map((edge) => {
+    const node = edge.node;
+    const item = {
+      type: node.__typename.toUpperCase(),
+      id: node.id,
+      handle: node.handle,
+      title: node.title
+    };
+    if (node.__typename === "Product") {
+      item.description = node.description;
+      item.image = node.featuredImage ? {
+        url: node.featuredImage.url,
+        altText: node.featuredImage.altText
+      } : void 0;
+    } else if (node.__typename === "Article") {
+      item.description = node.excerpt;
+      item.image = node.image ? {
+        url: node.image.url,
+        altText: node.image.altText
+      } : void 0;
+    }
+    return item;
+  }) || [];
+  return {
+    items,
+    totalCount: data.search.totalCount || 0,
+    pageInfo: data.search.pageInfo
+  };
+}
+function useSearch(options = {}) {
+  const { client, locale } = useShopify();
+  const { query, first = 20, types = ["PRODUCT", "ARTICLE", "PAGE"], ...swrOptions } = options;
+  return useSWR__default.default(
+    query ? ["search", locale, query, first, types] : null,
+    () => performSearch(client, locale, query, first, types),
+    swrOptions
+  );
+}
+async function getSiteInfo(client, locale, metafieldIdentifiers) {
+  const hasMetafields = metafieldIdentifiers && metafieldIdentifiers.length > 0;
+  const query = (
+    /* GraphQL */
+    `
+    query getSiteInfo(
+      ${hasMetafields ? "$shopMetafieldIdentifiers: [HasMetafieldsIdentifier!]!" : ""}
+    ) @inContext(language: $language) {
+      shop {
+        name
+        description
+        primaryDomain {
+          url
+          host
+        }
+        brand {
+          logo {
+            image {
+              url
+            }
+          }
+          colors {
+            primary {
+              background
+            }
+            secondary {
+              background
+            }
+          }
+        }
+        ${hasMetafields ? "metafields(identifiers: $shopMetafieldIdentifiers) { key value }" : ""}
+      }
+    }
+  `
+  );
+  const variables = {};
+  if (hasMetafields) {
+    variables.shopMetafieldIdentifiers = metafieldIdentifiers;
+  }
+  const data = await client.query(query, variables);
+  if (!data || !data.shop) {
+    return void 0;
+  }
+  const shop = data.shop;
+  const metafields = shop.metafields?.reduce((acc, mf) => {
+    if (mf && mf.key) {
+      acc[mf.key] = mf.value;
+    }
+    return acc;
+  }, {});
+  return {
+    name: shop.name,
+    description: shop.description,
+    primaryDomain: shop.primaryDomain,
+    brand: shop.brand ? {
+      logo: shop.brand.logo,
+      colors: shop.brand.colors ? {
+        primary: shop.brand.colors.primary?.background,
+        secondary: shop.brand.colors.secondary?.background
+      } : void 0
+    } : void 0,
+    metafields
+  };
+}
+function useSite(options = {}) {
+  const { client, locale } = useShopify();
+  const { metafieldIdentifiers, ...swrOptions } = options;
+  return useSWR__default.default(
+    ["site", locale, metafieldIdentifiers],
+    () => getSiteInfo(client, locale, metafieldIdentifiers),
+    swrOptions
+  );
+}
+
+// src/hooks/member/plus/types.ts
+var PLUS_MEMBER_TYPE = /* @__PURE__ */ ((PLUS_MEMBER_TYPE2) => {
+  PLUS_MEMBER_TYPE2[PLUS_MEMBER_TYPE2["FREE"] = 0] = "FREE";
+  PLUS_MEMBER_TYPE2[PLUS_MEMBER_TYPE2["MONTHLY"] = 1] = "MONTHLY";
+  PLUS_MEMBER_TYPE2[PLUS_MEMBER_TYPE2["ANNUAL"] = 2] = "ANNUAL";
+  return PLUS_MEMBER_TYPE2;
+})(PLUS_MEMBER_TYPE || {});
+var PlusMemberMode = /* @__PURE__ */ ((PlusMemberMode2) => {
+  PlusMemberMode2["MONTHLY"] = "monthly";
+  PlusMemberMode2["ANNUAL"] = "annual";
+  return PlusMemberMode2;
+})(PlusMemberMode || {});
+var DeliveryPlusType = /* @__PURE__ */ ((DeliveryPlusType2) => {
+  DeliveryPlusType2["FREE"] = "free";
+  DeliveryPlusType2["MONTHLY"] = "monthly";
+  DeliveryPlusType2["ANNUAL"] = "annual";
+  return DeliveryPlusType2;
+})(DeliveryPlusType || {});
+var ShippingMethodMode = /* @__PURE__ */ ((ShippingMethodMode2) => {
+  ShippingMethodMode2["FREE"] = "free";
+  ShippingMethodMode2["TDD"] = "tdd";
+  ShippingMethodMode2["NDD"] = "ndd";
+  return ShippingMethodMode2;
+})(ShippingMethodMode || {});
+var createInitialValue = () => ({
+  zipCode: "",
+  plusMemberMetafields: {},
+  setZipCode: () => {
+  },
+  allowNextDayDelivery: false,
+  setAllowNextDayDelivery: () => {
+  },
+  allowThirdDayDelivery: false,
+  setAllowThirdDayDelivery: () => {
+  },
+  selectedPlusMemberMode: "free",
+  setSelectedPlusMemberMode: () => {
+  },
+  showAreaCheckModal: false,
+  setShowAreaCheckModal: () => {
+  },
+  selectedShippingMethod: void 0,
+  setSelectedShippingMethod: () => {
+  },
+  showTip: false,
+  setShowTip: () => {
+  },
+  showMoreShippingMethod: false,
+  setShowMoreShippingMethod: () => {
+  },
+  variant: {},
+  product: {},
+  shippingMethodsContext: {
+    freeShippingMethods: [],
+    paymentShippingMethods: [],
+    nddOverweight: false,
+    tddOverweight: false
+  },
+  selectedPlusMemberProduct: null,
+  plusMemberProducts: [],
+  showPlusMemberBenefit: false,
+  setShowPlusMemberBenefit: () => {
+  },
+  deleteMarginBottom: false,
+  setDeleteMarginBottom: () => {
+  },
+  profile: void 0,
+  locale: void 0
+});
+var PlusMemberContext = react.createContext(createInitialValue());
+function usePlusMemberContext() {
+  return react.useContext(PlusMemberContext);
+}
+function usePlusMonthlyProductVariant() {
+  const { plusMemberProducts, plusMemberMetafields } = usePlusMemberContext();
+  const plusMonthly = plusMemberMetafields?.plus_monthly_product;
+  const plusMonthlyProductVariant = react.useMemo(() => {
+    const product = plusMemberProducts?.find(
+      (item) => item?.handle === plusMonthly?.handle
+    );
+    const productVariant = product?.variants?.find(
+      (item) => item.sku === plusMonthly?.sku
+    );
+    return productVariant;
+  }, [plusMemberProducts, plusMonthly]);
+  return plusMonthlyProductVariant;
+}
+function usePlusAnnualProductVariant() {
+  const { plusMemberProducts, plusMemberMetafields } = usePlusMemberContext();
+  const plusAnnual = plusMemberMetafields?.plus_annual_product;
+  const plusAnnualProductVariant = react.useMemo(() => {
+    const product = plusMemberProducts?.find(
+      (item) => item?.handle === plusAnnual?.handle
+    );
+    const productVariant = product?.variants?.find(
+      (item) => item.sku === plusAnnual?.sku
+    );
+    return productVariant;
+  }, [plusMemberProducts, plusAnnual]);
+  return plusAnnualProductVariant;
+}
+function useShippingMethods(options) {
+  const {
+    variant,
+    plusMemberMetafields,
+    selectedPlusMemberMode,
+    isPlus = false,
+    nddCoupon,
+    tddCoupon
+  } = options;
+  const { plus_shipping, shippingMethod } = plusMemberMetafields || {};
+  const nddOverweight = react.useMemo(() => {
+    return (variant?.weight || 0) > (shippingMethod?.overWeight_ndd || Infinity);
+  }, [shippingMethod?.overWeight_ndd, variant?.weight]);
+  const tddOverweight = react.useMemo(() => {
+    return (variant?.weight || 0) > (shippingMethod?.overWeight_tdd || Infinity);
+  }, [shippingMethod?.overWeight_tdd, variant?.weight]);
+  const paymentShippingMethods = react.useMemo(() => {
+    const weight = variant?.weight || 0;
+    const methods = plus_shipping?.shipping_methods?.filter(
+      ({ weight_low, weight_high, __mode, __plus }) => {
+        const fitWeight = (!weight_low || weight >= weight_low) && (!weight_high || weight <= weight_high);
+        return __mode !== "free" /* FREE */ && !__plus && fitWeight;
+      }
+    ) || [];
+    return methods.map((method) => {
+      let disabled = false;
+      const selectedFreeMember = selectedPlusMemberMode === "free";
+      if (method.__mode === "ndd" /* NDD */) {
+        disabled = selectedFreeMember || nddOverweight;
+      } else if (method.__mode === "tdd" /* TDD */) {
+        disabled = selectedFreeMember || tddOverweight;
+      }
+      return {
+        ...method,
+        id: method.__mode + method.__code,
+        useCoupon: false,
+        subtitle: plus_shipping?.directly || "",
+        disabled
+      };
+    });
+  }, [
+    nddOverweight,
+    plus_shipping?.directly,
+    plus_shipping?.shipping_methods,
+    selectedPlusMemberMode,
+    tddOverweight,
+    variant?.weight
+  ]);
+  const nddPrice = react.useMemo(() => {
+    const weight = variant?.weight || 0;
+    const nddMethod = paymentShippingMethods.find(
+      ({ __mode, weight_high, weight_low }) => {
+        const fitWeight = (!weight_low || weight >= weight_low) && (!weight_high || weight <= weight_high);
+        return __mode === "ndd" && fitWeight;
+      }
+    );
+    return nddMethod?.price || 0;
+  }, [variant?.weight, paymentShippingMethods]);
+  const tddPrice = react.useMemo(() => {
+    const weight = variant?.weight || 0;
+    const tddMethod = paymentShippingMethods.find(
+      ({ __mode, weight_high, weight_low }) => {
+        const fitWeight = (!weight_low || weight >= weight_low) && (!weight_high || weight <= weight_high);
+        return __mode === "tdd" && fitWeight;
+      }
+    );
+    return tddMethod?.price || 0;
+  }, [variant?.weight, paymentShippingMethods]);
+  const freeShippingMethods = react.useMemo(() => {
+    const weight = variant?.weight || 0;
+    let methods = plus_shipping?.shipping_methods?.filter(
+      ({ __mode, __plus, weight_low, weight_high }) => {
+        if (__mode === "free" /* FREE */) {
+          return true;
+        }
+        if (isPlus) {
+          const hasCoupon = isPlus && __mode === "ndd" /* NDD */ && nddCoupon || isPlus && __mode === "tdd" /* TDD */ && (tddCoupon || nddCoupon);
+          const fitWeight = (!weight_low || weight >= weight_low) && (!weight_high || weight <= weight_high);
+          return hasCoupon && fitWeight && !__plus;
+        } else {
+          return __plus;
+        }
+      }
+    ) || [];
+    if (isPlus) {
+      methods = methods.sort((a, b) => {
+        if (b.__mode === "free" /* FREE */) return -1;
+        return 0;
+      });
+    }
+    return methods.map((method) => {
+      let price = 0;
+      let coupon;
+      let disabled;
+      if (method.__mode !== "free" /* FREE */) {
+        switch (method.__mode) {
+          case "tdd":
+            price = tddPrice;
+            coupon = tddCoupon || nddCoupon;
+            break;
+          case "ndd":
+            price = nddPrice;
+            coupon = nddCoupon;
+            break;
+        }
+        disabled = selectedPlusMemberMode === "free";
+        if (method.__mode === "ndd" /* NDD */) {
+          disabled = disabled || nddOverweight;
+        } else if (method.__mode === "tdd" /* TDD */) {
+          disabled = disabled || tddOverweight;
+        }
+      }
+      return {
+        ...method,
+        id: method.__mode + method.__code,
+        useCoupon: true,
+        disabled,
+        coupon,
+        price
+      };
+    });
+  }, [
+    variant?.weight,
+    plus_shipping?.shipping_methods,
+    isPlus,
+    nddCoupon,
+    tddCoupon,
+    selectedPlusMemberMode,
+    tddPrice,
+    nddPrice,
+    nddOverweight,
+    tddOverweight
+  ]);
+  return {
+    freeShippingMethods,
+    paymentShippingMethods,
+    nddOverweight,
+    tddOverweight
+  };
+}
+function useShippingMethodAvailableCheck() {
+  const {
+    zipCode,
+    allowNextDayDelivery,
+    allowThirdDayDelivery,
+    selectedShippingMethod,
+    setSelectedShippingMethod,
+    setShowTip,
+    shippingMethodsContext
+  } = usePlusMemberContext();
+  react.useEffect(() => {
+    const freeShippingMethod = shippingMethodsContext.freeShippingMethods[0];
+    const standardShippingMethod = shippingMethodsContext.freeShippingMethods?.find(
+      (item) => item.__mode === "free" /* FREE */
+    );
+    const freeTDD = shippingMethodsContext.freeShippingMethods.find(
+      (item) => item.__mode === "tdd" /* TDD */
+    );
+    const paymentTDD = shippingMethodsContext.paymentShippingMethods.find(
+      (item) => item.__mode === "tdd" /* TDD */
+    );
+    if (zipCode) {
+      console.log(
+        "allowNextDayDelivery, allowThirdDayDelivery:",
+        allowNextDayDelivery,
+        allowThirdDayDelivery
+      );
+      if (!allowNextDayDelivery && !allowThirdDayDelivery) {
+        setShowTip(true);
+        setSelectedShippingMethod(standardShippingMethod);
+      } else {
+        if (selectedShippingMethod?.__mode === "ndd" /* NDD */ && !allowNextDayDelivery) {
+          setShowTip(true);
+          if (allowThirdDayDelivery) {
+            if (selectedShippingMethod.useCoupon) {
+              const method = freeTDD || freeShippingMethod;
+              if (method) setSelectedShippingMethod(method);
+            } else {
+              const method = paymentTDD || freeShippingMethod;
+              if (method) setSelectedShippingMethod(method);
+            }
+          } else {
+            if (freeShippingMethod) setSelectedShippingMethod(freeShippingMethod);
+          }
+        } else if (
+          // TDD 无法使用
+          selectedShippingMethod?.__mode === "tdd" /* TDD */ && !allowThirdDayDelivery
+        ) {
+          setShowTip(true);
+          if (freeShippingMethod) setSelectedShippingMethod(freeShippingMethod);
+        }
+      }
+    }
+  }, [
+    allowNextDayDelivery,
+    allowThirdDayDelivery,
+    zipCode,
+    shippingMethodsContext,
+    selectedShippingMethod,
+    setSelectedShippingMethod,
+    setShowTip
+  ]);
+}
+var useReplaceCartPlusMember = () => {
+  const { plusMemberMetafields, selectedPlusMemberMode } = usePlusMemberContext();
+  const { trigger: removeCartLines2 } = useRemoveCartLines();
+  const { cart } = useCartContext();
+  const plusMonthly = plusMemberMetafields?.plus_monthly_product;
+  const plusAnnual = plusMemberMetafields?.plus_annual_product;
+  const handler = react.useCallback(async () => {
+    const plusMonthlyInCart = cart?.lineItems.find(
+      (item) => item.variant?.sku === plusMonthly?.sku
+    );
+    const plusAnnualInCart = cart?.lineItems.find(
+      (item) => item.variant?.sku === plusAnnual?.sku
+    );
+    if (selectedPlusMemberMode === "annual" /* ANNUAL */ && plusMonthlyInCart) {
+      await removeCartLines2({
+        lineIds: [plusMonthlyInCart.id]
+      });
+    } else if (selectedPlusMemberMode === "monthly" /* MONTHLY */ && plusAnnualInCart) {
+      await removeCartLines2({
+        lineIds: [plusAnnualInCart.id]
+      });
+    }
+  }, [
+    cart?.lineItems,
+    selectedPlusMemberMode,
+    plusMonthly?.sku,
+    plusAnnual?.sku,
+    removeCartLines2
+  ]);
+  return handler;
+};
+var usePlusMemberDeliveryCodes = ({
+  deliveryData
+}) => {
+  return react.useMemo(
+    () => deliveryData?.deliveryCustomData?.discount_code,
+    [deliveryData]
+  );
+};
+var usePlusMemberItemCustomAttributes = ({
+  deliveryData
+}) => {
+  const { deliveryCustomData } = deliveryData || {};
+  return react.useMemo(() => {
+    const itemCustomAttributes = [];
+    if (deliveryCustomData?.is_presale) {
+      itemCustomAttributes.push({
+        key: "_is_presale",
+        value: "true"
+      });
+    }
+    return itemCustomAttributes;
+  }, [deliveryCustomData]);
+};
+var usePlusMemberCheckoutCustomAttributes = ({
+  deliveryData,
+  product,
+  variant,
+  customer,
+  isShowShippingBenefits
+}) => {
+  const { deliveryCustomData } = deliveryData || {};
+  const { profile } = usePlusMemberContext();
+  const userType = react.useMemo(() => {
+    const customerInfo = customer;
+    if (!customerInfo) {
+      return "new_user_unlogin";
+    }
+    if (customer) {
+      const { orders = {} } = customer;
+      const edgesLength = orders?.edges?.length;
+      if (edgesLength === 1) {
+        return "old_user_orders_once";
+      } else if (edgesLength && edgesLength > 1) {
+        return "old_user_orders_twice";
+      }
+    }
+    return "new_user_login";
+  }, [customer]);
+  return react.useMemo(() => {
+    const checkoutCustomAttributes = [
+      {
+        key: "_token",
+        value: profile?.token || ""
+      },
+      {
+        key: "_last_url",
+        value: typeof window !== "undefined" ? window.location.origin + window.location.pathname : ""
+      },
+      {
+        key: "_user_type",
+        value: userType
+      }
+    ];
+    if (profile) {
+      checkoutCustomAttributes.push({
+        key: "_login_user",
+        value: "1"
+      });
+    }
+    if (deliveryCustomData) {
+      checkoutCustomAttributes.push({
+        key: "_checkout_delivery_custom",
+        value: JSON.stringify({
+          ...deliveryCustomData,
+          is_prime: profile?.isPlus
+        })
+      });
+    }
+    if (variant?.metafields?.presell) {
+      checkoutCustomAttributes.push({
+        key: "_presale",
+        value: "true"
+      });
+    }
+    if (isShowShippingBenefits && !isShowShippingBenefits({ variant, product, setting: {} })) {
+      checkoutCustomAttributes.push({
+        key: "_hide_shipping",
+        value: "true"
+      });
+    }
+    return checkoutCustomAttributes;
+  }, [deliveryCustomData, product, profile, userType, variant, isShowShippingBenefits]);
+};
+function useAutoRemovePlusMemberInCart({
+  metafields,
+  isMonthlyPlus,
+  isAnnualPlus
+}) {
+  const { plus_monthly_product, plus_annual_product } = metafields || {};
+  const { cart } = useCartContext();
+  const { trigger: removeCartLines2 } = useRemoveCartLines();
+  react.useEffect(() => {
+    if (!cart) return;
+    const removePlusProduct = async (productType) => {
+      if (!productType) return;
+      const product = cart.lineItems?.find(
+        (item) => item.product?.handle === productType?.handle && item.variant?.sku === productType?.sku
+      );
+      if (product) {
+        await removeCartLines2({
+          lineIds: [product.id]
+        });
+      }
+    };
+    if (isMonthlyPlus) {
+      removePlusProduct(plus_monthly_product);
+    }
+    if (isAnnualPlus) {
+      removePlusProduct(plus_annual_product);
+    }
+  }, [
+    cart,
+    plus_annual_product,
+    plus_monthly_product,
+    isAnnualPlus,
+    isMonthlyPlus,
+    removeCartLines2
+  ]);
+}
+var PlusMemberProvider = ({
+  variant,
+  product,
+  shopCommon,
+  metafields,
+  initialSelectedPlusMemberMode = "free",
+  profile,
+  locale,
+  children
+}) => {
+  const [zipCode, setZipCode] = react.useState("");
+  const [showTip, setShowTip] = react.useState(false);
+  const [selectedPlusMemberMode, setSelectedPlusMemberMode] = react.useState(
+    initialSelectedPlusMemberMode
+  );
+  const [selectedShippingMethod, setSelectedShippingMethod] = react.useState();
+  const [allowNextDayDelivery, setAllowNextDayDelivery] = react.useState(false);
+  const [allowThirdDayDelivery, setAllowThirdDayDelivery] = react.useState(false);
+  const [showAreaCheckModal, setShowAreaCheckModal] = react.useState(false);
+  const [showMoreShippingMethod, setShowMoreShippingMethod] = react.useState(false);
+  const [showPlusMemberBenefit, setShowPlusMemberBenefit] = react.useState(false);
+  const [deleteMarginBottom, setDeleteMarginBottom] = react.useState(false);
+  const shippingMethodsContext = useShippingMethods({
+    variant,
+    plusMemberMetafields: metafields,
+    selectedPlusMemberMode});
+  const plusMemberHandles = react.useMemo(() => {
+    return [
+      metafields?.plus_monthly_product?.handle,
+      metafields?.plus_annual_product?.handle
+    ].filter(Boolean);
+  }, [metafields]);
+  const { data: plusMemberProducts = [] } = useProductsByHandles({
+    handles: plusMemberHandles
+  });
+  const selectedPlusMemberProduct = react.useMemo(() => {
+    if (selectedPlusMemberMode === "free" /* FREE */) {
+      return null;
+    }
+    const handle = selectedPlusMemberMode === "monthly" /* MONTHLY */ ? metafields?.plus_monthly_product?.handle : metafields?.plus_annual_product?.handle;
+    const sku = selectedPlusMemberMode === "monthly" /* MONTHLY */ ? metafields?.plus_monthly_product?.sku : metafields?.plus_annual_product?.sku;
+    const product2 = plusMemberProducts?.find((p) => p.handle === handle);
+    const variant2 = product2?.variants?.find((v) => v.sku === sku);
+    return product2 && variant2 ? { product: product2, variant: variant2 } : null;
+  }, [plusMemberProducts, metafields, selectedPlusMemberMode]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    PlusMemberContext.Provider,
+    {
+      value: {
+        variant,
+        shopCommon,
+        zipCode,
+        setZipCode,
+        allowNextDayDelivery,
+        setAllowNextDayDelivery,
+        allowThirdDayDelivery,
+        setAllowThirdDayDelivery,
+        plusMemberMetafields: metafields,
+        selectedPlusMemberMode,
+        setSelectedPlusMemberMode,
+        showAreaCheckModal,
+        setShowAreaCheckModal,
+        selectedShippingMethod,
+        setSelectedShippingMethod,
+        shippingMethodsContext,
+        showTip,
+        setShowTip,
+        showMoreShippingMethod,
+        setShowMoreShippingMethod,
+        selectedPlusMemberProduct,
+        plusMemberProducts,
+        product,
+        showPlusMemberBenefit,
+        setShowPlusMemberBenefit,
+        deleteMarginBottom,
+        setDeleteMarginBottom,
+        profile,
+        locale
+      },
+      children
+    }
+  );
+};
+function useIntersection(targetRef, options) {
+  const {
+    callback,
+    once = false,
+    root = null,
+    rootMargin = "0px",
+    threshold = 0.8
+  } = options;
+  react.useEffect(() => {
+    if (!targetRef?.current) {
+      return;
+    }
+    if (typeof IntersectionObserver === "undefined") {
+      console.warn("[useIntersection] IntersectionObserver is not supported");
+      return;
+    }
+    const current = targetRef.current;
+    const observerOptions = {
+      root,
+      rootMargin,
+      threshold
+    };
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          callback();
+          if (once) {
+            observer.disconnect();
+          }
+        }
+      });
+    }, observerOptions);
+    observer.observe(current);
+    return () => {
+      observer.disconnect();
+    };
+  }, [targetRef, callback, once, root, rootMargin, threshold]);
+}
+function useExposure(targetRef, options) {
+  const { threshold = 0.5, duration = 2e3, once = true, onExposure } = options;
+  const [isVisible, setIsVisible] = react.useState(false);
+  const timeoutRef = react.useRef(void 0);
+  const hasTriggeredRef = react.useRef(false);
+  react.useEffect(() => {
+    if (!targetRef?.current || typeof IntersectionObserver === "undefined") {
+      return;
+    }
+    if (once && hasTriggeredRef.current) {
+      return;
+    }
+    const current = targetRef.current;
+    const clearTimer = () => {
+      if (timeoutRef.current) {
+        clearTimeout(timeoutRef.current);
+        timeoutRef.current = void 0;
+      }
+    };
+    const observer = new IntersectionObserver(
+      (entries) => {
+        entries.forEach((entry) => {
+          setIsVisible(entry.isIntersecting);
+          if (entry.isIntersecting) {
+            timeoutRef.current = setTimeout(() => {
+              if (once && hasTriggeredRef.current) {
+                return;
+              }
+              onExposure();
+              hasTriggeredRef.current = true;
+              if (once) {
+                observer.disconnect();
+              }
+            }, duration);
+          } else {
+            clearTimer();
+          }
+        });
+      },
+      {
+        root: null,
+        rootMargin: "0px",
+        threshold
+      }
+    );
+    observer.observe(current);
+    return () => {
+      clearTimer();
+      observer.disconnect();
+    };
+  }, [targetRef, threshold, duration, once, onExposure]);
+  return isVisible;
+}
+function determineSuggestedLocale(countryCode, mapping) {
+  if (!countryCode) {
+    return "us";
+  }
+  const upperCode = countryCode.toUpperCase();
+  if (mapping?.customMapping?.[upperCode]) {
+    return mapping.customMapping[upperCode];
+  }
+  if (mapping?.euCountries?.includes(upperCode)) {
+    if (upperCode === "PL") {
+      return "pl";
+    }
+    return "eu";
+  }
+  if (mapping?.auCountries?.includes(upperCode)) {
+    return "au";
+  }
+  if (mapping?.deCountries?.includes(upperCode)) {
+    return "de";
+  }
+  if (mapping?.aeEnCountries?.includes(upperCode)) {
+    return "ae-en";
+  }
+  if (upperCode === "GB") {
+    return "uk";
+  }
+  return countryCode.toLowerCase();
+}
+function useGeoLocation(options = {}) {
+  const {
+    endpoint = "/geolocation",
+    cacheKey = "geoLocation",
+    cacheDuration = 1e3 * 60 * 60 * 24,
+    // 24 hours
+    localeMapping,
+    enableCache = true,
+    ...swrOptions
+  } = options;
+  const fetcher = async () => {
+    if (enableCache) {
+      const cached = shopifySdk.getLocalStorage(cacheKey);
+      if (cached) {
+        return cached;
+      }
+    }
+    try {
+      const response = await fetch(endpoint);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch geo location: ${response.status}`);
+      }
+      const result = await response.json();
+      const countryCode = result?.geo?.country?.code;
+      if (!countryCode) {
+        console.warn("[useGeoLocation] No country code in response");
+        return void 0;
+      }
+      const suggestLocale = determineSuggestedLocale(
+        countryCode,
+        localeMapping
+      );
+      const geoData = {
+        geo: result.geo,
+        suggestLocale
+      };
+      if (enableCache) {
+        const expires = new Date(Date.now() + cacheDuration);
+        shopifySdk.setLocalStorage(cacheKey, geoData, { expires });
+      }
+      return geoData;
+    } catch (error) {
+      console.error("[useGeoLocation] Error fetching geo data:", error);
+      return void 0;
+    }
+  };
+  return useSWR__default.default(
+    cacheKey,
+    fetcher,
+    swrOptions
+  );
+}
+function getCachedGeoLocation(cacheKey = "geoLocation") {
+  return shopifySdk.getLocalStorage(cacheKey) ?? void 0;
+}
+function clearGeoLocationCache(cacheKey = "geoLocation") {
+  if (typeof localStorage !== "undefined") {
+    localStorage.removeItem(cacheKey);
+  }
+}
+
+exports.BuyRuleType = BuyRuleType;
+exports.CODE_AMOUNT_KEY = CODE_AMOUNT_KEY;
+exports.CUSTOMER_ATTRIBUTE_KEY = CUSTOMER_ATTRIBUTE_KEY;
+exports.CUSTOMER_SCRIPT_GIFT_KEY = CUSTOMER_SCRIPT_GIFT_KEY;
+exports.DeliveryPlusType = DeliveryPlusType;
+exports.MAIN_PRODUCT_CODE = MAIN_PRODUCT_CODE;
+exports.OrderBasePriceType = OrderBasePriceType;
+exports.OrderDiscountType = OrderDiscountType;
+exports.PLUS_MEMBER_TYPE = PLUS_MEMBER_TYPE;
+exports.PlusMemberContext = PlusMemberContext;
+exports.PlusMemberMode = PlusMemberMode;
+exports.PlusMemberProvider = PlusMemberProvider;
+exports.PriceBasePriceType = PriceBasePriceType;
+exports.PriceDiscountType = PriceDiscountType;
+exports.RuleType = RuleType;
+exports.SCRIPT_CODE_AMOUNT_KEY = SCRIPT_CODE_AMOUNT_KEY;
+exports.ShippingMethodMode = ShippingMethodMode;
+exports.SpendMoneyType = SpendMoneyType;
+exports.atobID = atobID;
+exports.btoaID = btoaID;
+exports.clearGeoLocationCache = clearGeoLocationCache;
+exports.currencyCodeMapping = currencyCodeMapping;
+exports.defaultSWRMutationConfiguration = defaultSWRMutationConfiguration;
+exports.formatFunctionAutoFreeGift = formatFunctionAutoFreeGift;
+exports.formatScriptAutoFreeGift = formatScriptAutoFreeGift;
+exports.getCachedGeoLocation = getCachedGeoLocation;
+exports.getDiscountEnvAttributeValue = getDiscountEnvAttributeValue;
+exports.getMatchedMainProductSubTotal = getMatchedMainProductSubTotal;
+exports.getQuery = getQuery;
+exports.getReferralAttributes = getReferralAttributes;
+exports.isAttributesEqual = isAttributesEqual;
+exports.preCheck = preCheck;
+exports.safeParseJson = safeParseJson;
+exports.useAddCartLines = useAddCartLines;
+exports.useAddToCart = useAddToCart;
+exports.useAllBlogs = useAllBlogs;
+exports.useAllCollections = useAllCollections;
+exports.useAllProducts = useAllProducts;
+exports.useApplyCartCodes = useApplyCartCodes;
+exports.useArticle = useArticle;
+exports.useArticles = useArticles;
+exports.useArticlesInBlog = useArticlesInBlog;
+exports.useAutoRemovePlusMemberInCart = useAutoRemovePlusMemberInCart;
+exports.useBlog = useBlog;
+exports.useBuyNow = useBuyNow;
+exports.useCalcAutoFreeGift = useCalcAutoFreeGift;
+exports.useCalcOrderDiscount = useCalcOrderDiscount;
+exports.useCartAttributes = useCartAttributes;
+exports.useCartItemQuantityLimit = useCartItemQuantityLimit;
+exports.useCollection = useCollection;
+exports.useCollections = useCollections;
+exports.useCreateCart = useCreateCart;
+exports.useExposure = useExposure;
+exports.useGeoLocation = useGeoLocation;
+exports.useHasPlusMemberInCart = useHasPlusMemberInCart;
+exports.useIntersection = useIntersection;
+exports.usePlusAnnualProductVariant = usePlusAnnualProductVariant;
+exports.usePlusMemberCheckoutCustomAttributes = usePlusMemberCheckoutCustomAttributes;
+exports.usePlusMemberContext = usePlusMemberContext;
+exports.usePlusMemberDeliveryCodes = usePlusMemberDeliveryCodes;
+exports.usePlusMemberItemCustomAttributes = usePlusMemberItemCustomAttributes;
+exports.usePlusMonthlyProductVariant = usePlusMonthlyProductVariant;
+exports.usePrice = usePrice;
+exports.useProduct = useProduct;
+exports.useProductUrl = useProductUrl;
+exports.useProductsByHandles = useProductsByHandles;
+exports.useRemoveCartCodes = useRemoveCartCodes;
+exports.useRemoveCartLines = useRemoveCartLines;
+exports.useReplaceCartPlusMember = useReplaceCartPlusMember;
+exports.useScriptAutoFreeGift = useScriptAutoFreeGift;
+exports.useSearch = useSearch;
+exports.useSelectedOptions = useSelectedOptions;
+exports.useShippingMethodAvailableCheck = useShippingMethodAvailableCheck;
+exports.useShippingMethods = useShippingMethods;
+exports.useSite = useSite;
+exports.useUpdateCartAttributes = useUpdateCartAttributes;
+exports.useUpdateCartLines = useUpdateCartLines;
+exports.useUpdateLineCodeAmountAttributes = useUpdateLineCodeAmountAttributes;
+exports.useUpdateVariantQuery = useUpdateVariantQuery;
+exports.useVariant = useVariant;
+exports.useVariantMedia = useVariantMedia;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map