@pisell/pisellos 2.2.261 → 2.2.263

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

@@ -178,10 +178,6 @@ 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) {
@@ -404,12 +400,6 @@ 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);
           }
         }
 
@@ -540,9 +530,6 @@ 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
@@ -640,9 +627,6 @@ 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;
       }
 
       // 获取可参与商品列表
@@ -1120,248 +1104,6 @@ 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);
-    }
-
     /**
      * 获取未参与任何促销的商品
      */
@@ -1369,11 +1111,11 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
     key: "getRemainingProducts",
     value: function getRemainingProducts(allProducts, processedQuantityMap) {
       var result = [];
-      var _iterator22 = _createForOfIteratorHelper(allProducts),
-        _step22;
+      var _iterator18 = _createForOfIteratorHelper(allProducts),
+        _step18;
       try {
-        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {
-          var product = _step22.value;
+        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {
+          var product = _step18.value;
           var key = this.getProductKey(product);
           var processedQty = processedQuantityMap.get(key) || 0;
           var remainingQty = product.quantity - processedQty;
@@ -1388,9 +1130,9 @@ export var PromotionEvaluator = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator22.e(err);
+        _iterator18.e(err);
       } finally {
-        _iterator22.f();
+        _iterator18.f();
       }
       return result;
     }
@@ -1468,23 +1210,8 @@ 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,89 +136,3 @@ 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,103 +163,4 @@ 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, ITEM_REWARD_STRATEGY, } from './examples';
+export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY, } from './examples';

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

@@ -6,4 +6,4 @@ export { PromotionAdapter } from "./adapter";
 export { default } from "./adapter";
 
 // 导出策略配置示例常量
-export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY, ITEM_REWARD_STRATEGY } from "./examples";
+export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY } from "./examples";

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

