@anker-in/campaign-ui 0.2.10-beta.2 → 0.2.10-beta.21

package/src/shopify/utils/const.ts

@@ -1,115 +0,0 @@
-// 购物车数据来源
-export enum CartDataSource {
-  Storefront = 'storefront',
-  Theme = 'theme',
-}
-
-export const REVALIDATE_TIME = 60 * 5
-
-export const SOLD_OUT_PRICE = 9999999.99
-
-export enum TemplateType {
-  Page = 'page',
-  Product = 'product',
-  Collection = 'collection',
-  Blog = 'blog',
-  Article = 'article',
-}
-
-export enum DiscountType {
-  fixedAmount = 'fixed_amount',
-  percentage = 'percentage',
-}
-
-// 工具函数：根据配置生成常量
-export const createConstants = (config: {
-  env: string
-  brand: string
-  locales: string[]
-  googleClientId?: string
-  facebookAppId?: string
-  applicationName?: string
-}) => {
-  const { env, brand, locales, googleClientId, facebookAppId, applicationName } = config
-
-  return {
-    locales,
-    env,
-    applicationName: applicationName ? JSON.parse(applicationName) : undefined,
-    host: env === 'production' ? `www.${brand}.com` : `beta.${brand}.com`,
-    brand,
-    googleClientId,
-    facebookAppId,
-  }
-}
-
-
-export const COLOR_LABEL = [
-  'color',
-  'colour',
-  'couleur',
-  'cor',
-  'colore',
-  'farbe',
-  '색',
-  '色',
-  'カラー',
-  'färg',
-  'farve',
-]
-
-export enum CouponChannel {
-  LIGHTNING_DEAL = 'LIGHTNING_DEAL',
-  DEAL = 'LIGHTNING_DEAL',
-  COUPON = 'COUPON',
-  PED = 'PED',
-  WS24 = 'WS24',
-  WSTD = 'WSTD',
-  WSCH = 'WSCH',
-}
-
-export const PRICE_SYMBOL = {
-  us: '$',
-  uk: '£',
-  ca: '$',
-  eu: '€',
-  pl: 'zł',
-  fr: '€',
-  de: '€',
-  vn: '₫',
-  cl: '$',
-  sg: '$',
-  ae: 'AED',
-  es: '€',
-}
-
-export const CURRENCY_CODE = {
-  us: 'USD',
-  uk: 'GBP',
-  ca: 'CAD',
-  eu: 'EUR',
-  pl: 'PL',
-  fr: 'EUR',
-  de: 'EUR',
-  vn: 'VND',
-  cl: 'CLP',
-  es: 'EUR',
-}
-
-export const COUNTRY_CODE = {
-  pl: 'PL',
-} as Record<string, string>
-
-export const LANGUAGE_CODE = {
-  pl: 'PL',
-} as Record<string, string>
-
-
-export const CUSTOMER_ATTRIBUTE_KEY = '_discounts_function_env'
-export const CUSTOMER_SCRIPT_GIFT_KEY = '_giveaway_gradient_gifts'
-
-export const CODE_AMOUNT_KEY = '_sku_code_money'
-export const SCRIPT_CODE_AMOUNT_KEY = '_code_money'
-
-// 主产品公开 code
-export const MAIN_PRODUCT_CODE = ['WS24', 'WSTD', 'WS7D', 'WSCP', 'WSPE', 'WSPD']

package/src/shopify/utils/cookie.ts

@@ -1,39 +0,0 @@
-import { ShopifyConfig, SiteConfig } from '@shopify/types/config'
-import Cookies from 'js-cookie'
-
-export const SHOPIFY_COOKIE_EXPIRE = 30
-export const SHOPIFY_CART_COOKIE_EXPIRE = 14
-
-// 直接根据 locale 和 domain 生成 Cookie 名称的工具函数
-export const getCookieName = (type: string, domain: string, locale: string): string => {
-  return `${type}_${domain}_${locale}`
-}
-
-// 各种 Cookie 名称生成函数
-export const getCartIdCookieName = ({
-  shopifyConfig,
-  siteConfig,
-  withLocale = true,
-}: {
-  shopifyConfig: ShopifyConfig
-  siteConfig: SiteConfig
-  withLocale?: boolean
-}): string => {
-  return `shopifyCart_${shopifyConfig.storeDomain}${withLocale ? `_${siteConfig.locale}` : ''}`
-}
-
-export const createCartCookieOptions = () => {
-  const hostUrl = window.location.host.split('.')
-  return {
-    domain: hostUrl.reverse().slice(0, 2).reverse().join('.'), // 一二级域名
-    expires: SHOPIFY_CART_COOKIE_EXPIRE,
-  }
-}
-
-export const setCartCookies = (name: string, value: string) => {
-  Cookies.set(name, value, createCartCookieOptions())
-}
-
-export const removeCartCookies = (name: string) => {
-  Cookies.remove(name, createCartCookieOptions())
-}

