@pisell/pisellos 2.2.259 → 2.2.261

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

@@ -133,6 +133,9 @@ 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;
@@ -296,6 +299,16 @@ 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(
@@ -379,6 +392,9 @@ 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);
@@ -455,6 +471,9 @@ 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) || [];
@@ -768,6 +787,213 @@ 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);
+  }
   /**
    * 获取未参与任何促销的商品
    */
@@ -839,8 +1065,17 @@ 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,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/lib/model/strategy/adapter/promotion/examples.js

@@ -20,6 +20,7 @@ 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);
@@ -185,8 +186,98 @@ 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, } from './examples';
+export { X_ITEMS_FOR_Y_PRICE_STRATEGY, BUY_X_GET_Y_FREE_STRATEGY, ITEM_REWARD_STRATEGY, } from './examples';

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

@@ -30,6 +30,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 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,
@@ -43,6 +44,7 @@ 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,6 +12,8 @@ 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";
     /** 固定减价 */
@@ -66,6 +68,59 @@ 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;
+}
 /**
  * 商品标识
  *
@@ -102,10 +157,19 @@ 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;
+export type PromotionAction = XItemsForYPriceAction | BuyXGetYFreeAction | ItemRewardAction;
 /**
  * 促销相关运算符
  */
@@ -170,6 +234,8 @@ export interface PromotionProduct {
     quantity: number;
     /** 原价 */
     original_price?: number;
+    /** 内部字段：编辑态订单行只允许参与 ITEM_REWARD，避免旧促销误算历史行 */
+    _promotionOnlyForItemReward?: boolean;
 }
 /**
  * 促销活动适配器转换结果
@@ -195,7 +261,7 @@ export interface PromotionTransformResult {
 /**
  * Action 详情联合类型
  */
-export type PromotionActionDetail = XItemsForYPriceActionDetail | BuyXGetYFreeActionDetail;
+export type PromotionActionDetail = XItemsForYPriceActionDetail | BuyXGetYFreeActionDetail | ItemRewardActionDetail;
 /**
  * X件Y元 Action 详情
  */
@@ -226,6 +292,28 @@ 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,6 +28,8 @@ 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",
   /** 固定减价 */

package/lib/modules/Order/index.d.ts

@@ -461,7 +461,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     generateIdempotencyToken(): string;
     syncPaymentsToOrder<T = any>(params: SyncPaymentsToOrderParams): Promise<SyncPaymentsToOrderResult<T>>;
     createOrder(params: CommitOrderParams['query']): {
-        type: "virtual" | "appointment_booking";
+        type: "appointment_booking" | "virtual";
         platform: string;
         sales_channel: string;
         order_sales_channel: string;

package/lib/modules/Order/utils.js

@@ -446,7 +446,12 @@ function resolveEffectivePerUnitDiscount(product) {
     (sum, discount) => sum + Number((discount == null ? void 0 : discount.amount) || 0),
     0
   );
-  const hasPromoDiscountItem = discountList.some((item) => (item == null ? void 0 : item.type) === "promotion");
+  const hasPromoDiscountItem = discountList.some(
+    (item) => {
+      var _a, _b;
+      return (item == null ? void 0 : item.type) === "promotion" || (item == null ? void 0 : item.type) === "product" && ((_a = item == null ? void 0 : item.metadata) == null ? void 0 : _a.source) === "promotion" && ((_b = item == null ? void 0 : item.metadata) == null ? void 0 : _b.actionType) === "ITEM_REWARD";
+    }
+  );
   if (hasPromoDiscountItem)
     return fromList;
   const metadata = (product == null ? void 0 : product.metadata) || {};

package/lib/modules/Product/index.d.ts

@@ -49,5 +49,5 @@ export declare class Product extends BaseModule implements Module {
     getCategories(): ProductCategory[];
     setOtherParams(key: string, value: any): void;
     getOtherParams(): any;
-    getProductType(): "duration" | "session" | "normal";
+    getProductType(): "normal" | "duration" | "session";
 }

package/lib/modules/Rules/index.d.ts

@@ -36,6 +36,7 @@ export declare class RulesModule extends BaseModule implements Module, RulesModu
     excludeDiscountListByType(discountList: Discount[], type: string): Discount[];
     /** 手动改价场景：去掉 promotion，保留 type=product 等行内折扣 */
     resolveDiscountListForManualOverride(discountList: Discount[]): Discount[];
+    private isItemRewardProductDiscount;
     private getUnavailableReason;
     calcDiscount({ discountList, productList, holders, isFormSubject, orderTotalAmount }: {
         discountList: Discount[];