@pisell/pisellos 0.0.569 → 0.10.2

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

@@ -1,128 +1,122 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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
 });
-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 = {
+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 = {
   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: "商品不在促銷範圍內"
   }
 };
-
-// ============================================
-// PromotionEvaluator 实现
-// ============================================
-
-/**
- * Promotion 评估器
- *
- * 用于评估商品适用的促销活动
- * 封装了 StrategyEngine 和 PromotionAdapter 的调用逻辑
- */
-class PromotionEvaluator {
-  engine;
-  adapter;
-  strategyConfigs = [];
-  locale = 'en';
-  locales = defaultLocales;
+var PromotionEvaluator = class {
   constructor() {
-    this.engine = new _engine.StrategyEngine({
+    this.strategyConfigs = [];
+    this.locale = "en";
+    this.locales = defaultLocales;
+    this.engine = new import_engine.StrategyEngine({
       debug: false,
       enableTrace: false
     });
-    this.adapter = new _adapter.PromotionAdapter();
+    this.adapter = new import_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) {
-    return this.locales?.[this.locale]?.[key] || key;
+    var _a, _b;
+    return ((_b = (_a = this.locales) == null ? void 0 : _a[this.locale]) == null ? void 0 : _b[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] || "";
   }
-
   // ============================================
   // 核心评估方法
   // ============================================
-
   /**
    * 评估商品列表
    *
@@ -133,31 +127,19 @@ class PromotionEvaluator {
    * @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 !== undefined && product.bundle) {
+        if (matchInfo.matchedBundleIndex !== void 0 && product.bundle) {
           const bundleItem = product.bundle[matchInfo.matchedBundleIndex];
-          // 创建一个临时的"虚拟商品"用于策略引擎评估
-          // 这样策略引擎的 product_match 条件能正确通过
           contextProduct = {
             ...product,
             product_id: bundleItem._bundle_product_id,
@@ -169,8 +151,6 @@ class PromotionEvaluator {
           currentProduct: contextProduct,
           channel
         });
-
-        // 3. 评估策略（检查其他条件如时间范围等）
         const result = this.engine.evaluate(config, context);
         if (result.applicable && result.matchedActions.length > 0) {
           const action = result.matchedActions[0];
@@ -201,7 +181,6 @@ class PromotionEvaluator {
     }
     return results;
   }
-
   /**
    * 评估购物车
    *
@@ -212,42 +191,29 @@ class PromotionEvaluator {
    * @returns 购物车评估结果
    */
   evaluateCart(input) {
-    const {
-      products,
-      strategyConfigs,
-      channel
-    } = input;
+    const { products, strategyConfigs, channel } = input;
     const configs = strategyConfigs || this.strategyConfigs;
-
-    // 1. 先获取每个商品的促销结果
     const productResults = this.evaluateProducts(input);
-
-    // 2. 收集所有适用的促销（去重）
-    const promotionMap = new Map();
+    const promotionMap = /* @__PURE__ */ 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 !== undefined && product.bundle) {
+        if (promo.matchedBundleIndex !== void 0 && 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 = new Map();
+            existing.productMatchedBundleIndexMap = /* @__PURE__ */ new Map();
           }
           existing.productMatchedBundleIndexMap.set(product.id, promo.matchedBundleIndex);
         } else {
-          // 新促销
-          const productMatchedBundleIndexMap = new Map();
+          const productMatchedBundleIndexMap = /* @__PURE__ */ new Map();
           productMatchedBundleIndexMap.set(product.id, promo.matchedBundleIndex);
           promotionMap.set(promo.strategyId, {
             ...promo,
@@ -260,28 +226,30 @@ class PromotionEvaluator {
       }
     }
     const applicablePromotions = Array.from(promotionMap.values());
-
-    // 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
-    }));
+    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
+        };
+      }
+    );
     return {
       productResults,
       applicablePromotions,
       promotionGroups
     };
   }
