@anker-in/campaign-ui 0.5.16 → 0.5.19

package/src/lib/cart/types/autoFreeGift.ts

@@ -0,0 +1,169 @@
+import { ProductVariant } from '../../shopify/types/product'
+import { Product } from '../../shopify/types'
+import { LineItem } from '../../shopify/types/cart'
+
+export type AutoFreeGift = {
+  currentTier: {
+    amount: number
+    gift?: ProductVariant
+  }
+  nextTierGoal: {
+    amount: number
+    gift?: ProductVariant
+  }
+}
+
+export type DiscountLabel = {
+  cart_checkout_label: string
+  product_label: string
+  sold_out_label: string
+}
+
+export type AutoFreeGiftMainProduct = {
+  spend_money_type: number
+  variant_id_list: string[]
+  all_store_variant: boolean
+}
+
+export type GiftProduct = {
+  spend_sum_money: number
+  gift_type: number
+  reward_list: {
+    get_unit: number
+    variant_id: string
+    bak_variant_id_list: null
+  }[]
+}
+
+export type AutoFreeGiftConfig = Config[]
+
+// 定义规则条件类型
+export type RuleCondition = {
+  with_special_url_params: string[] // 包含特殊URL参数
+  without_special_url_params: string[] // 不包含特殊URL参数
+  with_user_tags: string[] // 包含用户标签
+  without_user_tags: string[] // 不包含用户标签
+}
+
+// main_product
+export type MainProductInfo = {
+  spend_money_type: SpendMoneyType
+  variant_list: VariantItem[]
+  all_store_variant: boolean
+}
+
+// 定义配置类型 - 根据JSON结构更新
+export type Config = {
+  // 规则ID
+  rule_id: number
+  // 规则类型
+  rule_type: RuleType
+  // 折扣标签
+  discount_label: {
+    cart_checkout_label: string
+    product_label: string
+    sold_out_label: string
+  }
+  // 前端标签
+  frontend_labels: { key: string; label: string; desc: string }[]
+  // 应用单位
+  apply_unit: number
+  // 规则结果
+  rule_result: {
+    // 购买规则类型
+    buy_rule_type: BuyRuleType
+    // 花费获取奖励
+    spend_get_reward: {
+      // 主产品
+      main_product: MainProductInfo
+      // 礼品产品
+      gift_product: GiftProductItem[]
+    }
+    // 买赠奖励
+    buy_get_reward: {
+      // 主产品
+      main_product: MainProductInfo
+      // 礼品产品
+      gift_product: GiftProductItem[] | null
+    }
+  }
+  // 规则条件
+  rule_conditions?: RuleCondition[]
+}
+
+export interface GiftTier {
+  spend_sum_money: number // 消费门槛金额
+  gift_type: number // 礼品类型
+  reward_list: RewardItem[] // 满足此门槛后可获得的奖励列表
+}
+
+export interface RewardItem {
+  get_unit: number // 获得单位
+  variant_list: VariantItem[] // 变体列表
+}
+
+export interface VariantItem {
+  variant_id: string // 变体ID
+  sku: string // 库存单位
+  handle: string // 处理标识
+  discount_value: number // 折扣值
+}
+
+export interface GiftProductItem {
+  spend_sum_money: number // 消费总金额
+  gift_type: number // 礼品类型
+  reward_list: RewardItem[] // 奖励列表
+}
+
+export enum RuleType {
+  AUTO_FREE_GIFT = 1, // 自动赠品
+  BUNDLE = 2, // 组合
+  VOLUME_DISCOUNT = 3, // 量价折扣
+  ORDER_DISCOUNT = 4, // 订单折扣
+  PRICE_DISCOUNT = 5, // 价格折扣
+}
+
+export enum BuyRuleType {
+  BUY_GET_GIFT = 1, // 买赠
+  SPEND_GET_GIFT = 2, // 满赠
+}
+
+export enum SpendMoneyType {
+  ORIGIN_PRICE = 1, // 原价
+  DISCOUNT_PRICE = 2, // 折扣价
+}
+
+// calcAutoFreeGift
+// 计算型 Hook 的返回类型
+export interface FunctionGiftResult {
+  qualifyingGift: FormattedGift | null // 当前应得的赠品
+  nextTierGoal: GiftTier | null // 下一个目标阶梯
+  activeCampaign: Config | null // 当前生效的活动配置
+  isLoading: boolean // 依赖数据是否加载中
+  giftProductsResult?: Product[] | []
+}
+
+// 格式化后的赠品信息，用于添加购物车
+export interface FormattedGift {
+  tier: GiftTier // 原始阶梯信息
+  itemsToAdd: CartLineInput[] // 准备好添加购物车的商品列表
+}
+
+// 购物车行项目输入类型 (Shopify API)
+export interface CartLineInput {
+  variant: {
+    id: string
+    handle: string
+    sku: string
+  }
+  quantity: number
+  attributes: { key: string; value: string }[]
+}
+
+// cart context AutoFreeGift
+export type AutoFreeGiftItem = {
+  line: LineItem
+  isSoldOut: boolean
+}
+
+export type AutoFreeGiftList = AutoFreeGiftItem[] | []

