@pisell/pisellos 2.3.37 → 2.3.38

package/dist/core/index.d.ts

@@ -28,6 +28,8 @@ declare class PisellOSCore implements PisellCore {
     getModule<T extends Module>(name: string): T | null;
     getModuleExports<T = any>(name: string): T | null;
     hasModule(name: string): boolean;
+    /** 返回当前已注册模块名，供宿主在切换店铺等生命周期中定向清理运行态。 */
+    getModuleNames(): string[];
     destroy(): Promise<void>;
     setContext(ctx: Partial<BusinessContext>): void;
     /**

package/dist/core/index.js

@@ -300,6 +300,13 @@ var PisellOSCore = /*#__PURE__*/function () {
       return this.modules.has(name);
     }
 
+    /** 返回当前已注册模块名，供宿主在切换店铺等生命周期中定向清理运行态。 */
+  }, {
+    key: "getModuleNames",
+    value: function getModuleNames() {
+      return Array.from(this.modules.keys());
+    }
+
     // 销毁方法
   }, {
     key: "destroy",

package/dist/model/strategy/adapter/promotion/adapter.d.ts

@@ -48,6 +48,10 @@ export declare class PromotionAdapter implements BusinessAdapter {
      * 解析 买X送Y Action
      */
     private parseBuyXGetYFreeAction;
+    /**
+     * 解析 商品奖励 Action
+     */
+    private parseItemRewardAction;
     /**
      * 获取适用的商品列表
      *

package/dist/model/strategy/adapter/promotion/adapter.js

@@ -162,6 +162,8 @@ export var PromotionAdapter = /*#__PURE__*/function () {
           return this.parseXItemsForYPriceAction(action);
         case PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE:
           return this.parseBuyXGetYFreeAction(action);
+        case PROMOTION_ACTION_TYPES.ITEM_REWARD:
+          return this.parseItemRewardAction(action);
         default:
           return undefined;
       }
@@ -204,6 +206,27 @@ export var PromotionAdapter = /*#__PURE__*/function () {
       };
     }
 
+    /**
+     * 解析 商品奖励 Action
+     */
+  }, {
+    key: "parseItemRewardAction",
+    value: function parseItemRewardAction(action) {
+      var value = action.value || {};
+      var config = action.config || {};
+      return {
+        type: PROMOTION_ACTION_TYPES.ITEM_REWARD,
+        rewardMethod: value.rewardMethod || 'free',
+        rewardValue: Number(value.rewardValue || 0),
+        quantityRule: value.quantityRule || 'per_condition_quantity',
+        triggerQuantity: Number(value.triggerQuantity || 1),
+        rewardQuantity: Number(value.rewardQuantity || 1),
+        maxRewardQuantity: value.maxRewardQuantity === undefined || value.maxRewardQuantity === null ? undefined : Number(value.maxRewardQuantity),
+        rewardTargets: Array.isArray(config.rewardTargets) ? config.rewardTargets : [],
+        targetSelection: config.targetSelection || 'consumer_best'
+      };
+    }
+
     /**
      * 获取适用的商品列表
      *

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

@@ -169,6 +169,21 @@ export declare class PromotionEvaluator {
      * 支持 bundle 子商品的数量计算（主商品数量 × 子商品数量）
      */
     private processBuyXGetYFree;
+    /**
+     * 处理 商品奖励 促销
+     *
+     * 1. 使用 group.products 统计触发条件商品数量
+     * 2. 按 quantityRule 计算最多奖励的目标商品数量
+     * 3. 在全购物车商品中筛选 rewardTargets
+     * 4. 按消费者最优（可节省金额从高到低）选择目标单位
+     * 5. 对目标商品拆分并写入 finalPrice，触发商品本身不改价
+     */
+    private processItemReward;
+    private normalizePositiveInteger;
+    private getAvailablePromotionQuantity;
+    private buildItemRewardTargetUnits;
+    private resolveItemRewardFinalPrice;
+    private resolveItemRewardLimit;
     /**
      * 获取未参与任何促销的商品
      */
@@ -194,6 +209,8 @@ export declare class PromotionEvaluator {
      * 检查商品是否在策略的适用范围内
      */
     private isProductInStrategy;
+    private shouldSkipStrategyForProduct;
+    private hasActionType;
     /**
      * 查找商品匹配规则
      */

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

@@ -178,6 +178,10 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
           try {
             for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
               var config = _step2.value;
+              if (this.shouldSkipStrategyForProduct(product, config)) {
+                continue;
+              }
+
               // 1. 先用 getProductMatchInfo 检查商品是否在策略的适用范围内（包含 bundle 子商品检查）
               var matchInfo = this.getProductMatchInfo(product, config);
               if (!matchInfo.isMatch) {
@@ -400,6 +404,12 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
             if (_result.giftInfo) {
               gifts.push(_result.giftInfo);
             }
+          } else if (actionType === PROMOTION_ACTION_TYPES.ITEM_REWARD) {
+            // 商品奖励处理：条件商品触发，目标商品行享优惠，不自动新增商品
+            var _result2 = this.processItemReward(group, processedQuantityMap, products, matchedBundleIndexMap);
+            pricedProducts.push.apply(pricedProducts, _toConsumableArray(_result2.products));
+            totalOriginalAmount = totalOriginalAmount.plus(_result2.originalAmount);
+            totalFinalAmount = totalFinalAmount.plus(_result2.finalAmount);
           }
         }
 
@@ -530,6 +540,9 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
           try {
             for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
               var config = _step8.value;
+              if (_this3.shouldSkipStrategyForProduct(product, config)) {
+                continue;
+              }
               var contextProduct = product;
               if (!matchVariant) {
                 // 只匹配 product_id，忽略 product_variant_id
@@ -627,6 +640,9 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
       } else if (actionType === 'X_ITEMS_FOR_Y_PRICE') {
         var _detail = actionDetail;
         requiredQuantity = _detail.x || 0;
+      } else if (actionType === 'ITEM_REWARD') {
+        var _detail2 = actionDetail;
+        requiredQuantity = _detail2.triggerQuantity || 1;
       }
 
       // 获取可参与商品列表
@@ -1104,6 +1120,248 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
       };
     }
 
+    /**
+     * 处理 商品奖励 促销
+     *
+     * 1. 使用 group.products 统计触发条件商品数量
+     * 2. 按 quantityRule 计算最多奖励的目标商品数量
+     * 3. 在全购物车商品中筛选 rewardTargets
+     * 4. 按消费者最优（可节省金额从高到低）选择目标单位
+     * 5. 对目标商品拆分并写入 finalPrice，触发商品本身不改价
+     */
+  }, {
+    key: "processItemReward",
+    value: function processItemReward(group, processedQuantityMap, allProducts, matchedBundleIndexMap) {
+      var _this4 = this;
+      var strategyId = group.strategyId,
+        strategyMetadata = group.strategyMetadata,
+        actionDetail = group.actionDetail,
+        triggerProducts = group.products;
+      var detail = actionDetail;
+      var triggerQuantity = this.normalizePositiveInteger(detail.triggerQuantity, 1);
+      var rewardQuantity = this.normalizePositiveInteger(detail.rewardQuantity, 1);
+      var conditionQuantity = this.getAvailablePromotionQuantity(triggerProducts, processedQuantityMap, matchedBundleIndexMap);
+      if (conditionQuantity < triggerQuantity) {
+        return {
+          products: [],
+          originalAmount: 0,
+          finalAmount: 0
+        };
+      }
+      var targetProducts = allProducts.filter(function (product) {
+        return _this4.isProductMatch(product, detail.rewardTargets || []);
+      });
+      var targetUnitCandidates = this.buildItemRewardTargetUnits(targetProducts, processedQuantityMap, detail);
+      if (targetUnitCandidates.length === 0) {
+        return {
+          products: [],
+          originalAmount: 0,
+          finalAmount: 0
+        };
+      }
+      var rewardLimit = this.resolveItemRewardLimit(detail, conditionQuantity, triggerQuantity, rewardQuantity, targetUnitCandidates.length);
+      if (rewardLimit <= 0) {
+        return {
+          products: [],
+          originalAmount: 0,
+          finalAmount: 0
+        };
+      }
+      var selectedUnits = _toConsumableArray(targetUnitCandidates).sort(function (a, b) {
+        var discountDiff = b.discountAmount.minus(a.discountAmount).toNumber();
+        if (discountDiff !== 0) return discountDiff;
+        return b.originalPrice.minus(a.originalPrice).toNumber();
+      }).slice(0, rewardLimit);
+      var selectedByProductId = new Map();
+      var _iterator18 = _createForOfIteratorHelper(selectedUnits),
+        _step18;
+      try {
+        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+          var unit = _step18.value;
+          var existing = selectedByProductId.get(unit.product.id);
+          if (existing) {
+            existing.quantity += 1;
+          } else {
+            selectedByProductId.set(unit.product.id, {
+              quantity: 1,
+              finalPrice: unit.finalPrice,
+              originalPrice: unit.originalPrice
+            });
+          }
+        }
+      } catch (err) {
+        _iterator18.e(err);
+      } finally {
+        _iterator18.f();
+      }
+      var result = [];
+      var originalAmount = new Decimal(0);
+      var finalAmount = new Decimal(0);
+      var _iterator19 = _createForOfIteratorHelper(targetProducts),
+        _step19;
+      try {
+        for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {
+          var product = _step19.value;
+          var key = this.getProductKey(product);
+          var processedQty = processedQuantityMap.get(key) || 0;
+          var availableQty = product.quantity - processedQty;
+          if (availableQty <= 0) continue;
+          var selected = selectedByProductId.get(product.id);
+          var selectedQty = (selected === null || selected === void 0 ? void 0 : selected.quantity) || 0;
+          var remainingQty = availableQty - selectedQty;
+          if (selectedQty <= 0) continue;
+          if (selectedQty > 0) {
+            result.push(_objectSpread(_objectSpread({}, product), {}, {
+              id: selectedQty === availableQty ? product.id : this.generateRandomId(),
+              originalId: product.id,
+              quantity: selectedQty,
+              finalPrice: this.formatPrice(selected.finalPrice),
+              strategyId: strategyId,
+              strategyMetadata: strategyMetadata,
+              inPromotion: true,
+              isSplit: selectedQty !== product.quantity
+            }));
+            originalAmount = originalAmount.plus(selected.originalPrice.mul(selectedQty));
+            finalAmount = finalAmount.plus(selected.finalPrice.mul(selectedQty));
+          }
+          if (remainingQty > 0) {
+            result.push(_objectSpread(_objectSpread({}, product), {}, {
+              quantity: remainingQty,
+              finalPrice: this.formatPrice(product.price),
+              strategyId: undefined,
+              strategyMetadata: undefined,
+              inPromotion: false,
+              isSplit: selectedQty > 0
+            }));
+            var remainingAmount = new Decimal(product.price).mul(remainingQty);
+            originalAmount = originalAmount.plus(remainingAmount);
+            finalAmount = finalAmount.plus(remainingAmount);
+          }
+          processedQuantityMap.set(key, processedQty + availableQty);
+        }
+      } catch (err) {
+        _iterator19.e(err);
+      } finally {
+        _iterator19.f();
+      }
+      return {
+        products: result,
+        originalAmount: originalAmount.toNumber(),
+        finalAmount: finalAmount.toNumber()
+      };
+    }
+  }, {
+    key: "normalizePositiveInteger",
+    value: function normalizePositiveInteger(value, fallback) {
+      var n = Math.floor(Number(value));
+      return Number.isFinite(n) && n > 0 ? n : fallback;
+    }
+  }, {
+    key: "getAvailablePromotionQuantity",
+    value: function getAvailablePromotionQuantity(products, processedQuantityMap, matchedBundleIndexMap) {
+      var total = 0;
+      var _iterator20 = _createForOfIteratorHelper(products),
+        _step20;
+      try {
+        for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {
+          var product = _step20.value;
+          var key = this.getProductKey(product);
+          var processedQty = processedQuantityMap.get(key) || 0;
+          var availableQty = product.quantity - processedQty;
+          if (availableQty <= 0) continue;
+          var matchedBundleIndex = matchedBundleIndexMap === null || matchedBundleIndexMap === void 0 ? void 0 : matchedBundleIndexMap.get(product.id);
+          if (matchedBundleIndex !== undefined && product.bundle) {
+            var bundleItem = product.bundle[matchedBundleIndex];
+            total += availableQty * ((bundleItem === null || bundleItem === void 0 ? void 0 : bundleItem.quantity) || 1);
+          } else {
+            total += availableQty;
+          }
+        }
+      } catch (err) {
+        _iterator20.e(err);
+      } finally {
+        _iterator20.f();
+      }
+      return total;
+    }
+  }, {
+    key: "buildItemRewardTargetUnits",
+    value: function buildItemRewardTargetUnits(products, processedQuantityMap, detail) {
+      var units = [];
+      var _iterator21 = _createForOfIteratorHelper(products),
+        _step21;
+      try {
+        for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {
+          var product = _step21.value;
+          var key = this.getProductKey(product);
+          var processedQty = processedQuantityMap.get(key) || 0;
+          var availableQty = product.quantity - processedQty;
+          if (availableQty <= 0) continue;
+          var originalPrice = new Decimal(product.price || 0);
+          var finalPrice = this.resolveItemRewardFinalPrice(originalPrice, detail);
+          var discountAmount = originalPrice.minus(finalPrice);
+          if (discountAmount.lte(0)) continue;
+          for (var i = 0; i < availableQty; i++) {
+            units.push({
+              product: product,
+              originalPrice: originalPrice,
+              finalPrice: finalPrice,
+              discountAmount: discountAmount
+            });
+          }
+        }
+      } catch (err) {
+        _iterator21.e(err);
+      } finally {
+        _iterator21.f();
+      }
+      return units;
+    }
+  }, {
+    key: "resolveItemRewardFinalPrice",
+    value: function resolveItemRewardFinalPrice(originalPrice, detail) {
+      var rewardValue = new Decimal(Number(detail.rewardValue) || 0);
+      var finalPrice;
+      switch (detail.rewardMethod) {
+        case 'percent_off':
+          {
+            var percent = Decimal.min(100, Decimal.max(0, rewardValue));
+            finalPrice = originalPrice.mul(new Decimal(100).minus(percent)).div(100);
+            break;
+          }
+        case 'amount_off':
+          finalPrice = originalPrice.minus(Decimal.max(0, rewardValue));
+          break;
+        case 'fixed_price':
+          finalPrice = Decimal.max(0, rewardValue);
+          break;
+        case 'free':
+        default:
+          finalPrice = new Decimal(0);
+          break;
+      }
+      return Decimal.max(0, Decimal.min(originalPrice, finalPrice)).toDecimalPlaces(2, Decimal.ROUND_HALF_UP);
+    }
+  }, {
+    key: "resolveItemRewardLimit",
+    value: function resolveItemRewardLimit(detail, conditionQuantity, triggerQuantity, rewardQuantity, targetUnitCount) {
+      var _detail$maxRewardQuan;
+      var limit = 0;
+      switch (detail.quantityRule) {
+        case 'all_targets':
+          limit = targetUnitCount;
+          break;
+        case 'max_per_order':
+          limit = this.normalizePositiveInteger((_detail$maxRewardQuan = detail.maxRewardQuantity) !== null && _detail$maxRewardQuan !== void 0 ? _detail$maxRewardQuan : detail.rewardQuantity, rewardQuantity);
+          break;
+        case 'per_condition_quantity':
+        default:
+          limit = Math.floor(conditionQuantity / triggerQuantity) * rewardQuantity;
+          break;
+      }
+      return Math.min(Math.max(0, limit), targetUnitCount);
+    }
+
     /**
      * 获取未参与任何促销的商品
      */
@@ -1111,11 +1369,11 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
     key: "getRemainingProducts",
     value: function getRemainingProducts(allProducts, processedQuantityMap) {
       var result = [];
-      var _iterator18 = _createForOfIteratorHelper(allProducts),
-        _step18;
+      var _iterator22 = _createForOfIteratorHelper(allProducts),
+        _step22;
       try {
-        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
-          var product = _step18.value;
+        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
+          var product = _step22.value;
           var key = this.getProductKey(product);
           var processedQty = processedQuantityMap.get(key) || 0;
           var remainingQty = product.quantity - processedQty;
@@ -1130,9 +1388,9 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator18.e(err);
+        _iterator22.e(err);
       } finally {
-        _iterator18.f();
+        _iterator22.f();
       }
       return result;
     }
@@ -1210,8 +1468,23 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
   }, {
     key: "isProductInStrategy",
     value: function isProductInStrategy(product, config) {
+      if (this.shouldSkipStrategyForProduct(product, config)) {
+        return false;
+      }
       return this.getProductMatchInfo(product, config).isMatch;
     }
+  }, {
+    key: "shouldSkipStrategyForProduct",
+    value: function shouldSkipStrategyForProduct(product, config) {
+      return Boolean(product._promotionOnlyForItemReward) && !this.hasActionType(config, PROMOTION_ACTION_TYPES.ITEM_REWARD);
+    }
+  }, {
+    key: "hasActionType",
+    value: function hasActionType(config, actionType) {
+      return (config.actions || []).some(function (action) {
+        return (action === null || action === void 0 ? void 0 : action.type) === actionType;
+      });
+    }
 
     /**
      * 查找商品匹配规则

package/dist/model/strategy/adapter/promotion/examples.d.ts

@@ -136,3 +136,89 @@ export declare const BUY_X_GET_Y_FREE_STRATEGY: {
         };
     }[];
 };
+/**
+ * ITEM_REWARD 策略配置示例：儿童票触发婴儿票免费
+ *
+ * 业务规则：
+ * - 条件商品：儿童票（conditions.rules.productIdAndVariantId）
+ * - 奖励商品：购物车/订单内已经存在的婴儿票（actions[0].config.rewardTargets）
+ * - 本 action 不自动新增婴儿票；每次购物车变更后由统一促销链路重算
+ *
+ * 字段说明：
+ * - type: "ITEM_REWARD" 表示商品奖励 action
+ * - target: "product" 表示本期只奖励商品行
+ * - config.rewardTargets: 奖励对象数组，支持 { product_id, product_variant_id }
+ * - config.targetSelection: "consumer_best" 表示目标商品超额时选择节省金额最高的商品
+ * - value.rewardMethod:
+ *   - "free": 目标商品最终价为 0
+ *   - "percent_off": 百分比折扣，rewardValue 为 0-100
+ *   - "amount_off": 每个目标商品固定减免 rewardValue
+ *   - "fixed_price": 目标商品最终单价为 rewardValue
+ * - value.quantityRule:
+ *   - "per_condition_quantity": 每满足 triggerQuantity 个条件商品，奖励 rewardQuantity 个目标商品
+ *   - "all_targets": 满足条件后奖励全部目标商品
+ *   - "max_per_order": 满足条件后每单最多奖励 maxRewardQuantity 个目标商品
+ */
+export declare const ITEM_REWARD_STRATEGY: {
+    metadata: {
+        id: string;
+        name: {
+            en: string;
+            'zh-CN': string;
+            'zh-HK': string;
+        };
+        type: string;
+        custom: {
+            display: {
+                product_card: {
+                    text: {
+                        en: string;
+                        'zh-CN': string;
+                        'zh-HK': string;
+                    };
+                    type: string;
+                };
+            };
+        };
+    };
+    conditions: {
+        operator: string;
+        rules: ({
+            type: string;
+            field: string;
+            value: string;
+            operator: string;
+        } | {
+            type: string;
+            field: string;
+            value: {
+                product_id: number;
+                product_variant_id: number;
+            }[];
+            operator: string;
+        })[];
+        actionIds: string[];
+    };
+    actions: {
+        id: string;
+        type: string;
+        value: {
+            rewardMethod: string;
+            rewardValue: number;
+            quantityRule: string;
+            triggerQuantity: number;
+            rewardQuantity: number;
+            maxRewardQuantity: number;
+        };
+        valueType: string;
+        target: string;
+        priority: number;
+        config: {
+            rewardTargets: {
+                product_id: number;
+                product_variant_id: number;
+            }[];
+            targetSelection: string;
+        };
+    }[];
+};

package/dist/model/strategy/adapter/promotion/examples.js

@@ -163,4 +163,103 @@ export var BUY_X_GET_Y_FREE_STRATEGY = {
       }]
     }
   }]