-
   /**
    * 评估购物车并计算定价
    *
@@ -293,70 +261,60 @@ class PromotionEvaluator {
    * @returns 带定价的购物车评估结果
    */
   evaluateCartWithPricing(input) {
-    const {
-      products
-    } = input;
-
-    // 1. 先调用 evaluateCart 获取分组结果
+    const { products } = input;
     const cartResult = this.evaluateCart(input);
-
-    // 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 sortedGroups = this.sortPromotionGroupsByPriority(
+      cartResult.promotionGroups,
+      cartResult.applicablePromotions
+    );
+    const processedQuantityMap = /* @__PURE__ */ new Map();
     const pricedProducts = [];
     const gifts = [];
-    let totalOriginalAmount = new _decimal.default(0);
-    let totalFinalAmount = new _decimal.default(0);
+    let totalOriginalAmount = new import_decimal.default(0);
+    let totalFinalAmount = new import_decimal.default(0);
     for (const group of sortedGroups) {
-      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);
+      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
+        );
         pricedProducts.push(...result.products);
         totalOriginalAmount = totalOriginalAmount.plus(result.originalAmount);
         totalFinalAmount = totalFinalAmount.plus(result.finalAmount);
-      } else if (actionType === _type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE) {
-        // 买X送Y处理
-        const result = this.processBuyXGetYFree(group, processedQuantityMap, matchedBundleIndexMap);
+      } else if (actionType === import_type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE) {
+        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);
         }
       }
     }
-
-    // 5. 处理未参与任何促销的商品
-    const remainingProducts = this.getRemainingProducts(products, processedQuantityMap);
+    const remainingProducts = this.getRemainingProducts(
+      products,
+      processedQuantityMap
+    );
     for (const product of remainingProducts) {
-      const amount = new _decimal.default(product.price).mul(product.quantity);
+      const amount = new import_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: _decimal.default.max(0, totalDiscount).toNumber()
+      totalDiscount: import_decimal.default.max(0, totalDiscount).toNumber()
     };
   }
-
   /**
    * 获取商品适用的促销列表
    *
@@ -367,13 +325,13 @@ class PromotionEvaluator {
    * @returns 适用的促销列表
    */
   getProductPromotions(product, strategyConfigs) {
+    var _a;
     const results = this.evaluateProducts({
       products: [product],
       strategyConfigs
     });
-    return results[0]?.applicablePromotions || [];
+    return ((_a = results[0]) == null ? void 0 : _a.applicablePromotions) || [];
   }
-
   /**
    * 获取商品的促销标签
    *
@@ -385,13 +343,12 @@ class PromotionEvaluator {
    */
   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
     }));
   }
-
   /**
    * 查找商品适用的策略配置
    *
@@ -401,9 +358,10 @@ class PromotionEvaluator {
    */
   findApplicableStrategies(product, strategyConfigs) {
     const configs = strategyConfigs || this.strategyConfigs;
-    return configs.filter(config => this.isProductInStrategy(product, config));
+    return configs.filter(
+      (config) => this.isProductInStrategy(product, config)
+    );
   }
-
   /**
    * 批量获取商品列表的适用策略信息
    *
@@ -415,30 +373,23 @@ class PromotionEvaluator {
    * @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,
@@ -452,8 +403,6 @@ class PromotionEvaluator {
           currentProduct: contextProduct,
           channel
         });
-
-        // 评估策略
         const result = this.engine.evaluate(config, context);
         if (result.applicable && result.matchedActions.length > 0) {
           const action = result.matchedActions[0];
@@ -463,11 +412,11 @@ class PromotionEvaluator {
             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,
@@ -490,7 +439,6 @@ class PromotionEvaluator {
     }
     return results;
   }
-
   /**
    * 获取促销所需数量和可参与商品列表
    *
@@ -501,50 +449,41 @@ class PromotionEvaluator {
    */
   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?.value || [];
+    const eligibleProducts = (productMatchRule == null ? void 0 : productMatchRule.value) || [];
     return {
       requiredQuantity,
       eligibleProducts
     };
   }