package/src/shopify/utils/errors.ts

@@ -1,65 +0,0 @@
-export type ErrorData = {
-  message: string
-  code?: string
-}
-
-export type ErrorProps = {
-  code?: string
-} & (
-  | { message: string; errors?: never }
-  | { message?: never; errors: ErrorData[] }
-)
-
-export class CommerceError extends Error {
-  code?: string
-  errors: ErrorData[]
-
-  constructor({ message, code, errors }: ErrorProps) {
-    const error: ErrorData = message
-      ? { message, ...(code ? { code } : {}) }
-      : errors![0]
-
-    super(error.message)
-    this.errors = message ? [error] : errors!
-
-    if (error.code) this.code = error.code
-  }
-}
-
-// Used for errors that come from a bad implementation of the hooks
-export class ValidationError extends CommerceError {
-  constructor(options: ErrorProps) {
-    super(options)
-  }
-}
-
-export class CommerceFetcherError extends CommerceError {
-  status: number
-
-  constructor(
-    options: {
-      status: number
-    } & ErrorProps
-  ) {
-    super(options)
-    this.status = options.status
-  }
-}
-
-export class FetcherError extends Error {
-  status: number
-  errors: string[]
-  errorCode: string
-  constructor(options: {
-    status: number
-    errors?: string[]
-    message?: string
-    errorCode?: string
-  }) {
-    const errorMessage = options.message || options.errors?.join('\n')
-    super(errorMessage)
-    this.status = options.status
-    this.errors = options.errors || []
-    this.errorCode = options.errorCode || ''
-  }
-}

package/src/shopify/utils/fetch-graphql-api.ts

@@ -1,67 +0,0 @@
-import fetchPonyfill from 'fetch-ponyfill'
-import { ShopifyConfig } from '@shopify/types/config'
-
-import { getCommerceError } from '../utils/handle-fetch-response'
-
-const { fetch } = fetchPonyfill()
-
-/**
- * Graphql Api 接口 fetch 方法
- * @param query: 查询语句
- * @param variables: 查询参数
- * @param config: 店铺配置
- * @returns
- */
-export async function fetchGraphqlApi<Data, Variables = undefined>({
-  query,
-  variables,
-  fetchOptions,
-  headers,
-  config,
-}: {
-  query: string
-  variables?: Variables
-  headers?: Record<string, any>
-  fetchOptions?: Omit<RequestInit, 'headers' | 'method' | 'body'>
-  config: ShopifyConfig
-}): Promise<{ status: number; data: Data; errors?: any } | never> {
-  const { storefrontToken, storeDomain } = config
-
-  let result: Response | undefined
-  try {
-    result = await fetch(`https://${storeDomain}/api/2025-07/graphql.json`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Shopify-Storefront-Access-Token': storefrontToken,
-        ...headers,
-      },
-      body: JSON.stringify({
-        ...(query && { query }),
-        ...(variables && { variables }),
-      }),
-      ...fetchOptions,
-    })
-
-    const { data, errors, status } = await result.json()
-
-    if (errors?.length) {
-      throw new Error(
-        `Status: ${status}, ${result.status}, GraphQL errors: ` +
-          errors.map(({ message }: { message: string }) => message).join(', ')
-      )
-    }
-
-    return { data, status, ...(errors && { errors }) }
-  } catch (err: any) {
-    console.error('fetchGraphqlApi url:', storeDomain, result?.status)
-    throw getCommerceError(
-      [
-        {
-          message: `status: ${result?.status}, ${err.message} \n Most likely related to an unexpected output. e.g the store might be protected with password or not available.`,
-        },
-      ],
-      500
-    )
-  }
-}

package/src/shopify/utils/handle-fetch-response.ts