+};
+
+/**
+ * ITEM_REWARD 策略配置示例：儿童票触发婴儿票免费
+ *
+ * 业务规则：
+ * - 条件商品：儿童票（conditions.rules.productIdAndVariantId）
+ * - 奖励商品：购物车/订单内已经存在的婴儿票（actions[0].config.rewardTargets）
+ * - 本 action 不自动新增婴儿票；每次购物车变更后由统一促销链路重算
+ *
+ * 字段说明：
+ * - type: "ITEM_REWARD" 表示商品奖励 action
+ * - target: "product" 表示本期只奖励商品行
+ * - config.rewardTargets: 奖励对象数组，支持 { product_id, product_variant_id }
+ * - config.targetSelection: "consumer_best" 表示目标商品超额时选择节省金额最高的商品
+ * - value.rewardMethod:
+ *   - "free": 目标商品最终价为 0
+ *   - "percent_off": 百分比折扣，rewardValue 为 0-100
+ *   - "amount_off": 每个目标商品固定减免 rewardValue
+ *   - "fixed_price": 目标商品最终单价为 rewardValue
+ * - value.quantityRule:
+ *   - "per_condition_quantity": 每满足 triggerQuantity 个条件商品，奖励 rewardQuantity 个目标商品
+ *   - "all_targets": 满足条件后奖励全部目标商品
+ *   - "max_per_order": 满足条件后每单最多奖励 maxRewardQuantity 个目标商品
+ */
+export var ITEM_REWARD_STRATEGY = {
+  metadata: {
+    id: 'STRATEGY_003',
+    name: {
+      en: 'Infant ticket free with child ticket',
+      'zh-CN': '儿童票触发婴儿票免费',
+      'zh-HK': '兒童票觸發嬰兒票免費'
+    },
+    type: 'promotion',
+    custom: {
+      display: {
+        product_card: {
+          text: {
+            en: 'Infant ticket free',
+            'zh-CN': '婴儿票免费',
+            'zh-HK': '嬰兒票免費'
+          },
+          type: 'tag'
+        }
+      }
+    }
+  },
+  conditions: {
+    operator: 'and',
+    rules: [{
+      type: 'operator',
+      field: 'currentDateTime',
+      value: '2023-01-01 00:00:00',
+      operator: '>='
+    }, {
+      type: 'operator',
+      field: 'currentDateTime',
+      value: '2030-01-01 00:00:00',
+      operator: '<='
+    }, {
+      type: 'operator',
+      field: 'productIdAndVariantId',
+      value: [{
+        product_id: 1001,
+        // 条件商品：儿童票
+        product_variant_id: 0 // 0 = 匹配任意变体
+      }],
+      operator: 'product_match'
+    }],
+    actionIds: ['1']
+  },
+  actions: [{
+    id: '1',
+    type: 'ITEM_REWARD',
+    value: {
+      rewardMethod: 'free',
+      // free | percent_off | amount_off | fixed_price
+      rewardValue: 0,
+      // free 可省略；其他 rewardMethod 使用
+      quantityRule: 'per_condition_quantity',
+      // per_condition_quantity | all_targets | max_per_order
+      triggerQuantity: 1,
+      // N：每满足 N 个条件商品
+      rewardQuantity: 1,
+      // Y：奖励 Y 个目标商品
+      maxRewardQuantity: 1 // max_per_order 使用；本例保留为配置示意
+    },
+    valueType: 'object',
+    target: 'product',
+    priority: 1,
+    config: {
+      rewardTargets: [{
+        product_id: 2001,
+        // 奖励对象：婴儿票
+        product_variant_id: 0 // 0 = 匹配任意变体
+      }],
+      targetSelection: 'consumer_best' // consumer_best = 按可节省金额从高到低选择
+    }
+  }]
 };

package/dist/model/strategy/adapter/promotion/index.d.ts

@@ -1,4 +1,4 @@
 export { PromotionEvaluator } from './evaluator';
 export { PromotionAdapter } from './adapter';
 export { default } from './adapter';
-export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY, } from './examples';
+export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY, ITEM_REWARD_STRATEGY, } from './examples';