@pisell/pisellos 2.2.261 → 2.2.263

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

@@ -133,9 +133,6 @@ var PromotionEvaluator = class {
     for (const product of products) {
       const applicablePromotions = [];
       for (const config of configs) {
-        if (this.shouldSkipStrategyForProduct(product, config)) {
-          continue;
-        }
         const matchInfo = this.getProductMatchInfo(product, config);
         if (!matchInfo.isMatch) {
           continue;
@@ -299,16 +296,6 @@ var PromotionEvaluator = class {
         if (result.giftInfo) {
           gifts.push(result.giftInfo);
         }
-      } else if (actionType === import_type.PROMOTION_ACTION_TYPES.ITEM_REWARD) {
-        const result = this.processItemReward(
-          group,
-          processedQuantityMap,
-          products,
-          matchedBundleIndexMap
-        );
-        pricedProducts.push(...result.products);
-        totalOriginalAmount = totalOriginalAmount.plus(result.originalAmount);
-        totalFinalAmount = totalFinalAmount.plus(result.finalAmount);
       }
     }
     const remainingProducts = this.getRemainingProducts(
@@ -392,9 +379,6 @@ var PromotionEvaluator = class {
     for (const product of products) {
       const applicableStrategies = [];
       for (const config of configs) {
-        if (this.shouldSkipStrategyForProduct(product, config)) {
-          continue;
-        }
         let contextProduct = product;
         if (!matchVariant) {
           const productMatchRule = this.findProductMatchRule(config);
@@ -471,9 +455,6 @@ var PromotionEvaluator = class {
     } else if (actionType === "X_ITEMS_FOR_Y_PRICE") {
       const detail = actionDetail;
       requiredQuantity = detail.x || 0;
-    } else if (actionType === "ITEM_REWARD") {
-      const detail = actionDetail;
-      requiredQuantity = detail.triggerQuantity || 1;
     }
     const productMatchRule = this.findProductMatchRule(config);
     const eligibleProducts = (productMatchRule == null ? void 0 : productMatchRule.value) || [];
@@ -787,213 +768,6 @@ var PromotionEvaluator = class {
       giftInfo
     };
   }
-  /**
-   * 处理 商品奖励 促销
-   *
-   * 1. 使用 group.products 统计触发条件商品数量
-   * 2. 按 quantityRule 计算最多奖励的目标商品数量
-   * 3. 在全购物车商品中筛选 rewardTargets
-   * 4. 按消费者最优（可节省金额从高到低）选择目标单位
-   * 5. 对目标商品拆分并写入 finalPrice，触发商品本身不改价
-   */
-  processItemReward(group, processedQuantityMap, allProducts, matchedBundleIndexMap) {
-    const {
-      strategyId,
-      strategyMetadata,
-      actionDetail,
-      products: triggerProducts
-    } = group;
-    const detail = actionDetail;
-    const triggerQuantity = this.normalizePositiveInteger(detail.triggerQuantity, 1);
-    const rewardQuantity = this.normalizePositiveInteger(detail.rewardQuantity, 1);
-    const conditionQuantity = this.getAvailablePromotionQuantity(
-      triggerProducts,
-      processedQuantityMap,
-      matchedBundleIndexMap
-    );
-    if (conditionQuantity < triggerQuantity) {
-      return { products: [], originalAmount: 0, finalAmount: 0 };
-    }
-    const targetProducts = allProducts.filter(
-      (product) => this.isProductMatch(product, detail.rewardTargets || [])
-    );
-    const targetUnitCandidates = this.buildItemRewardTargetUnits(
-      targetProducts,
-      processedQuantityMap,
-      detail
-    );
-    if (targetUnitCandidates.length === 0) {
-      return { products: [], originalAmount: 0, finalAmount: 0 };
-    }
-    const rewardLimit = this.resolveItemRewardLimit(
-      detail,
-      conditionQuantity,
-      triggerQuantity,
-      rewardQuantity,
-      targetUnitCandidates.length
-    );
-    if (rewardLimit <= 0) {
-      return { products: [], originalAmount: 0, finalAmount: 0 };
-    }
-    const selectedUnits = [...targetUnitCandidates].sort((a, b) => {
-      const discountDiff = b.discountAmount.minus(a.discountAmount).toNumber();
-      if (discountDiff !== 0)
-        return discountDiff;
-      return b.originalPrice.minus(a.originalPrice).toNumber();
-    }).slice(0, rewardLimit);
-    const selectedByProductId = /* @__PURE__ */ new Map();
-    for (const unit of selectedUnits) {
-      const 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
-        });
-      }
-    }
-    const result = [];
-    let originalAmount = new import_decimal.default(0);
-    let finalAmount = new import_decimal.default(0);
-    for (const product of targetProducts) {
-      const key = this.getProductKey(product);
-      const processedQty = processedQuantityMap.get(key) || 0;
-      const availableQty = product.quantity - processedQty;
-      if (availableQty <= 0)
-        continue;
-      const selected = selectedByProductId.get(product.id);
-      const selectedQty = (selected == null ? void 0 : selected.quantity) || 0;
-      const remainingQty = availableQty - selectedQty;
-      if (selectedQty <= 0)
-        continue;
-      if (selectedQty > 0) {
-        result.push({
-          ...product,
-          id: selectedQty === availableQty ? product.id : this.generateRandomId(),
-          originalId: product.id,
-          quantity: selectedQty,
-          finalPrice: this.formatPrice(selected.finalPrice),
-          strategyId,
-          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({
-          ...product,
-          quantity: remainingQty,
-          finalPrice: this.formatPrice(product.price),
-          strategyId: void 0,
-          strategyMetadata: void 0,
-          inPromotion: false,
-          isSplit: selectedQty > 0
-        });
-        const remainingAmount = new import_decimal.default(product.price).mul(remainingQty);
-        originalAmount = originalAmount.plus(remainingAmount);
-        finalAmount = finalAmount.plus(remainingAmount);
-      }
-      processedQuantityMap.set(key, processedQty + availableQty);
-    }
-    return {
-      products: result,
-      originalAmount: originalAmount.toNumber(),
-      finalAmount: finalAmount.toNumber()
-    };
-  }
-  normalizePositiveInteger(value, fallback) {
-    const n = Math.floor(Number(value));
-    return Number.isFinite(n) && n > 0 ? n : fallback;
-  }
-  getAvailablePromotionQuantity(products, processedQuantityMap, matchedBundleIndexMap) {
-    let total = 0;
-    for (const product of products) {
-      const key = this.getProductKey(product);
-      const processedQty = processedQuantityMap.get(key) || 0;
-      const availableQty = product.quantity - processedQty;
-      if (availableQty <= 0)
-        continue;
-      const matchedBundleIndex = matchedBundleIndexMap == null ? void 0 : matchedBundleIndexMap.get(product.id);
-      if (matchedBundleIndex !== void 0 && product.bundle) {
-        const bundleItem = product.bundle[matchedBundleIndex];
-        total += availableQty * ((bundleItem == null ? void 0 : bundleItem.quantity) || 1);
-      } else {
-        total += availableQty;
-      }
-    }
-    return total;
-  }
-  buildItemRewardTargetUnits(products, processedQuantityMap, detail) {
-    const units = [];
-    for (const product of products) {
-      const key = this.getProductKey(product);
-      const processedQty = processedQuantityMap.get(key) || 0;
-      const availableQty = product.quantity - processedQty;
-      if (availableQty <= 0)
-        continue;
-      const originalPrice = new import_decimal.default(product.price || 0);
-      const finalPrice = this.resolveItemRewardFinalPrice(originalPrice, detail);
-      const discountAmount = originalPrice.minus(finalPrice);
-      if (discountAmount.lte(0))
-        continue;
-      for (let i = 0; i < availableQty; i++) {
-        units.push({
-          product,
-          originalPrice,
-          finalPrice,
-          discountAmount
-        });
-      }
-    }
-    return units;
-  }
-  resolveItemRewardFinalPrice(originalPrice, detail) {
-    const rewardValue = new import_decimal.default(Number(detail.rewardValue) || 0);
-    let finalPrice;
-    switch (detail.rewardMethod) {
-      case "percent_off": {
-        const percent = import_decimal.default.min(100, import_decimal.default.max(0, rewardValue));
-        finalPrice = originalPrice.mul(new import_decimal.default(100).minus(percent)).div(100);
-        break;
-      }
-      case "amount_off":
-        finalPrice = originalPrice.minus(import_decimal.default.max(0, rewardValue));
-        break;
-      case "fixed_price":
-        finalPrice = import_decimal.default.max(0, rewardValue);
-        break;
-      case "free":
-      default:
-        finalPrice = new import_decimal.default(0);
-        break;
-    }
-    return import_decimal.default.max(0, import_decimal.default.min(originalPrice, finalPrice)).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP);
-  }
-  resolveItemRewardLimit(detail, conditionQuantity, triggerQuantity, rewardQuantity, targetUnitCount) {
-    let limit = 0;
-    switch (detail.quantityRule) {
-      case "all_targets":
-        limit = targetUnitCount;
-        break;
-      case "max_per_order":
-        limit = this.normalizePositiveInteger(
-          detail.maxRewardQuantity ?? detail.rewardQuantity,
-          rewardQuantity
-        );
-        break;
-      case "per_condition_quantity":
-      default:
-        limit = Math.floor(conditionQuantity / triggerQuantity) * rewardQuantity;
-        break;
-    }
-    return Math.min(Math.max(0, limit), targetUnitCount);
-  }
   /**
    * 获取未参与任何促销的商品
    */
@@ -1065,17 +839,8 @@ var PromotionEvaluator = class {
    * 检查商品是否在策略的适用范围内
    */
   isProductInStrategy(product, config) {
-    if (this.shouldSkipStrategyForProduct(product, config)) {
-      return false;
-    }
     return this.getProductMatchInfo(product, config).isMatch;
   }
-  shouldSkipStrategyForProduct(product, config) {
-    return Boolean(product._promotionOnlyForItemReward) && !this.hasActionType(config, import_type.PROMOTION_ACTION_TYPES.ITEM_REWARD);
-  }
-  hasActionType(config, actionType) {
-    return (config.actions || []).some((action) => (action == null ? void 0 : action.type) === actionType);
-  }
   /**
    * 查找商品匹配规则
    */

package/lib/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/lib/model/strategy/adapter/promotion/examples.js

@@ -20,7 +20,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var examples_exports = {};
 __export(examples_exports, {
   BUY_X_GET_Y_FREE_STRATEGY: () => BUY_X_GET_Y_FREE_STRATEGY,
-  ITEM_REWARD_STRATEGY: () => ITEM_REWARD_STRATEGY,
   X_ITEMS_FOR_Y_PRICE_STRATEGY: () => X_ITEMS_FOR_Y_PRICE_STRATEGY
 });
 module.exports = __toCommonJS(examples_exports);
@@ -186,98 +185,8 @@ var BUY_X_GET_Y_FREE_STRATEGY = {
     }
   ]
 };
-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 = 按可节省金额从高到低选择
-      }
-    }
-  ]
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BUY_X_GET_Y_FREE_STRATEGY,
-  ITEM_REWARD_STRATEGY,
   X_ITEMS_FOR_Y_PRICE_STRATEGY
 });