@@ -1,60 +0,0 @@
-import { CommerceFetcherError, FetcherError } from './errors'
-
-export function getCommerceError(errors: any[] | null, status = 500) {
-  errors = errors ?? [{ message: 'Failed to fetch Shopify API' }]
-  return new CommerceFetcherError({ errors, status })
-}
-
-export async function getFetcherError(
-  error: string | string[],
-  statusCode: any,
-  errorCode: any
-) {
-  let message = '',
-    errors: string[] = []
-  if (typeof error === 'string') {
-    message = error
-  } else if (Array.isArray(error)) {
-    errors = error
-  }
-
-  return new FetcherError({
-    message,
-    errors,
-    status: statusCode,
-    errorCode: errorCode || '',
-  })
-}
-
-export async function getAsyncError(res: Response, responseData: any) {
-  return getFetcherError(
-    responseData?.errors ||
-      responseData?.message ||
-      (Array.isArray(responseData?.data.message)
-        ? responseData?.data.message.join('. ')
-        : responseData?.data.message) ||
-      responseData?.data?.error ||
-      res.statusText,
-    res.status,
-    responseData?.data?.error_code || ''
-  )
-}
-
-export const handleFetchResponse = async (res: Response) => {
-  const responseText = await res.text()
-  let responseData
-  let requestErrorMessage
-
-  if (responseText) {
-    try {
-      responseData = JSON.parse(responseText)
-      requestErrorMessage = responseData?.error || responseData?.data?.error
-    } catch (err) {}
-  }
-
-  if (res.ok && !requestErrorMessage) {
-    return responseData?.data || responseData
-  }
-
-  throw await getAsyncError(res, responseData)
-}

package/src/shopify/utils/helper.ts

@@ -1,89 +0,0 @@
-import { HasMetafieldsIdentifier } from '../gql'
-import { HasMetafieldQueryRoot } from '../types/fetcher'
-import { PartialRecord } from '../utils/type-helper'
-import Cookies from 'js-cookie'
-import { CouponChannel } from '../utils/const'
-import { ProductVariant } from '../types/product'
-
-// 判断对象是否为空
-export function isObjEmpty(obj?: Record<string, any>) {
-  if (!obj) return true
-  else {
-    return Object.keys(obj).length === 0
-  }
-}
-
-export function atobID(id: string) {
-  if (id && typeof id === 'string' && id.includes('/')) {
-    return id.split('/').pop()?.split('?')?.shift()
-  } else {
-    return id
-  }
-}
-
-export function btoaID(id: string, type: 'ProductVariant' | 'Product' = 'ProductVariant') {
-  return `gid://shopify/${type}/${id}`
-}
-
-// 皮肤站三级域名
-export const getThemeLocale = (locale: string) => {
-  if (locale === 'eu-de') return 'de'
-  if (locale === 'eu-en') return 'eu'
-  if (locale === 'au') return 'au'
-  return locale
-}
-
-/**
- * 生成 metafieldIdentifiers 查询参数
- * {
- *   product: { namespace: 'product', key: 'img' },
- *   variant: { namespace: 'variant', key: 'img' }
- * }
- * =>
- * {
- *  productMetafieldIdentifiers: [{ namespace: 'combo', key: 'product' }]
- *  variantMetafieldIdentifiers: [{ namespace: 'combo', key: 'variant' }]
- * }
- */
-export function constructMetafieldIdentifiersQueryParams<T extends HasMetafieldQueryRoot>(
-  metafieldIdentifiers: PartialRecord<T, HasMetafieldsIdentifier[]> = {},
-  metafieldsNamespace: string = ''
-): PartialRecord<`${T}MetafieldIdentifiers`, HasMetafieldsIdentifier[]> {
-  const identifiers = Object.entries(metafieldIdentifiers).reduce<
-    PartialRecord<`${T}MetafieldIdentifiers`, HasMetafieldsIdentifier[]>
-  >((queryInput, [key, value]) => {
-    const metafieldIdentifiers = value as HasMetafieldsIdentifier[]
-    queryInput[`${key}MetafieldIdentifiers` as `${T}MetafieldIdentifiers`] = metafieldIdentifiers
-      .filter(item => item.namespace !== metafieldsNamespace)
-      .map(item => ({
-        namespace: metafieldsNamespace,
-        key: item.namespace,
-      }))
-      .concat(metafieldIdentifiers)
-    return queryInput
-  }, {})
-  return identifiers
-}
-
-export const referralAttributes = () => {
-  const inviteCode = Cookies.get('invite_code')
-  const playModeId = Cookies.get('playModeId')
-  const popup = Cookies.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 []
-}
-
-export const getNormalCoupon = ({ variant }: { variant?: ProductVariant }) => {
-  return variant?.coupons?.find((coupon: any) => coupon.discount_type !== CouponChannel.WSCH)
-}