-
   // ============================================
   // 私有辅助方法
   // ============================================
-
   /**
    * 按优先级排序促销组
    * 优先级从 strategyConfig.actions[0].priority 获取，数值越小优先级越高
    */
   sortPromotionGroupsByPriority(groups, promotions) {
-    // 创建策略ID到优先级的映射
-    const priorityMap = new Map();
+    var _a, _b;
+    const priorityMap = /* @__PURE__ */ new Map();
     for (const promo of promotions) {
-      const actions = promo.strategyConfig?.actions || [];
-      const priority = actions[0]?.priority ?? 999;
+      const actions = ((_a = promo.strategyConfig) == null ? void 0 : _a.actions) || [];
+      const priority = ((_b = actions[0]) == null ? void 0 : _b.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元 促销
    *
@@ -556,32 +495,19 @@ class PromotionEvaluator {
    * 注意：每个商品按 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 _decimal.default(0);
-    let finalAmount = new _decimal.default(0);
-
-    // 1. 展开所有商品为单件列表（排除已处理的数量）
-    // 每个单件记录来自哪个原商品（通过 product.id）
+    let originalAmount = new import_decimal.default(0);
+    let finalAmount = new import_decimal.default(0);
     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,
@@ -592,67 +518,47 @@ class PromotionEvaluator {
       }
     }
     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;
-      // 优先级2：按价格从高到低（优先使用高价商品）
+      if (aIsMultiple !== bIsMultiple)
+        return bIsMultiple - aIsMultiple;
       return b.price - a.price;
     });
-
-    // 3. 计算可以凑成多少组（cumulative 缺省视为 true，与 adapter 一致）
     const totalUnits = unitProducts.length;
     const isCumulative = cumulative !== false;
     const groupCount = isCumulative ? Math.floor(totalUnits / x) : totalUnits >= x ? 1 : 0;
     const promotionUnits = groupCount * x;
-
-    // 4. 分离参与促销的和不参与的商品
     const inPromotionUnits = unitProducts.slice(0, promotionUnits);
     const notInPromotionUnits = unitProducts.slice(promotionUnits);
-
-    // 5. 按原商品 id 统计参与促销和不参与的数量
-    const promotionQtyByProductId = new Map();
+    const promotionQtyByProductId = /* @__PURE__ */ new Map();
     for (const unit of inPromotionUnits) {
       const id = unit.productId;
       promotionQtyByProductId.set(id, (promotionQtyByProductId.get(id) || 0) + 1);
     }
-    const remainingQtyByProductId = new Map();
+    const remainingQtyByProductId = /* @__PURE__ */ new Map();
     for (const unit of notInPromotionUnits) {
       const id = unit.productId;
       remainingQtyByProductId.set(id, (remainingQtyByProductId.get(id) || 0) + 1);
     }
-
-    // 6. 为每个参与促销的单件计算均摊价格
-    // 按组内原价比例均摊
-    // 记录每个原商品的均摊价格累加（用于后续聚合）
-    const allocatedPricesByProductId = new Map();
+    const allocatedPricesByProductId = /* @__PURE__ */ 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 _decimal.default(0));
-
-      // 按原价比例均摊
-      const groupPriceDecimal = new _decimal.default(groupPrice);
-      let allocatedSum = new _decimal.default(0);
+      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);
       for (let i = 0; i < groupUnits.length; i++) {
         const unit = groupUnits[i];
         const isLastUnit = i === groupUnits.length - 1;
-        const ratio = groupOriginalTotal.eq(0) ? new _decimal.default(0) : new _decimal.default(unit.price).div(groupOriginalTotal);
+        const ratio = groupOriginalTotal.eq(0) ? new import_decimal.default(0) : new import_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);
@@ -660,25 +566,23 @@ class PromotionEvaluator {
         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) || [];
