@pisell/pisellos 2.1.119 → 2.1.121

package/lib/solution/ScanOrder/types.d.ts

@@ -0,0 +1,210 @@
+import { OrderModule, ProductList, SalesSummaryModule, ScanOrderLogInput, ScanOrderLoggerModule, ScanOrderLoggerProviderConfig, ScanOrderLoggerProviderType } from '../../modules';
+import type { QuantityCheckResult, QuantityLimitResult } from '../../model/strategy/adapter/itemRule';
+/**
+ * 扫码下单流程 hook
+ */
+export declare enum ScanOrderHooks {
+    onInited = "scanOrder:onInited",
+    onDestroy = "scanOrder:onDestroy",
+    onRetryInit = "scanOrder:onRetryInit",
+    onRefresh = "scanOrder:onRefresh",
+    onCartValidationChanged = "scanOrder:onCartValidationChanged"
+}
+export type ScanOrderStatus = 'idle' | 'initializing' | 'ready' | 'error';
+export type ScanOrderEntryContext = {
+    biz: string;
+    mode: 'scan' | 'append';
+    resourceId?: string;
+    sourceOrderId?: string;
+};
+export interface ScanOrderConfig {
+    orderSource: 'local' | 'remote';
+    scanTimeout: number;
+    allowAppend: boolean;
+    maxAppendCount: number;
+    features: {
+        autoMerge: boolean;
+        verifyResource: boolean;
+    };
+}
+export interface ScanOrderOrderProductIdentity {
+    product_id: number | null;
+    product_variant_id: number;
+    identity_key?: string;
+}
+export interface ScanOrderOrderProduct extends ScanOrderOrderProductIdentity {
+    order_detail_id: number | null;
+    num: number;
+    product_option_item: any[];
+    selling_price: string;
+    original_price: string;
+    payment_price: string;
+    tax_fee: string;
+    is_charge_tax: number;
+    discount_list: any[];
+    product_bundle: any[];
+    metadata: Record<string, any>;
+    _origin?: Record<string, any>;
+}
+export interface ScanOrderSubmitProduct extends Omit<ScanOrderOrderProduct, '_origin' | 'identity_key'> {
+}
+export interface ScanOrderSummary {
+    product_quantity: number;
+    product_original_amount: string;
+    product_amount: string;
+    product_expect_amount: string;
+    product_tax_fee: string;
+    shipping_fee: string;
+    shipping_tax_fee: string;
+    tax_fee: string;
+    surcharge_fee: string;
+    discount_amount: string;
+    deposit_amount: string;
+    deposit?: {
+        total: string;
+        deposit_policy_ids: number[];
+        hasDeposit: boolean;
+    };
+    expect_amount: string;
+    total_amount: string;
+    amount_gap: string;
+    rounding_amount: string;
+    pay_service_charge_amount: string;
+    tax_title?: string;
+    tax_rate?: number;
+}
+/**
+ * ScanOrder 临时订单（runtime-clean 版本）
+ * 只保留运行时字段，不包含任何 __comment 字段
+ */
+export interface ScanOrderTempOrder {
+    order_id: number | null;
+    relation_id?: string;
+    table_form_id?: string;
+    resource_id?: string;
+    order_number: string;
+    shop_order_number: string;
+    type: string;
+    business_code: string;
+    platform: string;
+    sales_channel: string;
+    order_sales_channel: string;
+    status: string;
+    payment_status: string;
+    shipping_status: string;
+    customer_id: number | null;
+    customer_name: string;
+    country_calling_code: string;
+    phone: string;
+    email: string;
+    is_price_include_tax: number;
+    tax_title: string;
+    tax_country_code: string;
+    currency_code: string;
+    currency_symbol: string;
+    currency_format: string;
+    is_deposit: number;
+    deposit_amount: string;
+    shop_discount: string;
+    surcharge_fee: string;
+    note: string;
+    schedule_date: string;
+    created_at: string;
+    products: ScanOrderOrderProduct[];
+    bookings: any[];
+    payments: any[];
+    surcharges: any[];
+    discount_list: any[];
+    relation_forms: any[];
+    contacts: any[];
+    contacts_info: any[];
+    holder: Record<string, any> | null;
+    summary: ScanOrderSummary;
+    metadata: Record<string, any>;
+}
+export interface ScanOrderSubmitPayload extends Omit<ScanOrderTempOrder, 'platform' | 'products' | 'created_at' | 'summary' | 'surcharges'> {
+    platform: 'H5' | 'PC';
+    request_unique_idempotency_token?: string;
+    form_record_ids?: Array<{
+        form_id: number | string;
+        form_record_ids: Array<number | string>;
+    }>;
+    products: ScanOrderSubmitProduct[];
+}
+export type ScanOrderAvailabilityMode = 'idle' | 'shop_closed' | 'resource_block' | 'resource_busy' | 'additional_order_with_code' | 'additional_order';
+export interface ScanOrderAvailabilityInfo {
+    mode: ScanOrderAvailabilityMode;
+    order_id?: string;
+    relation_id?: string;
+    table_form_id?: string;
+    deskmate_valid?: boolean;
+    errorTips?: string;
+    policy?: string | null;
+    partyroom_booking?: string | null;
+}
+export interface ScanOrderTableSnackConfig {
+    snack?: boolean | number | string;
+    table_validate?: boolean | number | string;
+}
+export interface ScanOrderOrderNumberPrefixConfig {
+    table_order?: string;
+    pos?: string;
+}
+export interface ScanOrderTableFormRecord {
+    policy?: string | null;
+}
+export interface ScanOrderTableConfigApiData {
+    table_max_number?: number | string | null;
+    order_count?: number | string | null;
+    order_id?: number | string | null;
+    last_order_id?: number | string | null;
+    relation_id?: number | string | null;
+    table_form_id?: number | string | null;
+    table_snack?: ScanOrderTableSnackConfig[] | null;
+    order_number_prefix?: ScanOrderOrderNumberPrefixConfig[] | null;
+    [key: string]: any;
+}
+export interface ScanOrderTableConfigApiResponse {
+    status?: boolean;
+    code?: number;
+    message?: string;
+    data?: ScanOrderTableConfigApiData | null;
+}
+export interface ScanOrderResourceState extends ScanOrderAvailabilityInfo {
+    tableMaxNumber: number;
+    orderCount: number;
+    relationId?: string;
+    tableFormId?: string;
+    currentOrderId?: string;
+    lastOrderId?: string;
+    allowSnack: boolean;
+    deskmateValid: boolean;
+    isExclusive: boolean;
+    isFull: boolean;
+    orderNumberPrefix: ScanOrderOrderNumberPrefixConfig[];
+    raw: ScanOrderTableConfigApiData | null;
+    table_form_record?: ScanOrderTableFormRecord | null;
+}
+export interface ScanOrderState {
+    entryContext: ScanOrderEntryContext | null;
+    status: ScanOrderStatus;
+    config: ScanOrderTableConfigApiData | null;
+    resource: ScanOrderResourceState | null;
+    flow: Record<string, any>;
+    error: string | null;
+    products?: ProductList;
+    order?: OrderModule;
+    salesSummary?: SalesSummaryModule;
+    scanOrderLogger?: ScanOrderLoggerModule;
+    itemRuleQuantityLimits: QuantityLimitResult[];
+    cartValidation: {
+        passed: boolean | null;
+        failures: QuantityCheckResult[];
+    };
+}
+export interface ScanOrderLoggerRuntimeConfig {
+    provider?: ScanOrderLoggerProviderType;
+    providerConfig?: ScanOrderLoggerProviderConfig;
+}
+export interface ScanOrderAddLogParams extends ScanOrderLogInput {
+}

