@anker-in/lib 1.1.0 → 1.1.1

package/src/cart/track/gtm.ts

@@ -0,0 +1,159 @@
+// GA 埋点
+import { Decimal } from 'decimal.js'
+
+import { AddToCartLineItems, BuyNowLineItems, GtmParams } from '../types'
+import { Cart } from '../../shopify/types/cart'
+import { getQuery } from '../utils'
+
+declare global {
+  interface Window {
+    dataLayer?: any[]
+    gtag?: (...args: any) => void
+  }
+}
+
+export const gaTrack = (data: any) => {
+  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.log('pageGTMEvent error', error)
+  }
+}
+
+export const addToCartGa = ({
+  lineItems = [],
+  gtmParams = {},
+}: {
+  lineItems: AddToCartLineItems
+  gtmParams?: GtmParams
+}) => {
+  if (!lineItems.length) {
+    return
+  }
+
+  const { variant } = lineItems[0]
+
+  const currencyCode = variant?.price?.currencyCode
+  const totalPrice = lineItems?.reduce(
+    (prev, { variant }) => new Decimal(prev || 0).plus(variant?.price?.amount || 0).toNumber(),
+    0
+  )
+
+  const searchTerm = getQuery().searchTerm
+
+  gaTrack({
+    event: 'ga4Event',
+    event_name: 'add_to_cart',
+    event_parameters: {
+      page_group: gtmParams?.pageGroup,
+      currency: currencyCode,
+      value: totalPrice, // Total price after discount
+      position: gtmParams?.position || '', // Module name
+      ...(searchTerm && {
+        // 站内搜索参数
+        search_term: searchTerm,
+        item_list_name: 'innersite_search',
+      }),
+      items: lineItems?.map(({ variant, quantity }) => ({
+        item_id: variant?.sku,
+        item_name: variant?.product?.title || variant?.product?.name,
+        item_brand: gtmParams?.brand || '',
+        item_category: variant?.product?.productType || '',
+        item_variant: variant?.title || variant?.name,
+        price: variant?.finalPrice?.amount ?? variant?.price?.amount, // Product unit price
+        quantity: quantity || 1,
+      })),
+      ...gtmParams?.ga4Params,
+    },
+  })
+}
+
+export const buyNowGa = ({ lineItems = [], gtmParams = {} }: { lineItems: BuyNowLineItems; gtmParams?: GtmParams }) => {
+  if (!lineItems.length) {
+    return
+  } else {
+    const currencyCode = lineItems[0].variant.price.currencyCode
+    const totalPrice = lineItems?.reduce(
+      (prev, lineItem) =>
+        new Decimal(prev || 0)
+          .plus(lineItem?.finalPrice?.amount ?? (lineItem?.variant.price.amount || 0))
+          .mul(lineItem.quantity || 1)
+          .toNumber(),
+      0
+    )
+    const searchTerm = getQuery().searchTerm
+    gaTrack({
+      event: 'ga4Event',
+      event_name: 'begin_checkout',
+      value: totalPrice, // Total price after discount
+      event_parameters: {
+        ...(searchTerm && {
+          search_term: searchTerm, // Use query directly
+          item_list_name: 'innersite_search',
+        }),
+        position: gtmParams?.position,
+        page_group: gtmParams.pageGroup,
+        currency: currencyCode,
+        value: totalPrice, // Total price after discount
+        items: lineItems?.map(lineItem => ({
+          item_id: lineItem.variant.sku,
+          item_name: lineItem.variant.product.title,
+          item_brand: lineItem.variant.product.vendor || gtmParams?.brand || '',
+          item_category: lineItem.variant.product.productType,
+          item_variant: lineItem.variant.title,
+          price: lineItem.finalPrice?.amount || lineItem.variant.price.amount, //产品单价
+          quantity: lineItem.quantity || 1,
+        })),
+        ...gtmParams.ga4Params,
+      },
+    })
+  }
+}
+
+export const cartCheckoutGa = ({ cart, gtmParams = {} }: { cart: Cart; gtmParams?: GtmParams }) => {
+  if (!cart?.lineItems.length) {
+    return
+  }
+
+  gaTrack({
+    event: 'ga4Event',
+    event_name: 'begin_checkout',
+    event_parameters: {
+      page_group: gtmParams?.pageGroup,
+      position: 'Cart Pop Up_Checkout',
+      currency: cart?.currency?.code,
+      value: cart?.totalPrice,
+      items: cart?.lineItems.map(product => {
+        const variant = product?.variant
+        return {
+          item_id: variant?.sku,
+          item_name: product?.name,
+          item_variant: variant?.title,
+          price: variant?.price,
+          quantity: product?.quantity || 1,
+        }
+      }),
+    },
+  })
+}
+
+export function gaNormalClick({ position, label }: { position: string; label: string }) {
+  gaTrack({
+    event: 'ga4Event',
+    event_name: 'lp_button',
+    event_parameters: {
+      page_group: 'soundcoreCredits Rewards Program',
+      position: position,
+      button_name: label,
+    },
+  })
+}

package/src/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/cart/types/index.ts

@@ -19,6 +19,7 @@ export type BuyNowLineItems = Array<{
 }>
 
 export type GtmParams = {
+  brand?: string // ga4 brand
   position?: string // ga4 position
   pageGroup?: string // ga4 pageGroup
   ga4Params?: Record<string, any> // ga4 额外埋点字段

package/src/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/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/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
+}