package/src/lib/cart/types/index.ts

@@ -0,0 +1,26 @@
+import { Attributes } from '../../shopify'
+import { ProductVariant, ProductPrice } from '../../shopify'
+
+export type AddToCartLineItems = Array<{
+  variant: ProductVariant
+  variantId?: string // 兼容老数据
+  quantity: number
+  finalPrice?: ProductPrice
+  attributes?: Attributes
+  sellingPlanId?: string
+}>
+
+export type BuyNowLineItems = Array<{
+  variant: ProductVariant
+  quantity: number
+  finalPrice?: ProductPrice
+  attributes?: Attributes
+  sellingPlanId?: string
+}>
+
+export type GtmParams = {
+  brand?: string // ga4 brand
+  position?: string // ga4 position
+  pageGroup?: string // ga4 pageGroup
+  ga4Params?: Record<string, any> // ga4 额外埋点字段
+}

package/src/lib/cart/types/orderDiscount.ts

@@ -0,0 +1,38 @@
+import { RuleCondition } from './autoFreeGift'
+
+export enum DiscountType {
+  PERCENTAGE = 1, // 百分比折扣
+  FIXED_AMOUNT = 2, // 固定金额折扣
+  REDUCE_PRICE = 3, // 降低指定价格
+}
+
+export enum BasePriceType {
+  ORIGIN_PRICE = 1, // 原价
+  MIN_DISCOUNTED_PRICE = 2, // 最低折扣价
+}
+
+export type TieredDiscount = {
+  amount: number // 消费门槛金额
+  discount: number // 折扣金额
+  discount_type: DiscountType // 折扣类型
+}
+
+export type OrderDiscountConfig = {
+  rule_id: number
+  rule_type: number
+  rule_conditions?: RuleCondition[]
+  result_detail: {
+    main_product: {
+      variant_list: Array<{
+        variant_id: string
+        sku: string
+        handle: string
+      }>
+      all_store_variant: boolean
+    }
+    order_discount_conf: {
+      base_price: BasePriceType
+      tiered_discounts: TieredDiscount[]
+    }
+  }
+}

package/src/lib/cart/types/priceDiscount.ts

@@ -0,0 +1,21 @@
+export enum DiscountType {
+  PERCENTAGE = 1, // 百分比折扣
+  FIXED_AMOUNT = 2, // 固定金额折扣
+}
+
+export enum BasePriceType {
+  MIN_DISCOUNTED_PRICE = 1, // 最低折扣价
+  MIN_TOTAL_PRICE = 2, // 最低总价
+}
+
+export type PriceDiscountConfig = {
+  rule_id: number
+  rule_type: number
+  discount_type: DiscountType
+  discount_value: number
+  base_price_type: BasePriceType
+  applicable_products: Array<{
+    product_id: string
+    variant_id?: string
+  }>
+}

package/src/lib/cart/utils/autoFreeGift.ts