package/lib/solution/ScanOrder/types.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/ScanOrder/types.ts
+var types_exports = {};
+__export(types_exports, {
+  ScanOrderHooks: () => ScanOrderHooks
+});
+module.exports = __toCommonJS(types_exports);
+var ScanOrderHooks = /* @__PURE__ */ ((ScanOrderHooks2) => {
+  ScanOrderHooks2["onInited"] = "scanOrder:onInited";
+  ScanOrderHooks2["onDestroy"] = "scanOrder:onDestroy";
+  ScanOrderHooks2["onRetryInit"] = "scanOrder:onRetryInit";
+  ScanOrderHooks2["onRefresh"] = "scanOrder:onRefresh";
+  ScanOrderHooks2["onCartValidationChanged"] = "scanOrder:onCartValidationChanged";
+  return ScanOrderHooks2;
+})(ScanOrderHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScanOrderHooks
+});

package/lib/solution/ScanOrder/utils.d.ts

@@ -0,0 +1,93 @@
+import { ScanOrderOrderProduct, ScanOrderOrderProductIdentity, ScanOrderSummary, ScanOrderTempOrder } from './types';
+import type { CartItemSummary, ItemRuleBusinessData, PaxInfo, QuantityLimitResult } from '../../model/strategy/adapter/itemRule';
+import type { StrategyConfig } from '../../model/strategy/type';
+/**
+ * 构建金额全为 0 的空 summary。
+ * 作为尚未计算金额时的兜底默认值，避免下游因 undefined 报错。
+ */
+export declare function createEmptySummary(): ScanOrderSummary;
+/**
+ * 商品数量安全取值。
+ * - NaN / undefined / < 1 均视作 1（最低起订量）
+ * - 有值时取整（不支持小数数量）
+ */
+export declare function getSafeProductNum(num?: number): number;
+/**
+ * 宽松布尔值转换。
+ * 兼容后端/配置中心常见的 boolean / number / string 表达，统一归一成 true/false。
+ */
+export declare function toBoolean(value: unknown): boolean;
+/**
+ * 将值归一化为有效的正向字符串。
+ * null / undefined / 空串 / '0' / 'null' 统一视为无效值并返回 undefined。
+ */
+export declare function toPositiveString(value: unknown): string | undefined;
+/**
+ * 归一化 item rule 策略模型 ID 列表。
+ * - 支持 string / number 混合输入
+ * - 仅保留 > 0 的合法数字
+ * - 自动去重
+ */
+export declare function normalizeEnabledItemRuleIds(rawIds: unknown): number[];
+/**
+ * 从 tableConfig 中提取合法策略模型 ID 列表。
+ */
+export declare function extractStrategyModelIdsFromTableConfig(tableConfig: Record<string, any> | null | undefined): number[];
+/**
+ * 仅保留 item_rule 类型策略。
+ */
+export declare function normalizeItemRuleStrategies(configs: unknown): StrategyConfig[];
+export declare function toNonNegativeNumber(value: unknown): number;
+export declare function toNonNegativeInt(value: unknown): number;
+export declare function toPriceString(value: unknown, fallback?: string): string;
+export declare function buildProductKey(productId: number, productVariantId: number): string;
+export declare function getTopLevelProductId(product: Record<string, any>): number | null;
+export declare function getTopLevelVariantId(product: Record<string, any>): number | null;
+export declare function buildQuantityLimitIndex(limits: QuantityLimitResult[]): {
+    exactLimitMap: Map<string, QuantityLimitResult[]>;
+    productLimitMap: Map<number, QuantityLimitResult[]>;
+};
+export declare function resolveSkuMatchedQuantityLimits(params: {
+    productId: number;
+    variantId: number | null;
+    limitIndex: {
+        exactLimitMap: Map<string, QuantityLimitResult[]>;
+        productLimitMap: Map<number, QuantityLimitResult[]>;
+    };
+}): QuantityLimitResult[];
+export declare function aggregateItemRuleLimit(matchedLimits: QuantityLimitResult[]): {
+    min: number | undefined;
+    max: number | undefined;
+    exact: number | undefined;
+    mustInclude: boolean;
+} | null;
+export declare function buildItemRuleBusinessData(params: {
+    tempOrder: ScanOrderTempOrder;
+    runtimeConfig: {
+        pax?: Partial<PaxInfo>;
+        historicalItems?: CartItemSummary[];
+        serviceType?: string;
+        submissionIndex?: number;
+        custom?: Record<string, any>;
+    };
+    itemRuleConfigs: StrategyConfig[];
+}): ItemRuleBusinessData;
+export declare function attachItemRuleLimitsToTopLevelProducts<T>(productList: T, limits: QuantityLimitResult[]): T;
+/**
+ * 判断两个商品 identity 是否匹配。
+ * 当双方都没有 identity_key 时回退到 product_id + product_variant_id 比较（向后兼容）；
+ * 一旦有一方携带 identity_key，则必须严格相等。
+ */
+export declare function isIdentityMatch(a: ScanOrderOrderProductIdentity, b: ScanOrderOrderProductIdentity): boolean;
+/**
+ * 根据 identity 在商品列表中定位下标。
+ * 用于判断商品是否已存在（已存在则累加数量，否则新增）。
+ */
+export declare function getProductIdentityIndex(products: ScanOrderOrderProduct[], identity: ScanOrderOrderProductIdentity): number;
+/**
+ * 对外部传入的商品对象做归一化：
+ * - 补全可选字段默认值（未传则使用兜底值，避免后续计算时因 undefined 导致异常）
+ * - 对 num 调用 getSafeProductNum 做安全处理
+ * - 保留 _origin 供后续业务流程（如促销规则）使用
+ */
+export declare function normalizeOrderProduct(product: Partial<ScanOrderOrderProduct> & ScanOrderOrderProductIdentity): ScanOrderOrderProduct;

