@pisell/pisellos 2.2.58 → 2.2.60

package/dist/modules/Rules/index.js

@@ -201,6 +201,13 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         productList: hasApplicableDiscount ? result.productList : productList
       };
     }
+  }, {
+    key: "filterDiscountListByType",
+    value: function filterDiscountListByType(discountList, type) {
+      return (discountList || []).filter(function (item) {
+        return item.type === type || item.tag === type;
+      });
+    }
   }, {
     key: "calcDiscount",
     value: function calcDiscount(_ref2, options) {
@@ -953,6 +960,9 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           }) && (!((_product$discount_lis5 = product.discount_list) !== null && _product$discount_lis5 !== void 0 && _product$discount_lis5.length) || ((_product11 = product) === null || _product11 === void 0 || (_product11 = _product11.discount_list) === null || _product11 === void 0 || (_product11$every = _product11.every) === null || _product11$every === void 0 ? void 0 : _product11$every.call(_product11, function (item) {
             return item.type === 'product';
           })));
+          if (product.inPromotion) {
+            isManualDiscount = false;
+          }
         } else {
           // bundle子商品：判断父主商品是否手动折扣
           var parentProduct = flatItem.parentProduct;
@@ -1048,25 +1058,27 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
                 }),
                 price: product.price
               }), {}, {
-                discount_list: []
+                discount_list: _this3.filterDiscountListByType(product.discount_list, 'promotion')
               }))]);
             } else {
+              var _ref7, _product$_promotion$f, _product12;
               processedProductsMap.set(product._id, [_this3.hooks.setProduct(originProduct, _objectSpread(_objectSpread({}, isManualDiscount ? {
                 price: product.price,
                 main_product_selling_price: product.price
               } : {
                 _id: product._id.split('___')[0] + '___' + index,
-                total: product.origin_total || product.total,
+                total: product.inPromotion ? (_ref7 = (_product$_promotion$f = (_product12 = product) === null || _product12 === void 0 || (_product12 = _product12._promotion) === null || _product12 === void 0 ? void 0 : _product12.finalPrice) !== null && _product$_promotion$f !== void 0 ? _product$_promotion$f : product.origin_total) !== null && _ref7 !== void 0 ? _ref7 : product.total : product.origin_total || product.total,
                 price: product.price,
                 main_product_selling_price: product.price
               }), {}, {
-                discount_list: []
+                discount_list: _this3.filterDiscountListByType(product.discount_list, 'promotion')
               }))]);
             }
           } else {
+            var _flatItem$bundleItem8;
             // bundle子商品：保存到扁平化Map
             processedFlatItemsMap.set(flatItem._id, [_objectSpread(_objectSpread({}, flatItem), {}, {
-              discount_list: [],
+              discount_list: _this3.filterDiscountListByType(((_flatItem$bundleItem8 = flatItem.bundleItem) === null || _flatItem$bundleItem8 === void 0 ? void 0 : _flatItem$bundleItem8.discount_list) || [], 'promotion'),
               price: isManualDiscount ? flatItem.bundleItem.price : flatItem.bundleItem.original_price,
               processed: true
             })]);
@@ -1099,14 +1111,14 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           // 主商品：保持原有逻辑
           if (splitCount < totalQuantity && isNeedSplit) {
             arr.push(_this3.hooks.setProduct(originProduct, {
-              discount_list: [],
+              discount_list: _this3.filterDiscountListByType(product.discount_list, 'promotion'),
               quantity: totalQuantity - splitCount,
               _id: product._id.split('___')[0],
               total: product.origin_total || product.total
             }));
           }
           for (var i = 0; i < splitCount; i++) {
-            var _product$discount_lis10, _originProduct, _selectedDiscount$met, _selectedDiscount$met2;
+            var _originProduct, _selectedDiscount$met, _selectedDiscount$met2;
             // 如果用过折扣卡，也就不存在拆分的情况了，这里直接使用上面计算出来的折扣卡
             var _selectedDiscount = selectedDiscountCard || applicableDiscounts[i];
             // 标记优惠券为已使用
@@ -1123,7 +1135,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
             // 优先从 origin_total拿，可能会拿不到（比如用户端预约在没有配置 original_price 的情况下）
             var productOriginTotal = product.origin_total || product.total || 0;
             // 如果当前 product 有 discount_list，则先从 origin_total 拿
-            if ((_product$discount_lis10 = product.discount_list) !== null && _product$discount_lis10 !== void 0 && _product$discount_lis10.length && product.origin_total) {
+            if (_this3.filterDiscountListByType(product.discount_list, 'promotion').length && product.origin_total) {
               productOriginTotal = product.origin_total;
             }
             // 如果originProduct?._productInit?.original_price为 0，product.origin_total可能为空，此时取 product.total
@@ -1205,7 +1217,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
               }));
             } else {
               arr.push(_this3.hooks.setProduct(originProduct, {
-                discount_list: [discountDetail],
+                discount_list: _this3.filterDiscountListByType(product.discount_list, 'promotion').concat([discountDetail]),
                 _id: product._id.split('___')[0] + '___' + _selectedDiscount.id + index,
                 price: _selectedDiscount.tag === 'good_pass' ? 0 : product.price,
                 quantity: isNeedSplit ? 1 : product.quantity,
@@ -1376,7 +1388,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
             var getDefaultProduct = function getDefaultProduct() {
               if (product.isClient) {
                 return _this3.hooks.setProduct(originProduct, {
-                  discount_list: [],
+                  discount_list: _this3.filterDiscountListByType(product.discount_list, 'promotion'),
                   price: product.price,
                   origin_total: getProductOriginTotalPrice({
                     product: {
@@ -1397,7 +1409,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
                 });
               } else {
                 return _this3.hooks.setProduct(originProduct, {
-                  discount_list: [],
+                  discount_list: _this3.filterDiscountListByType(product.discount_list, 'promotion'),
                   total: product.total,
                   origin_total: product.origin_total,
                   price: product.price
@@ -1567,8 +1579,8 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
                 quantity: 1,
                 discount_list: updatedMainDiscountList,
                 bundle: newBundleWithDiscount,
-                total: new Decimal(newTotalWithDiscount).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber(),
-                origin_total: new Decimal(newOriginTotalWithDiscount).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber()
+                total: newTotalWithDiscount,
+                origin_total: newOriginTotalWithDiscount
               })));
 
               // 第二个：包含原始bundle (qty=原quantity-1)
@@ -1630,8 +1642,6 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
                     return accumulator.add(currentPrice.mul(currentNum));
                   }, new Decimal(newTotalOriginal)).toNumber();
                 }
-                newTotalOriginal = new Decimal(newTotalOriginal).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber();
-                newOriginTotalOriginal = new Decimal(newOriginTotalOriginal).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber();
 
                 // 添加第二个主商品：qty=原quantity-1，包含原始bundle
                 result.push(_this3.hooks.setProduct(mainProduct, _objectSpread(_objectSpread({}, mainProductData), {}, {
@@ -1736,8 +1746,6 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
                     return accumulator.add(currentPrice.mul(currentNum));
                   }, new Decimal(newTotal)).toNumber();
                 }
-                newTotal = new Decimal(newTotal).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber();
-                newOriginTotal = new Decimal(newOriginTotal).toDecimalPlaces(2, Decimal.ROUND_HALF_UP).toNumber();
 
                 // 生成最终的主商品
                 result.push(_this3.hooks.setProduct(mainProduct, _objectSpread(_objectSpread({}, mainProductData), {}, {
@@ -1857,10 +1865,10 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           return true; // 单独购买时可用
         }
         if (isBundleItem) {
-          var _flatItem$bundleItem8, _flatItem$bundleItem9;
+          var _flatItem$bundleItem9, _flatItem$bundleItem10;
           // 套餐中购买时，判断是否为原价
-          var priceType = (_flatItem$bundleItem8 = flatItem.bundleItem) === null || _flatItem$bundleItem8 === void 0 ? void 0 : _flatItem$bundleItem8.price_type;
-          var priceTypeExt = (_flatItem$bundleItem9 = flatItem.bundleItem) === null || _flatItem$bundleItem9 === void 0 ? void 0 : _flatItem$bundleItem9.price_type_ext;
+          var priceType = (_flatItem$bundleItem9 = flatItem.bundleItem) === null || _flatItem$bundleItem9 === void 0 ? void 0 : _flatItem$bundleItem9.price_type;
+          var priceTypeExt = (_flatItem$bundleItem10 = flatItem.bundleItem) === null || _flatItem$bundleItem10 === void 0 ? void 0 : _flatItem$bundleItem10.price_type_ext;
           // original_price 对应：
           // 1. price_type: "markup" && price_type_ext: "product_price"
           // markup_price 对应：
@@ -1898,10 +1906,10 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           return false; // 单独购买时不可用
         }
         if (isBundleItem) {
-          var _flatItem$bundleItem10, _flatItem$bundleItem11;
+          var _flatItem$bundleItem11, _flatItem$bundleItem12;
           // 套餐中购买时，判断是否为原价
-          var _priceType = (_flatItem$bundleItem10 = flatItem.bundleItem) === null || _flatItem$bundleItem10 === void 0 ? void 0 : _flatItem$bundleItem10.price_type;
-          var _priceTypeExt = (_flatItem$bundleItem11 = flatItem.bundleItem) === null || _flatItem$bundleItem11 === void 0 ? void 0 : _flatItem$bundleItem11.price_type_ext;
+          var _priceType = (_flatItem$bundleItem11 = flatItem.bundleItem) === null || _flatItem$bundleItem11 === void 0 ? void 0 : _flatItem$bundleItem11.price_type;
+          var _priceTypeExt = (_flatItem$bundleItem12 = flatItem.bundleItem) === null || _flatItem$bundleItem12 === void 0 ? void 0 : _flatItem$bundleItem12.price_type_ext;
 
           // original_price 对应：
           // 1. price_type: "markup" && price_type_ext: "product_price"

package/dist/modules/Schedule/index.d.ts

@@ -33,7 +33,7 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     isInScheduleByDate({ date, schedule, }: {
         date: string;
         schedule: any;
-    }): boolean;
+    }): boolean | undefined;
     /**
      * 传入一个时间, 判断改时间是否在schedule 内
      * @param param0 { date: string, schedule: any } date: 日期, schedule: schedule
@@ -42,5 +42,5 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     static isInScheduleByDate({ date, schedule, }: {
         date: string;
         schedule: any;
-    }): boolean;
+    }): boolean | undefined;
 }

package/dist/modules/Schedule/index.js

@@ -27,7 +27,6 @@ import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
 import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
 import { generateMonthDates, disableAllDates, disableDatesBeforeOneDay } from "../Date/utils";
 import { calcScheduleDateRange } from "./utils";
-import { getDateIsInSchedule } from "./getDateIsInSchedule";
 dayjs.extend(isSameOrBefore);
 dayjs.extend(isSameOrAfter);
 export var ScheduleModule = /*#__PURE__*/function (_BaseModule) {
@@ -271,7 +270,6 @@ export var ScheduleModule = /*#__PURE__*/function (_BaseModule) {
       var _schedule$repeat_rule, _schedule$repeat_rule2;
       var date = _ref3.date,
         schedule = _ref3.schedule;
-      return getDateIsInSchedule(date, [schedule]);
       if (schedule.start_time && schedule.end_time) {
         var isBeforeStartTime = dayjs(date).isBefore(dayjs(schedule.start_time));
         var isAfterEndTime = dayjs(date).isAfter(dayjs(schedule.end_time));

package/dist/solution/BookingByStep/index.js

@@ -1161,6 +1161,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
       var productData = _objectSpread(_objectSpread({}, origin), {}, {
         product_variant_id: product_variant_id
       });
+      debugger;
       // 保护，如果进来的是 session 商品，则必须要有 date 和时间片，否则不允许添加
       if (isSessionProduct(productData)) {
         if (!date || !date.startTime || !date.endTime) {

package/dist/solution/Checkout/index.js

@@ -760,7 +760,6 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
         return _regeneratorRuntime().wrap(function _callee10$(_context10) {
           while (1) switch (_context10.prev = _context10.next) {
             case 0:
-              this.payment.wallet.clearAllCache();
               this.logInfo('updateLocalOrderAsync called', {
                 orderId: params.orderId,
                 orderDataType: (_params$orderData6 = params.orderData) === null || _params$orderData6 === void 0 ? void 0 : _params$orderData6.type,
@@ -772,11 +771,11 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               // 基础校验
               validation = validateLocalOrderData(params.orderData);
               if (validation.valid) {
-                _context10.next = 5;
+                _context10.next = 4;
                 break;
               }
               throw createCheckoutError(CheckoutErrorType.ValidationFailed, "\u8BA2\u5355\u6570\u636E\u9A8C\u8BC1\u5931\u8D25: ".concat(validation.errors.join(', ')));
-            case 5:
+            case 4:
               // 计算金额
               amountInfo = extractAmountFromCartSummary(params.cartSummary); // 规范化补充字段
               params.orderData.created_at = formatDateTime(new Date());
@@ -802,19 +801,19 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }
 
               // 保留原有支付项：通过 orderId 找到现有订单（按 id 或 order_id 匹配）
-              _context10.next = 18;
+              _context10.next = 17;
               return this.payment.getOrderListAsync();
-            case 18:
+            case 17:
               allOrders = _context10.sent;
               existingOrder = allOrders.find(function (o) {
                 return String(o.id) === String(params.orderId) || String(o.order_id) === String(params.orderId);
               });
               if (!existingOrder) {
-                _context10.next = 72;
+                _context10.next = 71;
                 break;
               }
               if (!(params.existPayment && params.existPayment.length > 0)) {
-                _context10.next = 48;
+                _context10.next = 47;
                 break;
               }
               this.logInfo('检测到云端支付项，将替换本地订单的支付项列表', {
@@ -838,7 +837,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 });
               }); // 计算是否需要支付定金
               _isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products); // 更新订单，替换支付项列表
-              _context10.next = 29;
+              _context10.next = 28;
               return this.payment.updateOrderAsync(existingOrder.uuid, {
                 total_amount: amountInfo.totalAmount,
                 is_deposit: _isNeedDeposit.hasDeposit ? 1 : 0,
@@ -856,21 +855,21 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   amount_breakdown: amountInfo
                 }
               });
-            case 29:
-              _context10.next = 31;
+            case 28:
+              _context10.next = 30;
               return this.payment.getPaymentOrderByUuidAsync(existingOrder.uuid);
-            case 31:
+            case 30:
               _updated = _context10.sent;
               if (_updated) {
-                _context10.next = 34;
+                _context10.next = 33;
                 break;
               }
               throw createCheckoutError(CheckoutErrorType.UnknownError, '订单更新失败');
-            case 34:
+            case 33:
               this.store.currentOrder = _updated;
-              _context10.next = 37;
+              _context10.next = 36;
               return this.updateStateAmountToRemaining(false);
-            case 37:
+            case 36:
               this.logInfo('本地订单更新成功(已替换云端支付项):', {
                 orderId: params.orderId,
                 uuid: _updated.uuid,
@@ -881,12 +880,12 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
 
               // 事件通知
-              _context10.next = 40;
+              _context10.next = 39;
               return this.core.effects.emit("".concat(this.name, ":onOrderCreated"), {
                 order: _updated,
                 timestamp: Date.now()
               });
-            case 40:
+            case 39:
               // 计算已同步的支付金额
               syncedPayments = _updated.payment.filter(function (p) {
                 return p.isSynced && p.status !== 'voided';
@@ -906,7 +905,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 order_wait_pay_amount: Number(_depositDiffAmount) > 0 ? Number(_depositDiffAmount) : Number(_remainingExpectAmount)
               });
               return _context10.abrupt("return", _updated);
-            case 48:
+            case 47:
               // 原有逻辑：保留现有支付项
               totalAmount = new Decimal(amountInfo.totalAmount || '0');
               activePayments = (existingOrder.payment || []).filter(function (p) {
@@ -919,7 +918,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               }, new Decimal(0));
               remaining = Decimal.max(0, totalAmount.minus(paidAmount)).toFixed(2); // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
               _isNeedDeposit2 = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products); // 更新到支付模块（使用 uuid，不修改 payment 列表）
-              _context10.next = 55;
+              _context10.next = 54;
               return this.payment.updateOrderAsync(existingOrder.uuid, {
                 total_amount: amountInfo.totalAmount,
                 is_deposit: _isNeedDeposit2.hasDeposit ? 1 : 0,
@@ -936,21 +935,21 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   amount_breakdown: amountInfo
                 }
               });
-            case 55:
-              _context10.next = 57;
+            case 54:
+              _context10.next = 56;
               return this.payment.getPaymentOrderByUuidAsync(existingOrder.uuid);
-            case 57:
+            case 56:
               updated = _context10.sent;
               if (updated) {
-                _context10.next = 60;
+                _context10.next = 59;
                 break;
               }
               throw createCheckoutError(CheckoutErrorType.UnknownError, '订单更新失败');
-            case 60:
+            case 59:
               this.store.currentOrder = updated;
-              _context10.next = 63;
+              _context10.next = 62;
               return this.updateStateAmountToRemaining(false);
-            case 63:
+            case 62:
               this.logInfo('本地订单更新成功(保留支付项):', {
                 orderId: params.orderId,
                 uuid: updated.uuid,
@@ -960,12 +959,12 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
               });
 
               // 事件通知（复用创建事件，便于上层监听刷新）
-              _context10.next = 66;
+              _context10.next = 65;
               return this.core.effects.emit("".concat(this.name, ":onOrderCreated"), {
                 order: updated,
                 timestamp: Date.now()
               });
-            case 66:
+            case 65:
               // 需要减去已经同步给后端的支付过的钱
               syncedAmount = activePayments.reduce(function (sum, p) {
                 var amt = new Decimal(p.amount || '0');
@@ -981,10 +980,10 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 order_wait_pay_amount: Number(depositDiffAmount) > 0 ? Number(depositDiffAmount) : Number(remainingExpectAmount)
               });
               return _context10.abrupt("return", updated);
-            case 72:
+            case 71:
               // 计算是否需要支付定金，如果需要默认切换到定金模式，以及记录定金总金额，并把当前默认待付金额调整为定金总金额
               isNeedDeposit = this.checkIsNeedDepositAsync(params.orderData.bookings, params.orderData.relation_products); // 没找到现有订单时，回退为创建逻辑（用于异常兜底）
-              _context10.next = 75;
+              _context10.next = 74;
               return this.payment.createPaymentOrderAsync({
                 order_id: String(params.orderId),
                 total_amount: amountInfo.totalAmount,
@@ -1003,7 +1002,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                   amount_breakdown: amountInfo
                 }
               });
-            case 75:
+            case 74:
               created = _context10.sent;
               this.store.currentOrder = created;
 
@@ -1039,7 +1038,7 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
                 this.initWalletData();
               }
               return _context10.abrupt("return", created);
-            case 79:
+            case 78:
             case "end":
               return _context10.stop();
           }
@@ -3128,14 +3127,13 @@ export var CheckoutImpl = /*#__PURE__*/function (_BaseModule) {
         return payment.status !== 'voided';
       }) // 只计算未撤销的支付项
       .reduce(function (sum, payment) {
-        // const amount = new Decimal(payment.amount || '0');
-        // 计算有效支付金额：支付金额 + 抹零金额的绝对值
-        // 当 rounding_amount 为负数时，表示抹掉的金额，按绝对值计算有效支付
-        // 例如：amount=15, rounding_amount=-0.2，有效支付=15.2（抹掉0.2元零头）
-        // 例2：amount=15,rounding_amount=0.2,有效支付 14.8 
-        var paymentAmount = new Decimal(payment.amount || 0);
-        var roundingAmount = new Decimal(payment.rounding_amount || 0);
-        var effectiveAmount = paymentAmount.minus(roundingAmount);
+        var amount = new Decimal(payment.amount || '0');
+        var roundingAmount = new Decimal(payment.rounding_amount || '0');
+
+        // 使用 Decimal.js 计算实际支付有效金额：
+        // 当 rounding_amount 为负数时，表示抹掉的金额，应该按绝对值加到实际支付中
+        // 例如：amount=15, rounding_amount=-0.2，实际相当于支付了15.2（抹掉了0.2元的零头）
+        var effectiveAmount = amount.add(roundingAmount.isNegative() ? roundingAmount.abs() : 0);
         return sum.add(effectiveAmount);
       }, new Decimal(0));
       return paidAmount.toFixed(2);

package/lib/model/strategy/adapter/index.d.ts

@@ -1,3 +1,5 @@
 export * from './type';
 export { default as WalletPassAdapter } from './walletPass';
 export { WalletPassEvaluator } from './walletPass/evaluator';
+import { PromotionEvaluator, PromotionAdapter } from './promotion';
+export { PromotionEvaluator, PromotionAdapter };

package/lib/model/strategy/adapter/index.js

@@ -30,6 +30,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/model/strategy/adapter/index.ts
 var adapter_exports = {};
 __export(adapter_exports, {
+  PromotionAdapter: () => import_promotion.PromotionAdapter,
+  PromotionEvaluator: () => import_promotion.PromotionEvaluator,
   WalletPassAdapter: () => import_walletPass.default,
   WalletPassEvaluator: () => import_evaluator.WalletPassEvaluator
 });
@@ -37,8 +39,11 @@ module.exports = __toCommonJS(adapter_exports);
 __reExport(adapter_exports, require("./type"), module.exports);
 var import_walletPass = __toESM(require("./walletPass"));
 var import_evaluator = require("./walletPass/evaluator");
+var import_promotion = require("./promotion");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  PromotionAdapter,
+  PromotionEvaluator,
   WalletPassAdapter,
   WalletPassEvaluator,
   ...require("./type")

package/lib/model/strategy/adapter/promotion/evaluator.d.ts

@@ -0,0 +1,213 @@
+import type { StrategyConfig } from '../../type';
+import { type PromotionProduct, type PromotionActionDetail, type PromotionEvaluatorInput, type ProductPromotionResult, type ApplicablePromotion, type CartEvaluationResult, type CartWithPricingResult } from './type';
+/**
+ * Promotion 评估器
+ *
+ * 用于评估商品适用的促销活动
+ * 封装了 StrategyEngine 和 PromotionAdapter 的调用逻辑
+ */
+export declare class PromotionEvaluator {
+    private engine;
+    private adapter;
+    private strategyConfigs;
+    private locale;
+    private locales;
+    constructor();
+    /**
+     * 设置策略配置列表
+     */
+    setStrategyConfigs(strategyConfigs: StrategyConfig[]): void;
+    /**
+     * 获取策略配置列表
+     */
+    getStrategyConfigs(): StrategyConfig[];
+    /**
+     * 添加策略配置
+     */
+    addStrategyConfig(strategyConfig: StrategyConfig): void;
+    /**
+     * 设置语言
+     */
+    setLocale(locale: string): void;
+    /**
+     * 设置自定义多语言文案
+     */
+    setLocales(locales: Record<string, Record<string, string>>): void;
+    /**
+     * 获取多语言文案
+     */
+    getText(key: string): string;
+    /**
+     * 获取多语言名称
+     */
+    getLocalizedName(name: string | Record<string, string>): string;
+    /**
+     * 评估商品列表
+     *
+     * 判断每个商品适用哪些促销活动
+     * 支持主商品和 bundle 子商品的匹配
+     *
+     * @param input 评估输入
+     * @returns 每个商品的促销评估结果
+     */
+    evaluateProducts(input: PromotionEvaluatorInput): ProductPromotionResult[];
+    /**
+     * 评估购物车
+     *
+     * 返回所有适用的促销及按促销分组的商品
+     * 支持 bundle 子商品的数量计算（主商品数量 × 子商品数量）
+     *
+     * @param input 评估输入
+     * @returns 购物车评估结果
+     */
+    evaluateCart(input: PromotionEvaluatorInput): CartEvaluationResult;
+    /**
+     * 评估购物车并计算定价
+     *
+     * 返回处理后的商品数组（包含拆分、finalPrice）和赠品信息
+     * - 对于 X_ITEMS_FOR_Y_PRICE：按原价比例均摊价格，优先使用高价商品
+     * - 对于 BUY_X_GET_Y_FREE：计算赠品数量和可选赠品列表
+     *
+     * @param input 评估输入
+     * @returns 带定价的购物车评估结果
+     */
+    evaluateCartWithPricing(input: PromotionEvaluatorInput): CartWithPricingResult;
+    /**
+     * 获取商品适用的促销列表
+     *
+     * 简化方法，用于商品卡片展示
+     *
+     * @param product 商品
+     * @param strategyConfigs 策略配置（可选）
+     * @returns 适用的促销列表
+     */
+    getProductPromotions(product: PromotionProduct, strategyConfigs?: StrategyConfig[]): ApplicablePromotion[];
+    /**
+     * 获取商品的促销标签
+     *
+     * 用于商品卡片展示
+     *
+     * @param product 商品
+     * @param strategyConfigs 策略配置（可选）
+     * @returns 促销标签列表
+     */
+    getProductPromotionTags(product: PromotionProduct, strategyConfigs?: StrategyConfig[]): Array<{
+        text: string;
+        type: string;
+        strategyId: string;
+    }>;
+    /**
+     * 查找商品适用的策略配置
+     *
+     * @param product 商品
+     * @param strategyConfigs 策略配置列表（可选）
+     * @returns 适用的策略配置列表
+     */
+    findApplicableStrategies(product: PromotionProduct, strategyConfigs?: StrategyConfig[]): StrategyConfig[];
+    /**
+     * 批量获取商品列表的适用策略信息
+     *
+     * 用于给商品列表追加策略标签信息
+     * 只检查商品 ID 匹配和策略时间范围
+     *
+     * @param input 评估输入（商品列表）
+     * @param matchVariant 是否需要匹配 product_variant_id，默认 true（严格匹配），false 时只匹配 product_id
+     * @returns 每个商品的适用策略完整数据
+     */
+    getProductsApplicableStrategies(input: PromotionEvaluatorInput, matchVariant?: boolean): Array<{
+        product: PromotionProduct;
+        applicableStrategies: Array<{
+            strategyId: string;
+            strategyName: string | Record<string, string>;
+            strategyMetadata: any;
+            actionType: string;
+            actionDetail: PromotionActionDetail;
+            display?: {
+                text: string | Record<string, string>;
+                type: string;
+            };
+            strategyConfig: StrategyConfig;
+            /** 满足促销所需的商品数量 */
+            requiredQuantity: number;
+            /** 可参与此促销的商品列表 */
+            eligibleProducts: Array<{
+                product_id: number;
+                product_variant_id: number;
+            }>;
+        }>;
+        hasApplicableStrategy: boolean;
+    }>;
+    /**
+     * 获取促销所需数量和可参与商品列表
+     *
+     * @param actionType 促销类型
+     * @param actionDetail 促销详情
+     * @param config 策略配置
+     * @returns { requiredQuantity, eligibleProducts }
+     */
+    private getPromotionRequirements;
+    /**
+     * 按优先级排序促销组
+     * 优先级从 strategyConfig.actions[0].priority 获取，数值越小优先级越高
+     */
+    private sortPromotionGroupsByPriority;
+    /**
+     * 处理 X件Y元 促销
+     *
+     * 1. 展开商品为单件列表，按价格从高到低排序
+     * 2. 计算可凑成的组数
+     * 3. 按原价比例均摊价格
+     * 4. 拆分商品（部分参与促销、部分原价）
+     *
+     * 注意：每个商品按 id 独立处理，不会合并不同 id 的商品
+     */
+    private processXItemsForYPrice;
+    /**
+     * 处理 买X送Y 促销
+     *
+     * 计算赠品数量，商品本身价格不变
+     * 支持 bundle 子商品的数量计算（主商品数量 × 子商品数量）
+     */
+    private processBuyXGetYFree;
+    /**
+     * 获取未参与任何促销的商品
+     */
+    private getRemainingProducts;
+    /**
+     * 价格统一保留两位小数
+     */
+    private formatPrice;
+    /**
+     * 获取商品唯一标识 key
+     * 使用商品的 id 作为唯一标识，不同 id 的商品不会被合并
+     */
+    private getProductKey;
+    /**
+     * 生成随机ID
+     */
+    private generateRandomId;
+    /**
+     * 商品匹配结果信息
+     */
+    private getProductMatchInfo;
+    /**
+     * 检查商品是否在策略的适用范围内
+     */
+    private isProductInStrategy;
+    /**
+     * 查找商品匹配规则
+     */
+    private findProductMatchRule;
+    /**
+     * 检查商品ID是否匹配配置列表
+     */
+    private isProductIdMatch;
+    /**
+     * 检查商品是否匹配配置（兼容旧方法）
+     */
+    private isProductMatch;
+    /**
+     * 获取展示配置
+     */
+    private getDisplayConfig;
+}