@@ -0,0 +1,297 @@
+import { AutoFreeGiftMainProduct, SpendMoneyType, RuleCondition, FormattedGift } from '../types/autoFreeGift'
+import { CUSTOMER_ATTRIBUTE_KEY } from '../../shopify/utils/const'
+import { atobID } from '../../shopify/utils/helper'
+import { UseScriptAutoFreeGiftResult } from '../hooks/feature/useScriptAutoFreeGift'
+import Cookies from 'js-cookie'
+import Decimal from 'decimal.js'
+import { Product } from '../../shopify/types'
+import { getQuery } from '../utils'
+
+export const getMatchedMainProductSubTotal = (
+  cartData: any,
+  variant_list: AutoFreeGiftMainProduct['variant_id_list'],
+  main_product: AutoFreeGiftMainProduct
+) => {
+  const isAllStoreVariant = main_product?.all_store_variant ?? false
+  const matchedList = cartData?.lineItems?.filter((line: any) => {
+    // 包含在主商品列表中
+    const { is_gift } = getDiscountEnvAttributeValue(line.customAttributes) // 获取折扣环境属性值
+    return isAllStoreVariant
+      ? !is_gift
+      : variant_list?.find((item: any) => {
+          return !is_gift && atobID(line.variantId) === item
+        })
+  })
+  return (
+    matchedList?.reduce((acc: number, line: any) => {
+      return (
+        acc +
+        (main_product?.spend_money_type === SpendMoneyType.ORIGIN_PRICE
+          ? Number(line.subtotalAmount) || 0
+          : Number(line.totalAmount) || 0)
+      )
+    }, 0) || 0 // 计算总金额
+  )
+}
+
+export const getDiscountEnvAttributeValue = (
+  // 函数接受一个名为 attributes 的参数，其类型为包含 key 和 value 字符串属性的对象数组，默认值为空数组
+  attributes: { key: string; value: string }[] = []
+) => {
+  // 在 attributes 数组中查找 key 值等于 CUSTOMER_ATTRIBUTE_KEY 的对象，并将其赋值给 attr 变量
+  const attr = attributes.find(attr => attr.key === CUSTOMER_ATTRIBUTE_KEY)
+  // 尝试解析 attr 对象的 value 属性为 JSON，如果解析失败或 attr 不存在，则返回一个空对象
+  return safeParseJson(attr?.value ?? '') ?? {}
+}
+
+export const safeParseJson = (str: string) => {
+  try {
+    return JSON.parse(str)
+  } catch (err) {
+    return {}
+  }
+}
+
+/**
+ * 检查 source 数组是否包含 requiredItems 数组中的所有元素。
+ * @param source - 源数据数组，例如用户的标签列表。
+ * @param requiredItems - 必须包含的项的数组。
+ * @returns boolean
+ */
+const containsAll = (source: string[], requiredItems: string[] = []): boolean => {
+  // 如果没有必须包含的项，则条件默认满足。
+  if (!requiredItems?.length) return true
+
+  const sourceSet = new Set(source)
+  // 检查每一个 requiredItem 是否都存在于 sourceSet 中。
+  return requiredItems.every(item => sourceSet.has(item))
+}
+
+/**
+ * 检查 source 数组是否不包含 forbiddenItems 数组中的任何元素。
+ * @param source - 源数据数组。
+ * @param forbiddenItems - 禁止包含的项的数组。
+ * @returns boolean
+ */
+const containsNone = (source: string[], forbiddenItems: string[] = []): boolean => {
+  // 如果没有禁止的项，则条件默认满足。
+  if (!forbiddenItems?.length) return true
+
+  const sourceSet = new Set(source)
+  // 只要在 sourceSet 中找到任何一个 forbiddenItem，条件就不满足。
+  return !forbiddenItems.some(item => sourceSet.has(item))
+}
+
+export function preCheck(rule_conditions: RuleCondition[], userTags: string[], currentDealsTypes: string[]): boolean {
+  // 1. 处理边界情况 (Guard Clauses)，保持不变
+  if (!Array.isArray(rule_conditions)) return false
+  if (rule_conditions.length === 0) return true
+
+  // 2. 使用 .some() 替代 for...of 循环和 break
+  // .some() 会在找到第一个满足条件的元素后立即返回 true，并停止遍历，
+  // 这完美地复刻了 for + break 的行为。
+  return rule_conditions.some(rule => {
+    // 检查标签条件是否满足
+    const tagsAreValid = containsAll(userTags, rule.with_user_tags) && containsNone(userTags, rule.without_user_tags)
+
+    // 检查URL参数条件是否满足
+    const paramsAreValid =
+      containsAll(currentDealsTypes, rule.with_special_url_params) &&
+      containsNone(currentDealsTypes, rule.without_special_url_params)
+
+    // 只有当两个条件都满足时，此规则才算匹配
+    return tagsAreValid && paramsAreValid
+  })
+}
+
+// 缓存上一次的结果，避免重复计算
+let formatScriptAutoFreeGiftCache: {
+  key: string
+  result: any[]
+} | null = null
+
+export const formatScriptAutoFreeGift = ({
+  scriptAutoFreeGiftResult,
+  gradient_gifts,
+  locale,
+}: {
+  scriptAutoFreeGiftResult: UseScriptAutoFreeGiftResult
+  gradient_gifts: any
+  locale: string
+}) => {
+  // 生成缓存键，用于判断输入是否发生变化
+  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(product => product.handle === item.handle)
+        const variant = product?.variants?.find((v: any) => v.sku === item.sku)
+
+        const query = getQuery()
+        const utmCampaign = Cookies.get('utm_campaign') || (query as any)?.utm_campaign
+        const addUTMFreeItem =
+          gradient_gifts.activityAvailableQuery && utmCampaign?.includes(gradient_gifts.activityAvailableQuery)
+
+        let points_subscribe = false
+        if (locale === 'au') {
+          const isPointsSubscribe = Cookies.get('points_subscribe')
+          points_subscribe = !!isPointsSubscribe
+        }
+
+        const customAttributes: { key: string; value: string }[] = [
+          {
+            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 as any)?.name || (product as any)?.title || '',
+          quantity: 1,
+          discounts: [],
+          path: product?.handle || '',
+          variant: variant,
+          totalAmount: 0,
+          subtotalAmount: new Decimal(variant?.price || 0).toNumber(),
+          options: [],
+          discountAllocations: [],
+          product: product,
+          customAttributes,
+          freeGiftVariant: undefined,
+          relatedVariant: undefined,
+        } as any
+
+        return {
+          line,
+          isSoldOut: !variant?.availableForSale,
+        }
+      }) || []
+
+  // 缓存结果
+  formatScriptAutoFreeGiftCache = {
+    key: cacheKey,
+    result: result,
+  }
+
+  return result
+}
+
+// 缓存上一次的结果，避免重复计算
+let formatFunctionAutoFreeGiftCache: {
+  key: string
+  result: any[]
+} | null = null
+
+export const formatFunctionAutoFreeGift = ({
+  qualifyingGift,
+  giftProductsResult,
+  locale,
+}: {
+  locale: string
+  qualifyingGift?: FormattedGift | null
+  giftProductsResult?: Product[] | []
+}) => {
+  // 生成缓存键，用于判断输入是否发生变化
+  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(product => product.handle === item.variant.handle)
+      const variant = product?.variants?.find(v => v.sku === item.variant.sku)
+      console.log('qualifyingGift variant', product, variant)
+
+        const line = {
+          id: product?.id + '_' + index,
+          variantId: String(variant?.id),
+          productId: String(product?.id),
+          name: (product as any)?.name || (product as any)?.title || '',
+          quantity: 1,
+          discounts: [],
+          path: product?.handle || '',
+          variant: variant,
+          totalAmount: 0,
+          subtotalAmount: new Decimal(variant?.price || 0).toNumber(),
+          options: [],
+          discountAllocations: [],
+          product: product,
+          customAttributes: item.attributes,
+          freeGiftVariant: undefined,
+          relatedVariant: undefined,
+        } as any
+      return {
+        line,
+        isSoldOut: !variant?.availableForSale,
+      }
+    }) || []
+
+  // 缓存结果
+  formatFunctionAutoFreeGiftCache = {
+    key: cacheKey,
+    result: result,
+  }
+
+  return result
+}