package/lib/solution/ScanOrder/utils.js

@@ -0,0 +1,359 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/ScanOrder/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  aggregateItemRuleLimit: () => aggregateItemRuleLimit,
+  attachItemRuleLimitsToTopLevelProducts: () => attachItemRuleLimitsToTopLevelProducts,
+  buildItemRuleBusinessData: () => buildItemRuleBusinessData,
+  buildProductKey: () => buildProductKey,
+  buildQuantityLimitIndex: () => buildQuantityLimitIndex,
+  createEmptySummary: () => createEmptySummary,
+  extractStrategyModelIdsFromTableConfig: () => extractStrategyModelIdsFromTableConfig,
+  getProductIdentityIndex: () => getProductIdentityIndex,
+  getSafeProductNum: () => getSafeProductNum,
+  getTopLevelProductId: () => getTopLevelProductId,
+  getTopLevelVariantId: () => getTopLevelVariantId,
+  isIdentityMatch: () => isIdentityMatch,
+  normalizeEnabledItemRuleIds: () => normalizeEnabledItemRuleIds,
+  normalizeItemRuleStrategies: () => normalizeItemRuleStrategies,
+  normalizeOrderProduct: () => normalizeOrderProduct,
+  resolveSkuMatchedQuantityLimits: () => resolveSkuMatchedQuantityLimits,
+  toBoolean: () => toBoolean,
+  toNonNegativeInt: () => toNonNegativeInt,
+  toNonNegativeNumber: () => toNonNegativeNumber,
+  toPositiveString: () => toPositiveString,
+  toPriceString: () => toPriceString
+});
+module.exports = __toCommonJS(utils_exports);
+function createEmptySummary() {
+  return {
+    product_quantity: 0,
+    product_original_amount: "0.00",
+    product_amount: "0.00",
+    product_expect_amount: "0.00",
+    product_tax_fee: "0.00",
+    shipping_fee: "0.00",
+    shipping_tax_fee: "0.00",
+    tax_fee: "0.00",
+    surcharge_fee: "0.00",
+    discount_amount: "0.00",
+    deposit_amount: "0.00",
+    expect_amount: "0.00",
+    total_amount: "0.00",
+    amount_gap: "0.00",
+    rounding_amount: "0.00",
+    pay_service_charge_amount: "0.00"
+  };
+}
+function getSafeProductNum(num) {
+  if (!num || Number.isNaN(num))
+    return 1;
+  if (num < 1)
+    return 1;
+  return Math.floor(num);
+}
+function toBoolean(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value !== 0;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    return ["1", "true", "yes", "y", "on"].includes(normalized);
+  }
+  return false;
+}
+function toPositiveString(value) {
+  if (value === null || value === void 0 || value === "")
+    return void 0;
+  const normalized = String(value).trim();
+  if (!normalized || normalized === "0" || normalized.toLowerCase() === "null") {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeEnabledItemRuleIds(rawIds) {
+  if (!Array.isArray(rawIds))
+    return [];
+  const uniqueIds = /* @__PURE__ */ new Set();
+  for (const item of rawIds) {
+    const strategyId = Number(item);
+    if (Number.isFinite(strategyId) && strategyId > 0) {
+      uniqueIds.add(strategyId);
+    }
+  }
+  return Array.from(uniqueIds);
+}
+function extractStrategyModelIdsFromTableConfig(tableConfig) {
+  const rawIds = Array.isArray(tableConfig == null ? void 0 : tableConfig.strategy_model_ids) ? tableConfig.strategy_model_ids : [];
+  return rawIds.map((id) => Number(id)).filter((id) => Number.isFinite(id) && id > 0);
+}
+function normalizeItemRuleStrategies(configs) {
+  if (!Array.isArray(configs))
+    return [];
+  return configs.filter(
+    (config) => {
+      var _a;
+      return Boolean(
+        config && typeof config === "object" && ((_a = config == null ? void 0 : config.metadata) == null ? void 0 : _a.type) === "item_rule"
+      );
+    }
+  );
+}
+function toNonNegativeNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) && value >= 0 ? value : 0;
+  }
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
+  }
+  return 0;
+}
+function toNonNegativeInt(value) {
+  return Math.floor(toNonNegativeNumber(value));
+}
+function toPriceString(value, fallback = "0.00") {
+  const parsedValue = Number(value);
+  if (Number.isNaN(parsedValue))
+    return fallback;
+  return parsedValue.toFixed(2);
+}
+function buildProductKey(productId, productVariantId) {
+  return `${productId}_${productVariantId}`;
+}
+function getTopLevelProductId(product) {
+  const rawProductId = product.product_id ?? product.id;
+  const productId = Number(rawProductId);
+  if (!Number.isFinite(productId) || productId <= 0)
+    return null;
+  return productId;
+}
+function getTopLevelVariantId(product) {
+  const rawVariantId = product.product_variant_id ?? product.variant_id;
+  if (rawVariantId === void 0 || rawVariantId === null || rawVariantId === "") {
+    return null;
+  }
+  const variantId = Number(rawVariantId);
+  if (!Number.isFinite(variantId) || variantId <= 0)
+    return null;
+  return variantId;
+}
+function buildQuantityLimitIndex(limits) {
+  const exactLimitMap = /* @__PURE__ */ new Map();
+  const productLimitMap = /* @__PURE__ */ new Map();
+  for (const limit of limits) {
+    for (const target of limit.targets || []) {
+      const productId = Number(target.product_id);
+      if (!Number.isFinite(productId) || productId <= 0)
+        continue;
+      const variantId = Number(target.product_variant_id);
+      const hasVariant = Number.isFinite(variantId) && variantId > 0;
+      if (hasVariant) {
+        const exactKey = buildProductKey(productId, variantId);
+        const existed2 = exactLimitMap.get(exactKey) || [];
+        exactLimitMap.set(exactKey, [...existed2, limit]);
+        continue;
+      }
+      const existed = productLimitMap.get(productId) || [];
+      productLimitMap.set(productId, [...existed, limit]);
+    }
+  }
+  return {
+    exactLimitMap,
+    productLimitMap
+  };
+}
+function resolveSkuMatchedQuantityLimits(params) {
+  const { productId, variantId, limitIndex } = params;
+  const exactMatched = variantId && variantId > 0 ? limitIndex.exactLimitMap.get(buildProductKey(productId, variantId)) || [] : [];
+  const productMatched = limitIndex.productLimitMap.get(productId) || [];
+  return [...exactMatched, ...productMatched];
+}
+function aggregateItemRuleLimit(matchedLimits) {
+  if (!matchedLimits.length)
+    return null;
+  let min;
+  let max;
+  let exact;
+  let mustInclude = false;
+  for (const limit of matchedLimits) {
+    if (typeof limit.requiredMin === "number" && Number.isFinite(limit.requiredMin)) {
+      min = min === void 0 ? limit.requiredMin : Math.max(min, limit.requiredMin);
+    }
+    if (typeof limit.requiredMax === "number" && Number.isFinite(limit.requiredMax)) {
+      max = max === void 0 ? limit.requiredMax : Math.min(max, limit.requiredMax);
+    }
+    if (typeof limit.requiredExact === "number" && Number.isFinite(limit.requiredExact)) {
+      exact = limit.requiredExact;
+    }
+    mustInclude = mustInclude || Boolean(limit.mustInclude);
+  }
+  if (typeof exact === "number" && Number.isFinite(exact)) {
+    min = exact;
+    max = exact;
+  }
+  return {
+    min,
+    max,
+    exact,
+    mustInclude
+  };
+}
+function buildItemRuleBusinessData(params) {
+  const { tempOrder, runtimeConfig, itemRuleConfigs } = params;
+  const rawPax = runtimeConfig.pax || {};
+  const adultPax = toNonNegativeInt(rawPax.adult);
+  const childPax = toNonNegativeInt(rawPax.child);
+  const totalPax = toNonNegativeInt(rawPax.total) || adultPax + childPax || 1;
+  const cartItems = tempOrder.products.reduce((result, product) => {
+    if (typeof product.product_id !== "number")
+      return result;
+    result.push({
+      product_id: product.product_id,
+      quantity: toNonNegativeInt(product.num),
+      ...typeof product.product_variant_id === "number" ? { product_variant_id: product.product_variant_id } : {}
+    });
+    return result;
+  }, []);
+  const historicalItems = Array.isArray(runtimeConfig.historicalItems) ? runtimeConfig.historicalItems.reduce((result, item) => {
+    if (typeof (item == null ? void 0 : item.product_id) !== "number")
+      return result;
+    result.push({
+      product_id: item.product_id,
+      quantity: toNonNegativeInt(item.quantity),
+      ...typeof item.product_variant_id === "number" ? { product_variant_id: item.product_variant_id } : {}
+    });
+    return result;
+  }, []) : [];
+  return {
+    pax: {
+      total: totalPax,
+      adult: adultPax,
+      child: childPax
+    },
+    cartItems,
+    historicalItems,
+    serviceType: runtimeConfig.serviceType || "dine-in",
+    submissionIndex: typeof runtimeConfig.submissionIndex === "number" ? toNonNegativeInt(runtimeConfig.submissionIndex) : tempOrder.order_id ? 1 : 0,
+    custom: runtimeConfig.custom || {},
+    strategyConfigs: itemRuleConfigs
+  };
+}
+function attachItemRuleLimitsToTopLevelProducts(productList, limits) {
+  if (!Array.isArray(productList))
+    return productList;
+  const limitIndex = buildQuantityLimitIndex(limits || []);
+  for (const item of productList) {
+    if (!item || typeof item !== "object")
+      continue;
+    const productItem = item;
+    const productId = getTopLevelProductId(productItem);
+    if (productId === null)
+      continue;
+    const variantId = getTopLevelVariantId(productItem);
+    const matchedLimits = limits.length ? resolveSkuMatchedQuantityLimits({
+      productId,
+      variantId,
+      limitIndex
+    }) : [];
+    const aggregatedLimit = aggregateItemRuleLimit(matchedLimits);
+    if (aggregatedLimit) {
+      productItem.item_rule_limit = aggregatedLimit;
+    } else if ("item_rule_limit" in productItem) {
+      delete productItem.item_rule_limit;
+    }
+  }
+  return productList;
+}
+function isIdentityMatch(a, b) {
+  if (a.product_id !== b.product_id || a.product_variant_id !== b.product_variant_id)
+    return false;
+  if (!a.identity_key && !b.identity_key)
+    return true;
+  return a.identity_key === b.identity_key;
+}
+function getProductIdentityIndex(products, identity) {
+  return products.findIndex((item) => isIdentityMatch(item, identity));
+}
+function normalizeOrderProduct(product) {
+  var _a;
+  const metadata = { ...product.metadata || {} };
+  if (product.identity_key && !metadata.unique_identification_number) {
+    metadata.unique_identification_number = product.identity_key;
+  }
+  const resolvedOriginalPrice = product.original_price || "0.00";
+  const resolvedSellingPrice = product.selling_price || "0.00";
+  if (metadata.main_product_original_price === void 0) {
+    metadata.main_product_original_price = resolvedOriginalPrice;
+  }
+  if (metadata.main_product_selling_price === void 0) {
+    metadata.main_product_selling_price = resolvedSellingPrice;
+  }
+  if (metadata.source_product_price === void 0) {
+    metadata.source_product_price = ((_a = product._origin) == null ? void 0 : _a.original_price) ?? resolvedOriginalPrice;
+  }
+  const normalizedBundle = (product.product_bundle || []).map((item) => ({
+    ...item,
+    bundle_selling_price: item.bundle_selling_price ?? item.price ?? "0.00",
+    custom_price: item.custom_price ?? item.bundle_selling_price ?? item.price ?? "0.00"
+  }));
+  return {
+    order_detail_id: product.order_detail_id || null,
+    product_id: product.product_id,
+    num: getSafeProductNum(product.num),
+    product_variant_id: product.product_variant_id,
+    identity_key: product.identity_key,
+    product_option_item: product.product_option_item || [],
+    selling_price: resolvedSellingPrice,
+    original_price: resolvedOriginalPrice,
+    payment_price: product.payment_price || "0.00",
+    tax_fee: product.tax_fee || "0.00",
+    is_charge_tax: product.is_charge_tax ?? 0,
+    discount_list: product.discount_list || [],
+    product_bundle: normalizedBundle,
+    metadata,
+    _origin: product._origin
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aggregateItemRuleLimit,
+  attachItemRuleLimitsToTopLevelProducts,
+  buildItemRuleBusinessData,
+  buildProductKey,
+  buildQuantityLimitIndex,
+  createEmptySummary,
+  extractStrategyModelIdsFromTableConfig,
+  getProductIdentityIndex,
+  getSafeProductNum,
+  getTopLevelProductId,
+  getTopLevelVariantId,
+  isIdentityMatch,
+  normalizeEnabledItemRuleIds,
+  normalizeItemRuleStrategies,
+  normalizeOrderProduct,
+  resolveSkuMatchedQuantityLimits,
+  toBoolean,
+  toNonNegativeInt,
+  toNonNegativeNumber,
+  toPositiveString,
+  toPriceString
+});