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

package/dist/provider/index.mjs

@@ -0,0 +1,1117 @@
+import { createContext, useMemo, useContext, useState, useCallback, useEffect, useRef } from 'react';
+import { createShopifyClient, getCart, updateCartAttributes, updateCartLines, getProductsByHandles } from '@anker-in/shopify-sdk';
+import Cookies5 from 'js-cookie';
+import { jsx } from 'react/jsx-runtime';
+import Decimal2 from 'decimal.js';
+import useSWR from 'swr';
+import useSWRMutation8 from 'swr/mutation';
+import { useRequest } from 'ahooks';
+
+// src/provider/context.ts
+var ShopifyContext = createContext(null);
+var browserCookieAdapter = {
+  get(key) {
+    return Cookies5.get(key);
+  },
+  set(key, value, options) {
+    Cookies5.set(key, value, {
+      domain: options?.domain,
+      path: options?.path || "/",
+      expires: options?.expires,
+      secure: options?.secure,
+      sameSite: options?.sameSite
+    });
+  },
+  remove(key) {
+    Cookies5.remove(key);
+  }
+};
+function getCartCookieName(locale) {
+  return `${locale}-shopify-cart-id`;
+}
+var browserCartCookieAdapter = {
+  getCartId(locale) {
+    return Cookies5.get(getCartCookieName(locale));
+  },
+  setCartId(locale, cartId) {
+    Cookies5.set(getCartCookieName(locale), cartId, {
+      path: "/",
+      expires: 30
+      // 30 days
+    });
+  },
+  removeCartId(locale) {
+    Cookies5.remove(getCartCookieName(locale));
+  }
+};
+function ShopifyProvider({
+  config,
+  locale,
+  locales,
+  cookieAdapter = browserCookieAdapter,
+  cartCookieAdapter = browserCartCookieAdapter,
+  routerAdapter,
+  userAdapter,
+  children
+}) {
+  const client = useMemo(() => {
+    return createShopifyClient(config, locale);
+  }, [config, locale]);
+  const value = useMemo(() => {
+    return {
+      client,
+      config,
+      locale,
+      locales: locales || config.getLocales(),
+      cookieAdapter,
+      cartCookieAdapter,
+      routerAdapter,
+      userAdapter
+    };
+  }, [
+    client,
+    config,
+    locale,
+    locales,
+    cookieAdapter,
+    cartCookieAdapter,
+    routerAdapter,
+    userAdapter
+  ]);
+  return /* @__PURE__ */ jsx(ShopifyContext.Provider, { value, children });
+}
+function useShopify() {
+  const context = useContext(ShopifyContext);
+  if (!context) {
+    throw new Error("useShopify must be used within a ShopifyProvider");
+  }
+  return context;
+}
+
+// src/hooks/cart/const.ts
+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.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.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(
+        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(
+        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 = useMemo(() => customer?.tags || [], [customer?.tags]);
+  const isCustomerLoading = useMemo(() => !customer ? true : false, [customer]);
+  const dealsType = "";
+  const { client, locale } = useShopify();
+  const giftProductsCache = useRef(null);
+  const { activeCampaign, subtotal } = 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 } = 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 = 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 = 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(shouldFetch ? giftHandles : null, async () => {
+    const res = await getProductsByHandles(client, {
+      handles: giftHandles,
+      locale
+    });
+    const result = Array.isArray(res) ? res : [];
+    giftProductsCache.current = {
+      data: result,
+      giftHandles: [...giftHandles]
+    };
+    return result;
+  });
+  const finalGiftProductsResult = 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] = useState(false);
+  const giftProductsCache = useRef(null);
+  useEffect(() => {
+    if (locale === "au") {
+      const isPointsSubscribe = Cookies5.get("points_subscribe");
+      set_points_subscribe(!!isPointsSubscribe);
+    }
+  }, [locale]);
+  const [upgrade_multiple, upgrade_value] = 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 = useMemo(() => {
+    if (!campaign) return [];
+    return (campaign.breakpoints || []).map((item) => ({
+      breakpoint: new Decimal2(item.breakpoint).minus(new Decimal2(upgrade_value)).dividedBy(new Decimal2(upgrade_multiple)).toFixed(2, Decimal2.ROUND_DOWN),
+      giveawayProducts: item.giveawayProducts || []
+    }));
+  }, [campaign, upgrade_multiple, upgrade_value]);
+  const giftHandles = useMemo(
+    () => (
+      // 使用 Set 去重，然后拼接字符串
+      [
+        ...new Set(
+          breakpoints.flatMap((b) => b.giveawayProducts.map((p) => p.handle)).filter(Boolean)
+        )
+      ]
+    ),
+    [breakpoints]
+  );
+  const shouldFetch = useMemo(() => {
+    if (!giftHandles.length) return false;
+    if (giftProductsCache.current && JSON.stringify(giftProductsCache.current.giftHandles) === JSON.stringify(giftHandles)) {
+      return false;
+    }
+    return true;
+  }, [giftHandles]);
+  const involvedLines = 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 = useMemo(() => {
+    if (!campaign) return new Decimal2(0);
+    return involvedLines.reduce((prev, item) => {
+      const amount = campaign.useTotalAmount ? item.totalAmount : item.subtotalAmount;
+      return new Decimal2(prev).plus(new Decimal2(amount || 0));
+    }, new Decimal2(0));
+  }, [involvedLines, campaign]);
+  const [freeGiftLevel, nextFreeGiftLevel] = useMemo(() => {
+    const sortedLevels = [...breakpoints].sort(
+      (a, b) => Number(b.breakpoint) - Number(a.breakpoint)
+    );
+    const levelIndex = sortedLevels.findIndex(
+      (level) => involvedSubTotal.gte(new Decimal2(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(shouldFetch ? giftHandles : null, async () => {
+    const res = await getProductsByHandles(client, {
+      handles: giftHandles,
+      locale
+    });
+    const result = Array.isArray(res) ? res : [];
+    giftProductsCache.current = {
+      data: result,
+      giftHandles: [...giftHandles]
+    };
+    return result;
+  });
+  const finalGiftProductsResult = useMemo(() => {
+    if (giftProductsCache.current && !shouldFetch) {
+      return giftProductsCache.current.data || void 0;
+    }
+    return giftProductsResult;
+  }, [giftProductsResult, shouldFetch]);
+  const reorder = 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
+  };
+};
+function useUpdateCartAttributes(mutate, metafieldIdentifiers, options) {
+  const { client, locale, cartCookieAdapter } = useShopify();
+  const updateAttributes = useCallback(
+    async (_key, { arg }) => {
+      const updatedCart = await updateCartAttributes(client, {
+        ...arg,
+        metafieldIdentifiers,
+        cookieAdapter: cartCookieAdapter
+      });
+      console.log("useUpdateCartAttributes updatedCart", updatedCart);
+      if (updatedCart) {
+        mutate(updatedCart);
+      }
+      return updatedCart;
+    },
+    [client, locale, cartCookieAdapter, mutate]
+  );
+  return useSWRMutation8("update-cart-attributes", updateAttributes, options);
+}
+function useHasPlusMemberInCart({
+  memberSetting,
+  cart
+}) {
+  const { plus_monthly_product, plus_annual_product } = memberSetting || {};
+  return 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.get("invite_code");
+  const playModeId = Cookies5.get("playModeId");
+  const popup = Cookies5.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] = useState("");
+  const { hasPlusMember } = useHasPlusMemberInCart({
+    memberSetting,
+    cart
+  });
+  console.log("memberSetting", memberSetting);
+  console.log("hasPlusMember", hasPlusMember);
+  useEffect(() => {
+    setCurrentUrl(window.location.href);
+  }, []);
+  const userType = useMemo(() => {
+    let userInfo = Cookies5.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 = 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 = 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 = useMemo(() => {
+    return [
+      {
+        key: "_presale",
+        value: cart?.lineItems.some((item) => item?.variant?.metafields?.presell === "presell")
+      }
+    ];
+  }, [cart]);
+  const weightAttributes = useMemo(() => {
+    return [
+      {
+        key: "_weight",
+        value: cart?.lineItems.reduce((acc, item) => {
+          return new Decimal2(acc).plus(item.variant.weight ?? 0).toNumber();
+        }, 0).toString()
+      },
+      {
+        key: "_app_source_name",
+        value: "dtc"
+      }
+    ];
+  }, [cart]);
+  const trackingAttributes = useMemo(() => {
+    return [
+      {
+        key: "utm_params",
+        value: currentUrl
+      }
+    ];
+  }, [currentUrl]);
+  return useMemo(
+    () => ({
+      attributes: [
+        ...memberAttributes,
+        ...functionAttributes,
+        ...presellAttributes,
+        ...weightAttributes,
+        ...trackingAttributes,
+        ...getReferralAttributes()
+      ].filter((item) => item?.value)
+    }),
+    [memberAttributes, functionAttributes, presellAttributes, weightAttributes, trackingAttributes]
+  );
+};
+var useUpdateLineCodeAmountAttributes = ({
+  cart,
+  mutateCart,
+  isCartLoading,
+  setLoadingState,
+  metafieldIdentifiers
+}) => {
+  const { client, cartCookieAdapter } = useShopify();
+  const mainProductDiscountCodes = useMemo(
+    () => cart?.discountCodes.filter(
+      ({ code, applicable }) => applicable && MAIN_PRODUCT_CODE.some((codePrefix) => code.startsWith(codePrefix))
+    ).map(({ code }) => code),
+    [cart]
+  );
+  const linesNeedUpdate = 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 } = useRequest(
+    async () => {
+      if (linesNeedUpdate?.length && !isCartLoading) {
+        const result = await updateCartLines(client, {
+          cartId: cart?.id || "",
+          lines: linesNeedUpdate,
+          metafieldIdentifiers,
+          cookieAdapter: cartCookieAdapter
+        });
+        if (result) {
+          mutateCart(result);
+        }
+      }
+    },
+    {
+      throttleWait: 3e3,
+      // 3 秒内只触发最后一次更新
+      throttleTrailing: true,
+      refreshDeps: [linesNeedUpdate, isCartLoading]
+    }
+  );
+  useEffect(() => {
+    setLoadingState((prev) => {
+      return {
+        ...prev,
+        editLineCodeAmountLoading: loading
+      };
+    });
+  }, [loading, setLoadingState]);
+};
+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
+});
+createContext(createInitialValue());
+var CartContext = createContext(null);
+function CartProvider({
+  children,
+  // swrOptions,
+  autoFreeGiftConfig,
+  gradientGiftsConfig,
+  profile,
+  customer,
+  locale,
+  metafieldIdentifiers,
+  memberSetting
+}) {
+  const { client, cartCookieAdapter } = useShopify();
+  const [customAttributes, setCustomAttributes] = useState([]);
+  const [isCodeChanging, setIsCodeChanging] = useState(false);
+  const [loadingState, setLoadingState] = useState({
+    editLineQuantityLoading: false,
+    editLineCodeAmountLoading: false,
+    listingAutoCodeApplying: false,
+    userCodeApplying: false
+  });
+  const [scriptAutoFreeGift, setScriptAutoFreeGift] = useState([]);
+  const [functionAutoFreeGift, setFunctionAutoFreeGift] = useState([]);
+  const {
+    run: fetchCart,
+    data: cart,
+    loading: isCartLoading,
+    mutate: mutateCart
+  } = useRequest(
+    async () => {
+      return getCart(client, {
+        cookieAdapter: cartCookieAdapter,
+        metafieldIdentifiers
+      });
+    },
+    {
+      refreshDeps: [locale]
+    }
+  );
+  const { trigger: updateAttributes } = useUpdateCartAttributes(mutateCart, metafieldIdentifiers);
+  const { attributes } = useCartAttributes({ profile, customer, cart, memberSetting });
+  useRequest(
+    () => {
+      const newAttributes = [...attributes, ...customAttributes];
+      const needUpdate = cart && !isAttributesEqual(cart.customAttributes, newAttributes);
+      if (needUpdate) {
+        return updateAttributes({ attributes: newAttributes });
+      } else {
+        return Promise.resolve(cart);
+      }
+    },
+    {
+      throttleWait: 1e3,
+      // 1 秒内只触发最后一次更新
+      throttleTrailing: true,
+      throttleLeading: false,
+      refreshDeps: [attributes, customAttributes]
+    }
+  );
+  useUpdateLineCodeAmountAttributes({
+    cart,
+    mutateCart,
+    isCartLoading: isCartLoading || isCodeChanging,
+    setLoadingState
+  });
+  const removeCustomAttributes = useCallback((attributes2) => {
+    setCustomAttributes(
+      (prev) => prev.filter((attr) => !attributes2.some((a) => a.key === attr.key))
+    );
+  }, []);
+  const addCustomAttributes = useCallback(
+    (attributes2) => {
+      const sameAttributes = attributes2.filter(
+        (attr) => customAttributes.some((a) => a.key === attr.key)
+      );
+      if (sameAttributes.length) {
+        setCustomAttributes((prev) => {
+          const removedAttributes = prev.filter(
+            (attr) => !sameAttributes.some((a) => a.key === attr.key)
+          );
+          return [...removedAttributes, ...attributes2];
+        });
+      } else {
+        setCustomAttributes((prev) => [...prev, ...attributes2]);
+      }
+    },
+    [customAttributes]
+  );
+  const functionAutoFreeGiftResult = useCalcAutoFreeGift(cart, autoFreeGiftConfig || [], customer);
+  const scriptAutoFreeGiftResult = useScriptAutoFreeGift({
+    campaign: gradientGiftsConfig || null,
+    _giveaway: CUSTOMER_SCRIPT_GIFT_KEY,
+    cart
+  });
+  const formattedScriptGifts = useMemo(() => {
+    return formatScriptAutoFreeGift({
+      scriptAutoFreeGiftResult,
+      gradient_gifts: gradientGiftsConfig,
+      locale
+    });
+  }, [scriptAutoFreeGiftResult, gradientGiftsConfig, locale]);
+  const formattedFunctionGifts = useMemo(() => {
+    return formatFunctionAutoFreeGift({
+      qualifyingGift: functionAutoFreeGiftResult?.qualifyingGift || null,
+      giftProductsResult: functionAutoFreeGiftResult?.giftProductsResult || [],
+      locale
+    });
+  }, [functionAutoFreeGiftResult, locale]);
+  useEffect(() => {
+    if (loadingState.userCodeApplying || loadingState.editLineQuantityLoading || loadingState.editLineCodeAmountLoading || loadingState.listingAutoCodeApplying) {
+      return;
+    }
+    setScriptAutoFreeGift(formattedScriptGifts);
+    setFunctionAutoFreeGift(formattedFunctionGifts);
+  }, [
+    formattedScriptGifts,
+    formattedFunctionGifts,
+    loadingState.userCodeApplying,
+    loadingState.editLineQuantityLoading,
+    loadingState.editLineCodeAmountLoading,
+    loadingState.listingAutoCodeApplying
+  ]);
+  const giftNeedAddToCartLines = useMemo(() => {
+    const cartGiftLineItems = cart?.lineItems.filter(
+      (line) => line.customAttributes?.some(
+        (attr) => [CUSTOMER_ATTRIBUTE_KEY, CUSTOMER_SCRIPT_GIFT_KEY].includes(attr.key)
+      )
+    );
+    const result = [...scriptAutoFreeGift, ...functionAutoFreeGift].filter(
+      (item) => (
+        // 如果购物车中已经存在对应赠品，且标记了 function 满赠的属性，则不添加
+        !cartGiftLineItems?.find((line) => {
+          return line.variantId === item.line.variantId && line.customAttributes?.some((attr) => {
+            if (attr.key === "_discounts_function_env") {
+              return getDiscountEnvAttributeValue(line.customAttributes).is_gift;
+            }
+            return false;
+          });
+        })
+      )
+    );
+    return result;
+  }, [cart?.lineItems, scriptAutoFreeGift, functionAutoFreeGift]);
+  const value = useMemo(
+    () => ({
+      cart,
+      isCartLoading,
+      triggerFetch: fetchCart,
+      mutateCart,
+      addCustomAttributes,
+      removeCustomAttributes,
+      setCustomAttributes,
+      locale,
+      isCodeChanging,
+      setIsCodeChanging,
+      autoFreeGiftConfig,
+      setLoadingState,
+      loadingState,
+      // function满赠
+      functionAutoFreeGift,
+      functionAutoFreeGiftResult,
+      setFunctionAutoFreeGift,
+      // script满赠
+      scriptAutoFreeGift,
+      scriptAutoFreeGiftResult,
+      setScriptAutoFreeGift,
+      giftNeedAddToCartLines,
+      metafieldIdentifiers
+    }),
+    [
+      cart,
+      isCartLoading,
+      fetchCart,
+      mutateCart,
+      addCustomAttributes,
+      removeCustomAttributes,
+      locale,
+      isCodeChanging,
+      autoFreeGiftConfig,
+      loadingState,
+      // function满赠
+      functionAutoFreeGift,
+      functionAutoFreeGiftResult,
+      setFunctionAutoFreeGift,
+      // script满赠
+      scriptAutoFreeGift,
+      scriptAutoFreeGiftResult,
+      setScriptAutoFreeGift,
+      giftNeedAddToCartLines,
+      metafieldIdentifiers
+    ]
+  );
+  return /* @__PURE__ */ jsx(CartContext.Provider, { value, children });
+}
+function useCartContext() {
+  const context = useContext(CartContext);
+  if (!context) {
+    throw new Error("useCartContext must be used within a CartProvider");
+  }
+  return context;
+}
+
+export { CartProvider, ShopifyContext, ShopifyProvider, useCartContext, useShopify };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map