-
-      // 获取当前商品的 matchedBundleIndex
-      const matchedBundleIndex = matchedBundleIndexMap?.get(product.id);
+      const matchedBundleIndex = matchedBundleIndexMap == null ? void 0 : matchedBundleIndexMap.get(product.id);
       if (promoQty > 0 && remainingQty === 0) {
-        // 全部参与促销：保留原 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 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);
         const finalPricePerUnit = this.formatPrice(actualTotal.div(promoQty));
         result.push({
           ...product,
@@ -693,26 +597,25 @@ class PromotionEvaluator {
         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: undefined,
-          strategyMetadata: undefined,
+          strategyId: void 0,
+          strategyMetadata: void 0,
           inPromotion: false,
           isSplit: false
         });
-        const amount = new _decimal.default(product.price).mul(remainingQty);
+        const amount = new import_decimal.default(product.price).mul(remainingQty);
         originalAmount = originalAmount.plus(amount);
         finalAmount = finalAmount.plus(amount);
       } else if (promoQty > 0 && remainingQty > 0) {
-        // 部分参与促销，部分不参与：需要拆分
-        // 参与促销的部分：新 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 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);
         const finalPricePerUnit = this.formatPrice(actualTotal.div(promoQty));
         result.push({
           ...product,
@@ -728,50 +631,44 @@ class PromotionEvaluator {
         });
         originalAmount = originalAmount.plus(promoOriginalAmount);
         finalAmount = finalAmount.plus(actualTotal);
-
-        // 不参与促销的部分：保留原 id
         result.push({
           ...product,
           quantity: remainingQty,
           finalPrice: this.formatPrice(product.price),
-          strategyId: undefined,
-          strategyMetadata: undefined,
+          strategyId: void 0,
+          strategyMetadata: void 0,
           inPromotion: false,
           isSplit: true
         });
-        const remainingAmount = new _decimal.default(product.price).mul(remainingQty);
+        const remainingAmount = new import_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 _decimal.default(groupPrice).mul(groupCount);
-      const promoItems = result.filter(p => p.inPromotion);
-      let actualPromoTotal = new _decimal.default(0);
+      const expectedPromoTotal = new import_decimal.default(groupPrice).mul(groupCount);
+      const promoItems = result.filter((p) => p.inPromotion);
+      let actualPromoTotal = new import_decimal.default(0);
       for (const p of promoItems) {
-        actualPromoTotal = actualPromoTotal.plus(new _decimal.default(p.finalPrice).mul(p.quantity));
+        actualPromoTotal = actualPromoTotal.plus(
+          new import_decimal.default(p.finalPrice).mul(p.quantity)
+        );
       }
       const roundingDiff = actualPromoTotal.minus(expectedPromoTotal);
       if (!roundingDiff.eq(0)) {
-        // 优先找 quantity=1 的促销商品调整（差额直接加减到单价上）
-        const adjustTarget = promoItems.find(p => p.quantity === 1);
+        const adjustTarget = promoItems.find((p) => p.quantity === 1);
         if (adjustTarget) {
-          adjustTarget.finalPrice = this.formatPrice(new _decimal.default(adjustTarget.finalPrice).minus(roundingDiff));
+          adjustTarget.finalPrice = this.formatPrice(
+            new import_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 _decimal.default(lastPromo.finalPrice).minus(roundingDiff));
-
-          // 原商品减少1件
+          const adjustedUnitPrice = this.formatPrice(
+            new import_decimal.default(lastPromo.finalPrice).minus(roundingDiff)
+          );
           lastPromo.quantity -= 1;
           lastPromo.isSplit = true;
-
-          // 拆出1件用调整后的价格
           result.push({
             ...lastPromo,
             id: this.generateRandomId(),
@@ -781,11 +678,11 @@ class PromotionEvaluator {
             isSplit: true
           });
         }
-
-        // 重新计算 finalAmount
-        finalAmount = new _decimal.default(0);
+        finalAmount = new import_decimal.default(0);
         for (const p of result) {
-          finalAmount = finalAmount.plus(new _decimal.default(p.finalPrice).mul(p.quantity));
+          finalAmount = finalAmount.plus(
+            new import_decimal.default(p.finalPrice).mul(p.quantity)
+          );
         }
       }
     }
@@ -795,7 +692,6 @@ class PromotionEvaluator {
       finalAmount: finalAmount.toNumber()
     };
   }
-
   /**
    * 处理 买X送Y 促销
    *
@@ -811,56 +707,34 @@ class PromotionEvaluator {
       products: groupProducts
     } = group;
     const detail = actionDetail;
-    const {
-      buyQuantity,
-      freeQuantity,
-      cumulative,
-      giftProducts
-    } = detail;
+    const { buyQuantity, freeQuantity, cumulative, giftProducts } = detail;
     const result = [];
-    let originalAmount = new _decimal.default(0);
-    let finalAmount = new _decimal.default(0);
-
-    // 1. 先计算可用商品总数量（第一次遍历）
-    // 对于 bundle 子商品匹配，促销数量 = 主商品数量 × bundle子商品数量
+    let originalAmount = new import_decimal.default(0);
+    let finalAmount = new import_decimal.default(0);
     let totalPromoQty = 0;
-    const productInfoMap = new Map();
+    const productInfoMap = /* @__PURE__ */ 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;
-
-      // 获取 matchedBundleIndex
-      const matchedBundleIndex = matchedBundleIndexMap?.get(product.id);
-
-      // 计算用于促销的数量
+      if (availableQty <= 0)
+        continue;
+      const matchedBundleIndex = matchedBundleIndexMap == null ? void 0 : matchedBundleIndexMap.get(product.id);
       let promoQty = availableQty;
-      if (matchedBundleIndex !== undefined && product.bundle) {
+      if (matchedBundleIndex !== void 0 && 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,
@@ -872,21 +746,15 @@ class PromotionEvaluator {
         isSplit: info.availableQty < product.quantity,
         matchedBundleIndex: info.matchedBundleIndex
       });
-      const amount = new _decimal.default(product.price).mul(info.availableQty);
+      const amount = new import_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,
@@ -900,7 +768,6 @@ class PromotionEvaluator {
       giftInfo
     };
   }
-
   /**
    * 获取未参与任何促销的商品
    */
@@ -915,7 +782,7 @@ class PromotionEvaluator {
           ...product,
           quantity: remainingQty,
           finalPrice: this.formatPrice(product.price),
-          strategyId: undefined,
+          strategyId: void 0,
           inPromotion: false,
           isSplit: remainingQty < product.quantity
         });
@@ -923,14 +790,12 @@ class PromotionEvaluator {
     }
     return result;
   }
-
   /**
    * 价格统一保留两位小数
    */
   formatPrice(value) {
-    return new _decimal.default(value).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+    return new import_decimal.default(value).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
   }
-
   /**
    * 获取商品唯一标识 key
    * 使用商品的 id 作为唯一标识，不同 id 的商品不会被合并
@@ -938,107 +803,92 @@ class PromotionEvaluator {
   getProductKey(product) {
     return String(product.id);
   }
-
   /**
    * 生成随机ID
    */
   generateRandomId() {
-    return Math.floor(Math.random() * 1000000000) + Date.now();
+    return Math.floor(Math.random() * 1e9) + 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) {
-    if (!config?.conditions?.rules) {
+    var _a;
+    if (!((_a = config == null ? void 0 : config.conditions) == null ? void 0 : _a.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 => {
-      // 首先检查 product_id
+    return configProducts.some((config) => {
       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 (custom?.display?.product_card) {
+    if ((_a = custom == null ? void 0 : custom.display) == null ? void 0 : _a.product_card) {
       return {
         text: custom.display.product_card.text,
         type: custom.display.product_card.type
       };
     }
-    return undefined;
+    return void 0;
   }
-}
-exports.PromotionEvaluator = PromotionEvaluator;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PromotionEvaluator
+});