package/src/shopify/utils/normalize/cart.ts

@@ -1,106 +0,0 @@
-import { ProductVariant as ShopifyProductVariant, CartLine as ShopifyCartLine } from '@shopify/gql'
-import type { Cart, LineItem } from '@shopify/types/cart'
-import type { Cart as ShopifyCart } from '@shopify/gql'
-
-import { normalizeMetafields } from './metafield'
-
-export function normalizeCart(cart: ShopifyCart, metafieldNamespacePrefix: string = ''): Cart {
-  const lineItems = cart.lines?.edges?.map(item => normalizeLineItem(item, metafieldNamespacePrefix))
-  const orderDiscounts = cart?.discountAllocations?.reduce((pre, cur) => {
-    return Number(cur?.discountedAmount?.amount) + pre
-  }, 0)
-  const [totalLineItemsDiscount, lineItemsSubtotalPrice] = lineItems?.reduce(
-    ([t, l], cur) => {
-      const currentDiscount = cur?.discountAllocations?.reduce((p, c) => Number(c?.amount) + p, 0) || 0
-      return [currentDiscount + t, Number(cur?.subtotalAmount) + l]
-    },
-    [0, 0]
-  ) || [0, 0]
-
-  return {
-    customAttributes: cart.attributes,
-    totalLineItemsDiscount: orderDiscounts + totalLineItemsDiscount,
-    id: cart.id,
-    url: cart.checkoutUrl,
-    ready: true,
-    customerId: cart?.buyerIdentity?.customer?.id || '',
-    email: cart?.buyerIdentity?.email || '',
-    createdAt: cart.createdAt,
-    currency: {
-      code: cart.cost?.subtotalAmount?.currencyCode,
-    },
-    taxesIncluded: cart.cost?.totalTaxAmountEstimated,
-    lineItems: cart.lines?.edges?.map(item => normalizeLineItem(item, metafieldNamespacePrefix)),
-    subtotalPrice: cart.cost?.subtotalAmount?.amount,
-    totalPrice: cart.cost?.totalAmount?.amount - (cart.cost?.totalTaxAmount?.amount || 0),
-    // 预估税额现在逻辑没理清楚，暂时 写死为 0
-    // totalTaxAmount: cart.cost?.totalTaxAmount?.amount,
-    totalTaxAmount: 0,
-    // lineItemsSubtotalPrice: cart.cost?.subtotalAmount?.amount,
-    lineItemsSubtotalPrice,
-    discountCodes: cart.discountCodes || [],
-    discountAllocations:
-      cart?.discountAllocations?.map(item => ({
-        code: item?.code || item?.title || '',
-        amount: item?.discountedAmount?.amount,
-      })) || [],
-  }
-}
-
-export function normalizeLineItem({
-  node: { id, merchandise: variant, quantity, discountAllocations, attributes, cost },
-}: {
-  node: ShopifyCartLine
-}, metafieldNamespacePrefix: string = ''): LineItem {
-  const price = variant?.price?.amount
-  const name = variant?.product?.title
-  return {
-    id,
-    name,
-    quantity,
-    variantId: String(variant?.id),
-    productId: String(variant?.product?.id),
-    totalAmount: cost?.totalAmount?.amount,
-    subtotalAmount: cost?.subtotalAmount?.amount,
-    discountAllocations:
-      discountAllocations?.map(item => ({
-        code: item?.code || item?.title || '',
-        amount: item?.discountedAmount?.amount,
-      })) || [],
-    customAttributes:
-      attributes?.map(item => ({
-        key: item?.key || '',
-        value: item?.value || '',
-      })) || [],
-    variant: {
-      id: String(variant?.id),
-      options: [],
-      price,
-      listPrice: variant?.compareAtPrice?.amount,
-      sku: variant?.sku ?? '',
-      name: variant?.title!,
-      requiresShipping: variant?.requiresShipping ?? false,
-      availableForSale: availableVariant({
-        ...variant,
-        price: variant?.price,
-      } as unknown as ShopifyProductVariant),
-      quantityAvailable: variant?.quantityAvailable || 0,
-      currentlyNotInStock: variant?.currentlyNotInStock || false,
-      metafields: normalizeMetafields(variant.metafields, metafieldNamespacePrefix),
-    },
-    product: variant?.product as any,
-    path: `/${variant?.product?.handle}`,
-    discounts: [],
-    options: variant?.title == 'Default Title' ? [] : variant?.selectedOptions,
-  }
-}
-
-const availableVariant = (variant: ShopifyProductVariant) => {
-  //availableForSale 是否可售 true:可售
-  if (!variant.availableForSale) return false
-  //currentlyNotInStock 是否可超卖 true:是
-  //quantityAvailable 库存
-  if (!variant.quantityAvailable && !variant.currentlyNotInStock) return false
-  if (variant.price?.amount >= 9999999.99) return false
-  return true
-}

