@pisell/pisellos 0.0.567 → 0.0.568

package/lib/model/strategy/adapter/promotion/evaluator.js

@@ -1,122 +1,128 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/model/strategy/adapter/promotion/evaluator.ts
-var evaluator_exports = {};
-__export(evaluator_exports, {
-  PromotionEvaluator: () => PromotionEvaluator
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(evaluator_exports);
-var import_decimal = __toESM(require("decimal.js"));
-var import_engine = require("../../engine");
-var import_adapter = require("./adapter");
-var import_type = require("./type");
-var defaultLocales = {
+exports.PromotionEvaluator = void 0;
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _engine = require("../../engine");
+var _adapter = require("./adapter");
+var _type = require("./type");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// ============================================
+// 类型定义
+// ============================================
+
+// ============================================
+// 多语言定义
+// ============================================
+
+const defaultLocales = {
   en: {
-    no_applicable_promotion: "No applicable promotion",
-    promotion_not_in_time_range: "Promotion not in valid time range",
-    product_not_in_promotion: "Product not in promotion scope"
+    no_applicable_promotion: 'No applicable promotion',
+    promotion_not_in_time_range: 'Promotion not in valid time range',
+    product_not_in_promotion: 'Product not in promotion scope'
   },
-  "zh-CN": {
-    no_applicable_promotion: "无适用的促销活动",
-    promotion_not_in_time_range: "促销活动不在有效时间范围内",
-    product_not_in_promotion: "商品不在促销范围内"
+  'zh-CN': {
+    no_applicable_promotion: '无适用的促销活动',
+    promotion_not_in_time_range: '促销活动不在有效时间范围内',
+    product_not_in_promotion: '商品不在促销范围内'
   },
-  "zh-HK": {
-    no_applicable_promotion: "無適用的促銷活動",
-    promotion_not_in_time_range: "促銷活動不在有效時間範圍內",
-    product_not_in_promotion: "商品不在促銷範圍內"
+  'zh-HK': {
+    no_applicable_promotion: '無適用的促銷活動',
+    promotion_not_in_time_range: '促銷活動不在有效時間範圍內',
+    product_not_in_promotion: '商品不在促銷範圍內'
   }
 };
-var PromotionEvaluator = class {
+
+// ============================================
+// PromotionEvaluator 实现
+// ============================================
+
+/**
+ * Promotion 评估器
+ *
+ * 用于评估商品适用的促销活动
+ * 封装了 StrategyEngine 和 PromotionAdapter 的调用逻辑
+ */
+class PromotionEvaluator {
+  engine;
+  adapter;
+  strategyConfigs = [];
+  locale = 'en';
+  locales = defaultLocales;
   constructor() {
-    this.strategyConfigs = [];
-    this.locale = "en";
-    this.locales = defaultLocales;
-    this.engine = new import_engine.StrategyEngine({
+    this.engine = new _engine.StrategyEngine({
       debug: false,
       enableTrace: false
     });
-    this.adapter = new import_adapter.PromotionAdapter();
+    this.adapter = new _adapter.PromotionAdapter();
   }
+
   // ============================================
   // 配置管理
   // ============================================
+
   /**
    * 设置策略配置列表
    */
   setStrategyConfigs(strategyConfigs) {
-    const newStrategyConfigs = strategyConfigs.filter((item) => item.metadata.type === "promotion");
+    const newStrategyConfigs = strategyConfigs.filter(item => item.metadata.type === 'promotion');
     this.strategyConfigs = newStrategyConfigs;
   }
+
   /**
    * 获取策略配置列表
    */
   getStrategyConfigs() {
     return this.strategyConfigs;
   }
+
   /**
    * 添加策略配置
    */
   addStrategyConfig(strategyConfig) {
     this.strategyConfigs.push(strategyConfig);
   }
+
   /**
    * 设置语言
    */
   setLocale(locale) {
     this.locale = locale;
   }
+
   /**
    * 设置自定义多语言文案
    */
   setLocales(locales) {
-    this.locales = { ...defaultLocales, ...locales };
+    this.locales = {
+      ...defaultLocales,
+      ...locales
+    };
   }
+
   /**
    * 获取多语言文案
    */
   getText(key) {
-    var _a, _b;
-    return ((_b = (_a = this.locales) == null ? void 0 : _a[this.locale]) == null ? void 0 : _b[key]) || key;
+    return this.locales?.[this.locale]?.[key] || key;
   }
+
   /**
    * 获取多语言名称
    */
   getLocalizedName(name) {
-    if (typeof name === "string") {
+    if (typeof name === 'string') {
       return name;
     }
-    return name[this.locale] || name["en"] || Object.values(name)[0] || "";
+    return name[this.locale] || name['en'] || Object.values(name)[0] || '';
   }
+
   // ============================================
   // 核心评估方法
   // ============================================
+
   /**
    * 评估商品列表
    *
@@ -127,19 +133,31 @@ var PromotionEvaluator = class {
    * @returns 每个商品的促销评估结果
    */
   evaluateProducts(input) {
-    const { products, strategyConfigs, channel } = input;
+    const {
+      products,
+      strategyConfigs,
+      channel
+    } = input;
     const configs = strategyConfigs || this.strategyConfigs;
     const results = [];
     for (const product of products) {
       const applicablePromotions = [];
+
+      // 遍历所有策略，检查此商品是否适用
       for (const config of configs) {
+        // 1. 先用 getProductMatchInfo 检查商品是否在策略的适用范围内（包含 bundle 子商品检查）
         const matchInfo = this.getProductMatchInfo(product, config);
         if (!matchInfo.isMatch) {
+          // 商品不在策略适用范围内，跳过
           continue;
         }
+
+        // 2. 准备上下文（如果是 bundle 子商品匹配，需要用 bundle 子商品的 ID）
         let contextProduct = product;
-        if (matchInfo.matchedBundleIndex !== void 0 && product.bundle) {
+        if (matchInfo.matchedBundleIndex !== undefined && product.bundle) {
           const bundleItem = product.bundle[matchInfo.matchedBundleIndex];
+          // 创建一个临时的"虚拟商品"用于策略引擎评估
+          // 这样策略引擎的 product_match 条件能正确通过
           contextProduct = {
             ...product,
             product_id: bundleItem._bundle_product_id,
@@ -151,6 +169,8 @@ var PromotionEvaluator = class {
           currentProduct: contextProduct,
           channel
         });
+
+        // 3. 评估策略（检查其他条件如时间范围等）
         const result = this.engine.evaluate(config, context);
         if (result.applicable && result.matchedActions.length > 0) {
           const action = result.matchedActions[0];
@@ -181,6 +201,7 @@ var PromotionEvaluator = class {
     }
     return results;
   }
+
   /**
    * 评估购物车
    *
@@ -191,29 +212,42 @@ var PromotionEvaluator = class {
    * @returns 购物车评估结果
    */
   evaluateCart(input) {
-    const { products, strategyConfigs, channel } = input;
+    const {
+      products,
+      strategyConfigs,
+      channel
+    } = input;
     const configs = strategyConfigs || this.strategyConfigs;
+
+    // 1. 先获取每个商品的促销结果
     const productResults = this.evaluateProducts(input);
-    const promotionMap = /* @__PURE__ */ new Map();
+
+    // 2. 收集所有适用的促销（去重）
+    const promotionMap = new Map();
     for (const productResult of productResults) {
       for (const promo of productResult.applicablePromotions) {
         const existing = promotionMap.get(promo.strategyId);
         const product = productResult.product;
+
+        // 计算促销数量：如果是 bundle 子商品匹配，数量 = 主商品数量 × 子商品数量
         let promoQuantity = product.quantity;
-        if (promo.matchedBundleIndex !== void 0 && product.bundle) {
+        if (promo.matchedBundleIndex !== undefined && product.bundle) {
           const bundleItem = product.bundle[promo.matchedBundleIndex];
           promoQuantity = product.quantity * (bundleItem.quantity || 1);
         }
         if (existing) {
+          // 已存在，添加商品到列表
           existing.applicableProducts.push(product);
           existing.totalQuantity += promoQuantity;
           existing.totalAmount += product.price * product.quantity;
+          // 记录每个商品的 matchedBundleIndex
           if (!existing.productMatchedBundleIndexMap) {
-            existing.productMatchedBundleIndexMap = /* @__PURE__ */ new Map();
+            existing.productMatchedBundleIndexMap = new Map();
           }
           existing.productMatchedBundleIndexMap.set(product.id, promo.matchedBundleIndex);
         } else {
-          const productMatchedBundleIndexMap = /* @__PURE__ */ new Map();
+          // 新促销
+          const productMatchedBundleIndexMap = new Map();
           productMatchedBundleIndexMap.set(product.id, promo.matchedBundleIndex);
           promotionMap.set(promo.strategyId, {
             ...promo,
@@ -226,30 +260,28 @@ var PromotionEvaluator = class {
       }
     }
     const applicablePromotions = Array.from(promotionMap.values());
-    const promotionGroups = applicablePromotions.map(
-      (promo) => {
-        var _a;
-        return {
-          strategyId: promo.strategyId,
-          strategyName: promo.strategyName,
-          strategyMetadata: (_a = promo.strategyConfig) == null ? void 0 : _a.metadata,
-          strategyConfig: promo.strategyConfig,
-          actionType: promo.actionType,
-          actionDetail: promo.actionDetail,
-          products: promo.applicableProducts,
-          totalQuantity: promo.totalQuantity,
-          totalAmount: promo.totalAmount,
-          // 传递 productMatchedBundleIndexMap 到 group
-          productMatchedBundleIndexMap: promo.productMatchedBundleIndexMap
-        };
-      }
-    );
+
+    // 3. 按促销分组
+    const promotionGroups = applicablePromotions.map(promo => ({
+      strategyId: promo.strategyId,
+      strategyName: promo.strategyName,
+      strategyMetadata: promo.strategyConfig?.metadata,
+      strategyConfig: promo.strategyConfig,
+      actionType: promo.actionType,
+      actionDetail: promo.actionDetail,
+      products: promo.applicableProducts,
+      totalQuantity: promo.totalQuantity,
+      totalAmount: promo.totalAmount,
+      // 传递 productMatchedBundleIndexMap 到 group
+      productMatchedBundleIndexMap: promo.productMatchedBundleIndexMap
+    }));
     return {
       productResults,
       applicablePromotions,
       promotionGroups
     };
   }
+
   /**
    * 评估购物车并计算定价
    *
@@ -261,60 +293,70 @@ var PromotionEvaluator = class {
    * @returns 带定价的购物车评估结果
    */
   evaluateCartWithPricing(input) {
-    const { products } = input;
+    const {
+      products
+    } = input;
+
+    // 1. 先调用 evaluateCart 获取分组结果
     const cartResult = this.evaluateCart(input);
-    const sortedGroups = this.sortPromotionGroupsByPriority(
-      cartResult.promotionGroups,
-      cartResult.applicablePromotions
-    );
-    const processedQuantityMap = /* @__PURE__ */ new Map();
+
+    // 2. 按 action priority 排序促销组（从 strategyConfig 获取 priority）
+    const sortedGroups = this.sortPromotionGroupsByPriority(cartResult.promotionGroups, cartResult.applicablePromotions);
+
+    // 3. 追踪已处理的商品（避免重复处理）
+    // key: `${product_id}_${product_variant_id}`
+    const processedQuantityMap = new Map();
+
+    // 4. 处理每个促销组，收集结果
     const pricedProducts = [];
     const gifts = [];
-    let totalOriginalAmount = new import_decimal.default(0);
-    let totalFinalAmount = new import_decimal.default(0);
+    let totalOriginalAmount = new _decimal.default(0);
+    let totalFinalAmount = new _decimal.default(0);
     for (const group of sortedGroups) {
-      const { actionType } = group;
-      const matchedBundleIndexMap = group.productMatchedBundleIndexMap || /* @__PURE__ */ new Map();
-      if (actionType === import_type.PROMOTION_ACTION_TYPES.X_ITEMS_FOR_Y_PRICE) {
-        const result = this.processXItemsForYPrice(
-          group,
-          processedQuantityMap,
-          matchedBundleIndexMap
-        );
+      const {
+        actionType
+      } = group;
+
+      // 直接使用 evaluateCart 阶段计算好的 matchedBundleIndexMap
+      const matchedBundleIndexMap = group.productMatchedBundleIndexMap || new Map();
+      if (actionType === _type.PROMOTION_ACTION_TYPES.X_ITEMS_FOR_Y_PRICE) {
+        // X件Y元处理
+        const result = this.processXItemsForYPrice(group, processedQuantityMap, matchedBundleIndexMap);
         pricedProducts.push(...result.products);
         totalOriginalAmount = totalOriginalAmount.plus(result.originalAmount);
         totalFinalAmount = totalFinalAmount.plus(result.finalAmount);
-      } else if (actionType === import_type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE) {
-        const result = this.processBuyXGetYFree(
-          group,
-          processedQuantityMap,
-          matchedBundleIndexMap
-        );
+      } else if (actionType === _type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE) {
+        // 买X送Y处理
+        const result = this.processBuyXGetYFree(group, processedQuantityMap, matchedBundleIndexMap);
         pricedProducts.push(...result.products);
         totalOriginalAmount = totalOriginalAmount.plus(result.originalAmount);
         totalFinalAmount = totalFinalAmount.plus(result.finalAmount);
+
+        // 添加赠品信息
         if (result.giftInfo) {
           gifts.push(result.giftInfo);
         }
       }
     }
-    const remainingProducts = this.getRemainingProducts(
-      products,
-      processedQuantityMap
-    );
+
+    // 5. 处理未参与任何促销的商品
+    const remainingProducts = this.getRemainingProducts(products, processedQuantityMap);
     for (const product of remainingProducts) {
-      const amount = new import_decimal.default(product.price).mul(product.quantity);
+      const amount = new _decimal.default(product.price).mul(product.quantity);
       totalOriginalAmount = totalOriginalAmount.plus(amount);
       totalFinalAmount = totalFinalAmount.plus(amount);
     }
     pricedProducts.push(...remainingProducts);
+
+    // 6. 计算总优惠金额
     const totalDiscount = totalOriginalAmount.minus(totalFinalAmount);
     return {
       products: pricedProducts,
       gifts,
-      totalDiscount: import_decimal.default.max(0, totalDiscount).toNumber()
+      totalDiscount: _decimal.default.max(0, totalDiscount).toNumber()
     };
   }
+
   /**
    * 获取商品适用的促销列表
    *
@@ -325,13 +367,13 @@ var PromotionEvaluator = class {
    * @returns 适用的促销列表
    */
   getProductPromotions(product, strategyConfigs) {
-    var _a;
     const results = this.evaluateProducts({
       products: [product],
       strategyConfigs
     });
-    return ((_a = results[0]) == null ? void 0 : _a.applicablePromotions) || [];
+    return results[0]?.applicablePromotions || [];
   }
+
   /**
    * 获取商品的促销标签
    *
@@ -343,12 +385,13 @@ var PromotionEvaluator = class {
    */
   getProductPromotionTags(product, strategyConfigs) {
     const promotions = this.getProductPromotions(product, strategyConfigs);
-    return promotions.filter((promo) => promo.display).map((promo) => ({
+    return promotions.filter(promo => promo.display).map(promo => ({
       text: this.getLocalizedName(promo.display.text),
       type: promo.display.type,
       strategyId: promo.strategyId
     }));
   }
+
   /**
    * 查找商品适用的策略配置
    *
@@ -358,10 +401,9 @@ var PromotionEvaluator = class {
    */
   findApplicableStrategies(product, strategyConfigs) {
     const configs = strategyConfigs || this.strategyConfigs;
-    return configs.filter(
-      (config) => this.isProductInStrategy(product, config)
-    );
+    return configs.filter(config => this.isProductInStrategy(product, config));
   }
+
   /**
    * 批量获取商品列表的适用策略信息
    *
@@ -373,23 +415,30 @@ var PromotionEvaluator = class {
    * @returns 每个商品的适用策略完整数据
    */
   getProductsApplicableStrategies(input, matchVariant = true) {
-    const { products, strategyConfigs, channel } = input;
+    const {
+      products,
+      strategyConfigs,
+      channel
+    } = input;
     const configs = strategyConfigs || this.strategyConfigs;
     const results = [];
     for (const product of products) {
       const applicableStrategies = [];
+
+      // 遍历所有策略，检查此商品是否适用
       for (const config of configs) {
         let contextProduct = product;
         if (!matchVariant) {
+          // 只匹配 product_id，忽略 product_variant_id
           const productMatchRule = this.findProductMatchRule(config);
           if (productMatchRule) {
             const configProducts = productMatchRule.value;
-            const matchedConfig = configProducts.find(
-              (item) => item.product_id === product.product_id
-            );
+            const matchedConfig = configProducts.find(item => item.product_id === product.product_id);
             if (!matchedConfig) {
+              // product_id 不在策略适用范围内，跳过
               continue;
             }
+            // 用配置中的 variant_id 构造上下文，确保引擎 product_match 通过
             if (matchedConfig.product_variant_id !== 0 && matchedConfig.product_variant_id !== product.product_variant_id) {
               contextProduct = {
                 ...product,
@@ -403,6 +452,8 @@ var PromotionEvaluator = class {
           currentProduct: contextProduct,
           channel
         });
+
+        // 评估策略
         const result = this.engine.evaluate(config, context);
         if (result.applicable && result.matchedActions.length > 0) {
           const action = result.matchedActions[0];
@@ -412,11 +463,11 @@ var PromotionEvaluator = class {
             channel
           });
           if (transformedResult.actionDetail) {
-            const { requiredQuantity, eligibleProducts } = this.getPromotionRequirements(
-              action.type,
-              transformedResult.actionDetail,
-              config
-            );
+            // 计算所需数量和可参与商品列表
+            const {
+              requiredQuantity,
+              eligibleProducts
+            } = this.getPromotionRequirements(action.type, transformedResult.actionDetail, config);
             applicableStrategies.push({
               strategyId: config.metadata.id,
               strategyName: config.metadata.name,
@@ -439,6 +490,7 @@ var PromotionEvaluator = class {
     }
     return results;
   }
+
   /**
    * 获取促销所需数量和可参与商品列表
    *
@@ -449,41 +501,50 @@ var PromotionEvaluator = class {
    */
   getPromotionRequirements(actionType, actionDetail, config) {
     let requiredQuantity = 0;
-    if (actionType === "BUY_X_GET_Y_FREE") {
+
+    // 根据促销类型获取所需数量
+    if (actionType === 'BUY_X_GET_Y_FREE') {
       const detail = actionDetail;
       requiredQuantity = detail.buyQuantity || 0;
-    } else if (actionType === "X_ITEMS_FOR_Y_PRICE") {
+    } else if (actionType === 'X_ITEMS_FOR_Y_PRICE') {
       const detail = actionDetail;
       requiredQuantity = detail.x || 0;
     }
+
+    // 获取可参与商品列表
     const productMatchRule = this.findProductMatchRule(config);
-    const eligibleProducts = (productMatchRule == null ? void 0 : productMatchRule.value) || [];
+    const eligibleProducts = productMatchRule?.value || [];
     return {
       requiredQuantity,
       eligibleProducts
     };
   }
+
   // ============================================
   // 私有辅助方法
   // ============================================
+
   /**
    * 按优先级排序促销组
    * 优先级从 strategyConfig.actions[0].priority 获取，数值越小优先级越高
    */
   sortPromotionGroupsByPriority(groups, promotions) {
-    var _a, _b;
-    const priorityMap = /* @__PURE__ */ new Map();
+    // 创建策略ID到优先级的映射
+    const priorityMap = new Map();
     for (const promo of promotions) {
-      const actions = ((_a = promo.strategyConfig) == null ? void 0 : _a.actions) || [];
-      const priority = ((_b = actions[0]) == null ? void 0 : _b.priority) ?? 999;
+      const actions = promo.strategyConfig?.actions || [];
+      const priority = actions[0]?.priority ?? 999;
       priorityMap.set(promo.strategyId, priority);
     }
+
+    // 按优先级排序（数值越小优先级越高）
     return [...groups].sort((a, b) => {
       const priorityA = priorityMap.get(a.strategyId) ?? 999;
       const priorityB = priorityMap.get(b.strategyId) ?? 999;
       return priorityA - priorityB;
     });
   }
+
   /**
    * 处理 X件Y元 促销
    *
@@ -495,19 +556,32 @@ var PromotionEvaluator = class {
    * 注意：每个商品按 id 独立处理，不会合并不同 id 的商品
    */
   processXItemsForYPrice(group, processedQuantityMap, matchedBundleIndexMap) {
-    const { strategyId, strategyMetadata, actionDetail, products: groupProducts } = group;
+    const {
+      strategyId,
+      strategyMetadata,
+      actionDetail,
+      products: groupProducts
+    } = group;
     const detail = actionDetail;
-    const { x, price: groupPrice, cumulative } = detail;
+    const {
+      x,
+      price: groupPrice,
+      cumulative
+    } = detail;
     const result = [];
-    let originalAmount = new import_decimal.default(0);
-    let finalAmount = new import_decimal.default(0);
+    let originalAmount = new _decimal.default(0);
+    let finalAmount = new _decimal.default(0);
+
+    // 1. 展开所有商品为单件列表（排除已处理的数量）
+    // 每个单件记录来自哪个原商品（通过 product.id）
     const unitProducts = [];
     for (const product of groupProducts) {
       const key = this.getProductKey(product);
       const processedQty = processedQuantityMap.get(key) || 0;
       const availableQty = product.quantity - processedQty;
-      if (availableQty <= 0)
-        continue;
+      if (availableQty <= 0) continue;
+
+      // 展开为单件，每个单件都记录来源商品
       for (let i = 0; i < availableQty; i++) {
         unitProducts.push({
           product,
@@ -518,46 +592,66 @@ var PromotionEvaluator = class {
       }
     }
     if (unitProducts.length === 0) {
-      return { products: [], originalAmount: 0, finalAmount: 0 };
+      return {
+        products: [],
+        originalAmount: 0,
+        finalAmount: 0
+      };
     }
+
+    // 2. 排序：优先选择来源数量是 x 倍数的商品（可完整凑组不拆分），然后按价格从高到低
     unitProducts.sort((a, b) => {
+      // 优先级1：来源购物车项数量是 x 的倍数的排前面（这些商品可以完整凑组，避免拆分）
       const aIsMultiple = a.sourceAvailableQty > 0 && a.sourceAvailableQty % x === 0 ? 1 : 0;
       const bIsMultiple = b.sourceAvailableQty > 0 && b.sourceAvailableQty % x === 0 ? 1 : 0;
-      if (aIsMultiple !== bIsMultiple)
-        return bIsMultiple - aIsMultiple;
+      if (aIsMultiple !== bIsMultiple) return bIsMultiple - aIsMultiple;
+      // 优先级2：按价格从高到低（优先使用高价商品）
       return b.price - a.price;
     });
+
+    // 3. 计算可以凑成多少组
     const totalUnits = unitProducts.length;
     const groupCount = cumulative ? Math.floor(totalUnits / x) : totalUnits >= x ? 1 : 0;
     const promotionUnits = groupCount * x;
+
+    // 4. 分离参与促销的和不参与的商品
     const inPromotionUnits = unitProducts.slice(0, promotionUnits);
     const notInPromotionUnits = unitProducts.slice(promotionUnits);
-    const promotionQtyByProductId = /* @__PURE__ */ new Map();
+
+    // 5. 按原商品 id 统计参与促销和不参与的数量
+    const promotionQtyByProductId = new Map();
     for (const unit of inPromotionUnits) {
       const id = unit.productId;
       promotionQtyByProductId.set(id, (promotionQtyByProductId.get(id) || 0) + 1);
     }
-    const remainingQtyByProductId = /* @__PURE__ */ new Map();
+    const remainingQtyByProductId = new Map();
     for (const unit of notInPromotionUnits) {
       const id = unit.productId;
       remainingQtyByProductId.set(id, (remainingQtyByProductId.get(id) || 0) + 1);
     }
-    const allocatedPricesByProductId = /* @__PURE__ */ new Map();
+
+    // 6. 为每个参与促销的单件计算均摊价格
+    // 按组内原价比例均摊
+    // 记录每个原商品的均摊价格累加（用于后续聚合）
+    const allocatedPricesByProductId = new Map();
     for (let g = 0; g < groupCount; g++) {
       const startIdx = g * x;
       const endIdx = startIdx + x;
       const groupUnits = inPromotionUnits.slice(startIdx, endIdx);
-      const groupOriginalTotal = groupUnits.reduce(
-        (sum, u) => sum.plus(u.price),
-        new import_decimal.default(0)
-      );
-      const groupPriceDecimal = new import_decimal.default(groupPrice);
-      let allocatedSum = new import_decimal.default(0);
+
+      // 计算组内原价总和
+      const groupOriginalTotal = groupUnits.reduce((sum, u) => sum.plus(u.price), new _decimal.default(0));
+
+      // 按原价比例均摊
+      const groupPriceDecimal = new _decimal.default(groupPrice);
+      let allocatedSum = new _decimal.default(0);
       for (let i = 0; i < groupUnits.length; i++) {
         const unit = groupUnits[i];
         const isLastUnit = i === groupUnits.length - 1;
-        const ratio = groupOriginalTotal.eq(0) ? new import_decimal.default(0) : new import_decimal.default(unit.price).div(groupOriginalTotal);
+        const ratio = groupOriginalTotal.eq(0) ? new _decimal.default(0) : new _decimal.default(unit.price).div(groupOriginalTotal);
         const allocatedDecimal = isLastUnit ? groupPriceDecimal.minus(allocatedSum) : groupPriceDecimal.mul(ratio);
+
+        // 记录这个单件的均摊价格
         const productId = unit.productId;
         const prices = allocatedPricesByProductId.get(productId) || [];
         prices.push(allocatedDecimal);
@@ -565,23 +659,25 @@ var PromotionEvaluator = class {
         allocatedSum = allocatedSum.plus(allocatedDecimal);
       }
     }
+
+    // 7. 为每个原商品生成结果
     for (const product of groupProducts) {
       const key = this.getProductKey(product);
       const processedQty = processedQuantityMap.get(key) || 0;
       const availableQty = product.quantity - processedQty;
-      if (availableQty <= 0)
-        continue;
+      if (availableQty <= 0) continue;
       const promoQty = promotionQtyByProductId.get(product.id) || 0;
       const remainingQty = remainingQtyByProductId.get(product.id) || 0;
       const allocatedPrices = allocatedPricesByProductId.get(product.id) || [];
-      const matchedBundleIndex = matchedBundleIndexMap == null ? void 0 : matchedBundleIndexMap.get(product.id);
+
+      // 获取当前商品的 matchedBundleIndex
+      const matchedBundleIndex = matchedBundleIndexMap?.get(product.id);
       if (promoQty > 0 && remainingQty === 0) {
-        const totalAllocated = allocatedPrices.reduce(
-          (sum, p) => sum.plus(p),
-          new import_decimal.default(0)
-        );
-        const productOriginalAmount = new import_decimal.default(product.price).mul(promoQty);
-        const actualTotal = import_decimal.default.min(totalAllocated, productOriginalAmount);
+        // 全部参与促销：保留原 id，计算总 finalPrice
+        const totalAllocated = allocatedPrices.reduce((sum, p) => sum.plus(p), new _decimal.default(0));
+        // 取促销价和原价的最小值，避免促销反而加价
+        const productOriginalAmount = new _decimal.default(product.price).mul(promoQty);
+        const actualTotal = _decimal.default.min(totalAllocated, productOriginalAmount);
         const finalPricePerUnit = this.formatPrice(actualTotal.div(promoQty));
         result.push({
           ...product,
@@ -596,25 +692,26 @@ var PromotionEvaluator = class {
         originalAmount = originalAmount.plus(productOriginalAmount);
         finalAmount = finalAmount.plus(actualTotal);
       } else if (promoQty === 0 && remainingQty > 0) {
+        // 全部不参与促销：保留原 id，finalPrice = 原价
         result.push({
           ...product,
           quantity: remainingQty,
           finalPrice: this.formatPrice(product.price),
-          strategyId: void 0,
-          strategyMetadata: void 0,
+          strategyId: undefined,
+          strategyMetadata: undefined,
           inPromotion: false,
           isSplit: false
         });
-        const amount = new import_decimal.default(product.price).mul(remainingQty);
+        const amount = new _decimal.default(product.price).mul(remainingQty);
         originalAmount = originalAmount.plus(amount);
         finalAmount = finalAmount.plus(amount);
       } else if (promoQty > 0 && remainingQty > 0) {
-        const totalAllocated = allocatedPrices.reduce(
-          (sum, p) => sum.plus(p),
-          new import_decimal.default(0)
-        );
-        const promoOriginalAmount = new import_decimal.default(product.price).mul(promoQty);
-        const actualTotal = import_decimal.default.min(totalAllocated, promoOriginalAmount);
+        // 部分参与促销，部分不参与：需要拆分
+        // 参与促销的部分：新 id
+        const totalAllocated = allocatedPrices.reduce((sum, p) => sum.plus(p), new _decimal.default(0));
+        // 取促销价和原价的最小值，避免促销反而加价
+        const promoOriginalAmount = new _decimal.default(product.price).mul(promoQty);
+        const actualTotal = _decimal.default.min(totalAllocated, promoOriginalAmount);
         const finalPricePerUnit = this.formatPrice(actualTotal.div(promoQty));
         result.push({
           ...product,
@@ -630,44 +727,50 @@ var PromotionEvaluator = class {
         });
         originalAmount = originalAmount.plus(promoOriginalAmount);
         finalAmount = finalAmount.plus(actualTotal);
+
+        // 不参与促销的部分：保留原 id
         result.push({
           ...product,
           quantity: remainingQty,
           finalPrice: this.formatPrice(product.price),
-          strategyId: void 0,
-          strategyMetadata: void 0,
+          strategyId: undefined,
+          strategyMetadata: undefined,
           inPromotion: false,
           isSplit: true
         });
-        const remainingAmount = new import_decimal.default(product.price).mul(remainingQty);
+        const remainingAmount = new _decimal.default(product.price).mul(remainingQty);
         originalAmount = originalAmount.plus(remainingAmount);
         finalAmount = finalAmount.plus(remainingAmount);
       }
+
+      // 更新已处理数量
       processedQuantityMap.set(key, processedQty + availableQty);
     }
+
+    // 8. 尾差调整：确保促销商品的 finalPrice × quantity 之和精确等于 groupPrice × groupCount
     if (groupCount > 0) {
-      const expectedPromoTotal = new import_decimal.default(groupPrice).mul(groupCount);
-      const promoItems = result.filter((p) => p.inPromotion);
-      let actualPromoTotal = new import_decimal.default(0);
+      const expectedPromoTotal = new _decimal.default(groupPrice).mul(groupCount);
+      const promoItems = result.filter(p => p.inPromotion);
+      let actualPromoTotal = new _decimal.default(0);
       for (const p of promoItems) {
-        actualPromoTotal = actualPromoTotal.plus(
-          new import_decimal.default(p.finalPrice).mul(p.quantity)
-        );
+        actualPromoTotal = actualPromoTotal.plus(new _decimal.default(p.finalPrice).mul(p.quantity));
       }
       const roundingDiff = actualPromoTotal.minus(expectedPromoTotal);
       if (!roundingDiff.eq(0)) {
-        const adjustTarget = promoItems.find((p) => p.quantity === 1);
+        // 优先找 quantity=1 的促销商品调整（差额直接加减到单价上）
+        const adjustTarget = promoItems.find(p => p.quantity === 1);
         if (adjustTarget) {
-          adjustTarget.finalPrice = this.formatPrice(
-            new import_decimal.default(adjustTarget.finalPrice).minus(roundingDiff)
-          );
+          adjustTarget.finalPrice = this.formatPrice(new _decimal.default(adjustTarget.finalPrice).minus(roundingDiff));
         } else if (promoItems.length > 0) {
+          // 没有 quantity=1 的促销商品，从最后一个促销商品中拆出1件做尾差调整
           const lastPromo = promoItems[promoItems.length - 1];
-          const adjustedUnitPrice = this.formatPrice(
-            new import_decimal.default(lastPromo.finalPrice).minus(roundingDiff)
-          );
+          const adjustedUnitPrice = this.formatPrice(new _decimal.default(lastPromo.finalPrice).minus(roundingDiff));
+
+          // 原商品减少1件
           lastPromo.quantity -= 1;
           lastPromo.isSplit = true;
+
+          // 拆出1件用调整后的价格
           result.push({
             ...lastPromo,
             id: this.generateRandomId(),
@@ -677,11 +780,11 @@ var PromotionEvaluator = class {
             isSplit: true
           });
         }
-        finalAmount = new import_decimal.default(0);
+
+        // 重新计算 finalAmount
+        finalAmount = new _decimal.default(0);
         for (const p of result) {
-          finalAmount = finalAmount.plus(
-            new import_decimal.default(p.finalPrice).mul(p.quantity)
-          );
+          finalAmount = finalAmount.plus(new _decimal.default(p.finalPrice).mul(p.quantity));
         }
       }
     }
@@ -691,6 +794,7 @@ var PromotionEvaluator = class {
       finalAmount: finalAmount.toNumber()
     };
   }
+
   /**
    * 处理 买X送Y 促销
    *
@@ -706,34 +810,56 @@ var PromotionEvaluator = class {
       products: groupProducts
     } = group;
     const detail = actionDetail;
-    const { buyQuantity, freeQuantity, cumulative, giftProducts } = detail;
+    const {
+      buyQuantity,
+      freeQuantity,
+      cumulative,
+      giftProducts
+    } = detail;
     const result = [];
-    let originalAmount = new import_decimal.default(0);
-    let finalAmount = new import_decimal.default(0);
+    let originalAmount = new _decimal.default(0);
+    let finalAmount = new _decimal.default(0);
+
+    // 1. 先计算可用商品总数量（第一次遍历）
+    // 对于 bundle 子商品匹配，促销数量 = 主商品数量 × bundle子商品数量
     let totalPromoQty = 0;
-    const productInfoMap = /* @__PURE__ */ new Map();
+    const productInfoMap = new Map();
     for (const product of groupProducts) {
       const key = this.getProductKey(product);
       const processedQty = processedQuantityMap.get(key) || 0;
       const availableQty = product.quantity - processedQty;
-      if (availableQty <= 0)
-        continue;
-      const matchedBundleIndex = matchedBundleIndexMap == null ? void 0 : matchedBundleIndexMap.get(product.id);
+      if (availableQty <= 0) continue;
+
+      // 获取 matchedBundleIndex
+      const matchedBundleIndex = matchedBundleIndexMap?.get(product.id);
+
+      // 计算用于促销的数量
       let promoQty = availableQty;
-      if (matchedBundleIndex !== void 0 && product.bundle) {
+      if (matchedBundleIndex !== undefined && product.bundle) {
         const bundleItem = product.bundle[matchedBundleIndex];
+        // 促销数量 = 主商品数量 × bundle子商品数量
         promoQty = availableQty * (bundleItem.quantity || 1);
       }
       totalPromoQty += promoQty;
-      productInfoMap.set(key, { availableQty, promoQty, matchedBundleIndex });
+      productInfoMap.set(key, {
+        availableQty,
+        promoQty,
+        matchedBundleIndex
+      });
     }
+
+    // 2. 判断是否满足促销条件
     const isFulfilled = totalPromoQty >= buyQuantity;
+
+    // 3. 生成商品结果（第二次遍历）
     for (const product of groupProducts) {
       const key = this.getProductKey(product);
       const info = productInfoMap.get(key);
-      if (!info || info.availableQty <= 0)
-        continue;
+      if (!info || info.availableQty <= 0) continue;
       const processedQty = processedQuantityMap.get(key) || 0;
+
+      // 商品本身价格不变，只是触发赠品
+      // inPromotion 只有在满足条件时才为 true
       result.push({
         ...product,
         quantity: info.availableQty,
@@ -745,15 +871,21 @@ var PromotionEvaluator = class {
         isSplit: info.availableQty < product.quantity,
         matchedBundleIndex: info.matchedBundleIndex
       });
-      const amount = new import_decimal.default(product.price).mul(info.availableQty);
+      const amount = new _decimal.default(product.price).mul(info.availableQty);
       originalAmount = originalAmount.plus(amount);
       finalAmount = finalAmount.plus(amount);
+
+      // 更新已处理数量（使用主商品数量）
       processedQuantityMap.set(key, processedQty + info.availableQty);
     }
+
+    // 4. 计算赠品数量（使用促销数量）
     let giftCount = 0;
     if (isFulfilled) {
       giftCount = cumulative ? Math.floor(totalPromoQty / buyQuantity) * freeQuantity : freeQuantity;
     }
+
+    // 5. 构建赠品信息
     const giftInfo = giftCount > 0 ? {
       strategyId,
       strategyName,
@@ -767,6 +899,7 @@ var PromotionEvaluator = class {
       giftInfo
     };
   }
+
   /**
    * 获取未参与任何促销的商品
    */
@@ -781,7 +914,7 @@ var PromotionEvaluator = class {
           ...product,
           quantity: remainingQty,
           finalPrice: this.formatPrice(product.price),
-          strategyId: void 0,
+          strategyId: undefined,
           inPromotion: false,
           isSplit: remainingQty < product.quantity
         });
@@ -789,12 +922,14 @@ var PromotionEvaluator = class {
     }
     return result;
   }
+
   /**
    * 价格统一保留两位小数
    */
   formatPrice(value) {
-    return new import_decimal.default(value).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
+    return new _decimal.default(value).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
   }
+
   /**
    * 获取商品唯一标识 key
    * 使用商品的 id 作为唯一标识，不同 id 的商品不会被合并
@@ -802,92 +937,107 @@ var PromotionEvaluator = class {
   getProductKey(product) {
     return String(product.id);
   }
+
   /**
    * 生成随机ID
    */
   generateRandomId() {
-    return Math.floor(Math.random() * 1e9) + Date.now();
+    return Math.floor(Math.random() * 1000000000) + Date.now();
   }
+
   /**
    * 商品匹配结果信息
    */
   getProductMatchInfo(product, config) {
     const productMatchRule = this.findProductMatchRule(config);
     if (!productMatchRule) {
-      return { isMatch: true };
+      // 没有商品范围条件，默认适用所有商品（匹配主商品）
+      return {
+        isMatch: true
+      };
     }
     const configProducts = productMatchRule.value;
+
+    // 1. 先检查主商品是否匹配
     if (this.isProductIdMatch(product.product_id, product.product_variant_id, configProducts)) {
-      return { isMatch: true };
+      return {
+        isMatch: true
+      };
     }
+
+    // 2. 主商品不匹配，检查 bundle 子商品
     if (product.bundle && product.bundle.length > 0) {
       for (let i = 0; i < product.bundle.length; i++) {
         const bundleItem = product.bundle[i];
-        if (this.isProductIdMatch(
-          bundleItem._bundle_product_id,
-          bundleItem.product_variant_id,
-          configProducts
-        )) {
-          return { isMatch: true, matchedBundleIndex: i };
+        if (this.isProductIdMatch(bundleItem._bundle_product_id, bundleItem.product_variant_id, configProducts)) {
+          return {
+            isMatch: true,
+            matchedBundleIndex: i
+          };
         }
       }
     }
-    return { isMatch: false };
+    return {
+      isMatch: false
+    };
   }
+
   /**
    * 检查商品是否在策略的适用范围内
    */
   isProductInStrategy(product, config) {
     return this.getProductMatchInfo(product, config).isMatch;
   }
+
   /**
    * 查找商品匹配规则
    */
   findProductMatchRule(config) {
-    var _a;
-    if (!((_a = config == null ? void 0 : config.conditions) == null ? void 0 : _a.rules)) {
+    if (!config?.conditions?.rules) {
       return null;
     }
-    return config.conditions.rules.find(
-      (rule) => rule.field === "productIdAndVariantId" && (rule.operator === "product_match" || rule.operator === "object_in")
-    );
+    return config.conditions.rules.find(rule => rule.field === 'productIdAndVariantId' && (rule.operator === 'product_match' || rule.operator === 'object_in'));
   }
+
   /**
    * 检查商品ID是否匹配配置列表
    */
   isProductIdMatch(productId, productVariantId, configProducts) {
-    return configProducts.some((config) => {
+    return configProducts.some(config => {
+      // 首先检查 product_id
       if (config.product_id !== productId) {
         return false;
       }
+
+      // 如果配置的 product_variant_id = 0，只需要 product_id 匹配
       if (config.product_variant_id === 0) {
         return true;
       }
+
+      // 否则需要 product_variant_id 精确匹配
       return config.product_variant_id === productVariantId;
     });
   }
+
   /**
    * 检查商品是否匹配配置（兼容旧方法）
    */
   isProductMatch(product, configProducts) {
     return this.isProductIdMatch(product.product_id, product.product_variant_id, configProducts);
   }
+
   /**
    * 获取展示配置
    */
   getDisplayConfig(config) {
-    var _a;
     const custom = config.metadata.custom;
-    if ((_a = custom == null ? void 0 : custom.display) == null ? void 0 : _a.product_card) {
+    if (custom?.display?.product_card) {
       return {
         text: custom.display.product_card.text,
         type: custom.display.product_card.type
       };
     }
-    return void 0;
+    return undefined;
   }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  PromotionEvaluator
-});
+}
+exports.PromotionEvaluator = PromotionEvaluator;