package/lib/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/lib/model/strategy/adapter/promotion/index.js

@@ -1,51 +0,0 @@
-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/index.ts
-var promotion_exports = {};
-__export(promotion_exports, {
-  BUY_X_GET_Y_FREE_STRATEGY: () => import_examples.BUY_X_GET_Y_FREE_STRATEGY,
-  ITEM_REWARD_STRATEGY: () => import_examples.ITEM_REWARD_STRATEGY,
-  PromotionAdapter: () => import_adapter.PromotionAdapter,
-  PromotionEvaluator: () => import_evaluator.PromotionEvaluator,
-  X_ITEMS_FOR_Y_PRICE_STRATEGY: () => import_examples.X_ITEMS_FOR_Y_PRICE_STRATEGY,
-  default: () => import_adapter2.default
-});
-module.exports = __toCommonJS(promotion_exports);
-var import_evaluator = require("./evaluator");
-var import_adapter = require("./adapter");
-var import_adapter2 = __toESM(require("./adapter"));
-var import_examples = require("./examples");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BUY_X_GET_Y_FREE_STRATEGY,
-  ITEM_REWARD_STRATEGY,
-  PromotionAdapter,
-  PromotionEvaluator,
-  X_ITEMS_FOR_Y_PRICE_STRATEGY
-});

package/lib/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元 - 业务层计算结果
  *

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

@@ -28,8 +28,6 @@ var PROMOTION_ACTION_TYPES = {
   X_ITEMS_FOR_Y_PRICE: "X_ITEMS_FOR_Y_PRICE",
   /** 买X送Y（买X件送Y件，可累计） */
   BUY_X_GET_Y_FREE: "BUY_X_GET_Y_FREE",
-  /** 商品奖励（满足条件后，订单内指定目标商品享优惠） */
-  ITEM_REWARD: "ITEM_REWARD",
   /** 固定折扣 */
   DISCOUNT_RATE: "DISCOUNT_RATE",
   /** 固定减价 */