package/src/lib/cart/utils/index.ts

@@ -0,0 +1,35 @@
+import { Attributes } from '../../shopify'
+
+export const isAttributesEqual = (oldAttributes: Attributes, newAttributes: Attributes) => {
+  // 比对两个数据是否完全相同
+  // 检查数组长度是否相同
+  if (oldAttributes?.length !== newAttributes?.length) {
+    return false
+  }
+
+  // 将数组转换为 Map 以便快速查找
+  const oldMap = new Map(oldAttributes.map(attr => [attr.key, attr.value]))
+  const newMap = new Map(newAttributes.map(attr => [attr.key, attr.value]))
+
+  // 检查所有 key 是否都存在且值相同
+  for (const [key, value] of newMap) {
+    if (!oldMap.has(key) || oldMap.get(key) !== value) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export const getQuery = (): Record<string, string> => {
+  const url = typeof window !== 'undefined' ? window.location.search : '' //获取url中"?"符后的字串
+  const theRequest: Record<string, string> = {}
+  if (url.indexOf('?') != -1) {
+    const str = url.substr(1),
+      strs = str.split('&')
+    for (let i = 0; i < strs.length; i++) {
+      theRequest[strs[i].split('=')[0]] = decodeURIComponent(strs[i].split('=')[1])
+    }
+  }
+  return theRequest
+}

package/src/lib/constants.ts

@@ -0,0 +1 @@
+export const ROUNDED_BRANDS = ['eufy', 'soundcore']

package/src/lib/context/HeadlessProvider.tsx

@@ -0,0 +1,30 @@
+import { createContext, useContext, useMemo, ReactNode } from 'react'
+
+import { HeadlessConfig } from './config'
+
+const HeadlessContext = createContext<HeadlessConfig | null>(null)
+
+interface HeadlessProviderProps {
+  children: ReactNode
+  headlessConfig: HeadlessConfig
+}
+
+export const HeadlessProvider = ({ children, headlessConfig }: HeadlessProviderProps): JSX.Element => {
+  const contextValue = useMemo((): HeadlessConfig => {
+    if (!headlessConfig) {
+      throw new Error(`No site configuration or headless configuration found`)
+    }
+
+    return headlessConfig
+  }, [headlessConfig])
+
+  return <HeadlessContext.Provider value={contextValue}>{children}</HeadlessContext.Provider>
+}
+
+export const useHeadlessContext = (): HeadlessConfig => {
+  const context = useContext(HeadlessContext)
+  if (!context) {
+    throw new Error('useHeadlessContext must be used within a HeadlessProvider')
+  }
+  return context || ({} as HeadlessConfig)
+}

package/src/lib/context/config.ts

@@ -0,0 +1,12 @@
+export type HeadlessConfig = {
+  storefrontToken: string
+  storeDomain: string
+  locale: string
+  comboMetafieldsNamespace: string
+  cartIdCookieName: string
+  brand: string
+  appName: string
+  passportUrl: string
+  currencyCode?: string
+  recaptchaSitekey?: string
+}

package/src/lib/context/index.ts

@@ -0,0 +1,2 @@
+export * from './HeadlessProvider'
+export * from './config'

package/src/lib/index.ts

@@ -0,0 +1,11 @@
+export * from './context'
+
+export * from './shopify'
+
+export * from './cart'
+
+export * from './utils'
+
+export * from './registration'
+
+export * from './constants'

package/src/lib/registration/hooks/index.ts

@@ -0,0 +1,3 @@
+export * from './useSendEmailValidation'
+export * from './useEmailValidation'
+export * from './useSubscriptions'

package/src/lib/registration/hooks/useEmailValidation.ts

@@ -0,0 +1,28 @@
+import useSWRMutation, { SWRMutationConfiguration } from 'swr/mutation'
+import { useHeadlessContext } from '../../context'
+import { fetcher } from '../../utils'
+
+export const useEmailValidation = (
+  config?: SWRMutationConfiguration<
+    any,
+    { type: 'responseError'; data: any; response: any },
+    string,
+    { token: string; code: string }
+  >
+) => {
+  const { locale } = useHeadlessContext()
+  return useSWRMutation(
+    'emailValidation',
+    (_, { arg: { token, code } }: { arg: { token: string; code: string } }) => {
+      return fetcher({
+        url: `/api/multipass/account/users/email_validation`,
+        method: 'POST',
+        body: { activation_code: token, verify_code: code },
+        action: 'account',
+        needRecaptcha: true,
+        locale,
+      })
+    },
+    config
+  )
+}