@@ -12,8 +12,6 @@ export declare const PROMOTION_ACTION_TYPES: {
     readonly X_ITEMS_FOR_Y_PRICE: "X_ITEMS_FOR_Y_PRICE";
     /** 买X送Y（买X件送Y件，可累计） */
     readonly BUY_X_GET_Y_FREE: "BUY_X_GET_Y_FREE";
-    /** 商品奖励（满足条件后，订单内指定目标商品享优惠） */
-    readonly ITEM_REWARD: "ITEM_REWARD";
     /** 固定折扣 */
     readonly DISCOUNT_RATE: "DISCOUNT_RATE";
     /** 固定减价 */
@@ -68,59 +66,6 @@ export interface BuyXGetYFreeConfig {
     /** 可选的赠品列表 */
     giftProducts?: ProductIdentifier[];
 }
-/**
- * 商品奖励优惠方式
- *
- * - free: 目标商品最终价为 0
- * - percent_off: 目标商品按百分比折扣，rewardValue 为 0-100
- * - amount_off: 每个目标商品固定减免 rewardValue
- * - fixed_price: 目标商品改为固定价 rewardValue
- */
-export type ItemRewardMethod = 'free' | 'percent_off' | 'amount_off' | 'fixed_price';
-/**
- * 商品奖励数量规则
- *
- * - per_condition_quantity: 每满足 N 个条件商品，奖励 Y 个目标商品
- * - all_targets: 满足条件后奖励全部目标商品
- * - max_per_order: 满足条件后每单最多奖励固定数量目标商品
- */
-export type ItemRewardQuantityRule = 'per_condition_quantity' | 'all_targets' | 'max_per_order';
-/** 商品奖励目标选择规则 */
-export type ItemRewardTargetSelection = 'consumer_best';
-/**
- * 商品奖励 - Action Value
- *
- * @example
- * value: {
- *   rewardMethod: 'free',
- *   quantityRule: 'per_condition_quantity',
- *   triggerQuantity: 1,
- *   rewardQuantity: 1,
- * }
- */
-export interface ItemRewardValue {
-    /** 奖励方式 */
-    rewardMethod: ItemRewardMethod;
-    /** 奖励值：percent_off/amount_off/fixed_price 使用，free 可省略 */
-    rewardValue?: number;
-    /** 奖励数量规则 */
-    quantityRule: ItemRewardQuantityRule;
-    /** 每满足 N 个条件商品；默认 1 */
-    triggerQuantity?: number;
-    /** 奖励 Y 个目标商品；默认 1 */
-    rewardQuantity?: number;
-    /** 每单最多奖励 Y 个目标商品；max_per_order 使用 */
-    maxRewardQuantity?: number;
-}
-/**
- * 商品奖励 - Action Config
- */
-export interface ItemRewardConfig {
-    /** 奖励对象，本期支持指定商品/变体；product_variant_id=0 表示任意变体 */
-    rewardTargets?: ProductIdentifier[];
-    /** 目标商品超额时的选择规则；本期支持 consumer_best */
-    targetSelection?: ItemRewardTargetSelection;
-}
 /**
  * 商品标识
  *
@@ -157,19 +102,10 @@ export interface BuyXGetYFreeAction extends Omit<ActionEffect, 'type' | 'value'
     valueType: 'object';
     config?: BuyXGetYFreeConfig;
 }
-/**
- * 商品奖励 Action
- */
-export interface ItemRewardAction extends Omit<ActionEffect, 'type' | 'value' | 'config'> {
-    type: typeof PROMOTION_ACTION_TYPES.ITEM_REWARD;
-    value: ItemRewardValue;
-    valueType: 'object';
-    config?: ItemRewardConfig;
-}
 /**
  * 促销活动 Action 联合类型
  */
-export type PromotionAction = XItemsForYPriceAction | BuyXGetYFreeAction | ItemRewardAction;
+export type PromotionAction = XItemsForYPriceAction | BuyXGetYFreeAction;
 /**
  * 促销相关运算符
  */
@@ -234,8 +170,6 @@ export interface PromotionProduct {
     quantity: number;
     /** 原价 */
     original_price?: number;
-    /** 内部字段：编辑态订单行只允许参与 ITEM_REWARD，避免旧促销误算历史行 */
-    _promotionOnlyForItemReward?: boolean;
 }
 /**
  * 促销活动适配器转换结果
@@ -261,7 +195,7 @@ export interface PromotionTransformResult {
 /**
  * Action 详情联合类型
  */
-export type PromotionActionDetail = XItemsForYPriceActionDetail | BuyXGetYFreeActionDetail | ItemRewardActionDetail;
+export type PromotionActionDetail = XItemsForYPriceActionDetail | BuyXGetYFreeActionDetail;
 /**
  * X件Y元 Action 详情
  */
@@ -292,28 +226,6 @@ export interface BuyXGetYFreeActionDetail {
     /** 可选的赠品列表 */
     giftProducts: ProductIdentifier[];
 }
-/**
- * 商品奖励 Action 详情
- */
-export interface ItemRewardActionDetail {
-    type: typeof PROMOTION_ACTION_TYPES.ITEM_REWARD;
-    /** 奖励方式 */
-    rewardMethod: ItemRewardMethod;
-    /** 奖励值：percent_off/amount_off/fixed_price 使用，free 为 0 */
-    rewardValue: number;
-    /** 奖励数量规则 */
-    quantityRule: ItemRewardQuantityRule;
-    /** 每满足 N 个条件商品；默认 1 */
-    triggerQuantity: number;
-    /** 奖励 Y 个目标商品；默认 1 */
-    rewardQuantity: number;
-    /** 每单最多奖励 Y 个目标商品；max_per_order 使用 */
-    maxRewardQuantity?: number;
-    /** 奖励对象，本期支持指定商品/变体 */
-    rewardTargets: ProductIdentifier[];
-    /** 目标商品超额时的选择规则 */
-    targetSelection: ItemRewardTargetSelection;
-}
 /**
  * X件Y元 - 业务层计算结果
  *