package/src/shopify/utils/normalize/customer.ts

@@ -1,18 +0,0 @@
-import { Customer } from '../../types/customer'
-import { Customer as ShopifyCustomer } from '@shopify/gql'
-
-export function normalizeCustomer(customer: ShopifyCustomer): Customer {
-  const { id, firstName, lastName, displayName, email, phone, tags, acceptsMarketing, createdAt, orders } = customer
-  return {
-    id,
-    firstName: firstName || '',
-    lastName: lastName || '',
-    displayName: displayName || '',
-    email: email || '',
-    phone: phone || '',
-    tags: tags || [],
-    acceptsMarketing: acceptsMarketing || false,
-    createdAt: createdAt || '',
-    orders: orders?.nodes?.map(order => order) || [],
-  }
-}

package/src/shopify/utils/normalize/index.ts

@@ -1,2 +0,0 @@
-export * from './cart'
-export * from './metafield'

package/src/shopify/utils/normalize/metafield.ts

@@ -1,69 +0,0 @@
-import { Maybe } from 'graphql/jsutils/Maybe'
-import { Metafield } from '../../gql'
-
-export const normalizeMetafields = (
-  metafields: Maybe<Metafield>[], 
-  metafieldNamespacePrefix: string
-): Record<string, any> => {
-  // combo namespace 的优先级低于普通namespace的优先级
-  return metafields?.reduce(
-    (prev, cur) => {
-      if (cur) {
-        let namespace = cur.namespace
-        if (namespace.startsWith(`${metafieldNamespacePrefix}combo`)) {
-          namespace = cur.key
-          prev[namespace] = prev[namespace] || {}
-
-          const parsedMetafields: {
-            [key: string]: Metafield
-          } = parseMetafield(cur)
-          if (parsedMetafields) {
-            Object.entries(parsedMetafields).forEach(([key, innerMetafields]) => {
-              prev[namespace][key] = prev[namespace][key] ?? (innerMetafields ? parseMetafield(innerMetafields) : null)
-            })
-          }
-        } else {
-          prev[namespace] = prev[namespace] || {}
-          prev[namespace][cur.key] = cur ? parseMetafield(cur) : null
-        }
-      }
-      return prev
-    },
-    {} as Record<string, any>
-  )
-}
-
-export function parseJSON(str: string) {
-  try {
-    return JSON.parse(str)
-  } catch (err) {
-    return {}
-  }
-}
-
-const parseDesc = (desc: string) => {
-  const cfg = parseJSON(desc) || {}
-  return {
-    parseType: cfg.type, // JSON_STRING
-    descContent: cfg.content || '', // 描述
-    status: cfg.status || 'Active', // 状态
-  }
-}
-
-export const parseMetafield = (metafield: Metafield) => {
-  const type = metafield?.type && metafield?.type.toLowerCase()
-  const { status } = parseDesc(metafield?.description || '')
-  if (status.toLowerCase() !== 'active') return null
-
-  switch (type) {
-    case 'json':
-    case 'json_string':
-    case 'rating':
-    case 'volume':
-    case 'weight':
-    case 'dimension':
-      return JSON.parse(metafield.value)
-    default:
-      return metafield?.value || metafield
-  }
-}