@pisell/pisellos 2.3.37 → 2.3.38

package/dist/types/index.d.ts

@@ -47,6 +47,7 @@ export interface PisellCore {
     getModule: <T extends Module>(name: string) => T | null;
     getModuleExports: <T = any>(name: string) => T | null;
     hasModule: (name: string) => boolean;
+    getModuleNames: () => string[];
     effects: {
         on: (event: string, callback: (payload: any) => void) => () => void;
         once: (event: string, callback: (payload: any) => void) => () => void;

package/lib/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/lib/core/index.js

@@ -210,6 +210,10 @@ var PisellOSCore = class {
   hasModule(name) {
     return this.modules.has(name);
   }
+  /** 返回当前已注册模块名，供宿主在切换店铺等生命周期中定向清理运行态。 */
+  getModuleNames() {
+    return Array.from(this.modules.keys());
+  }
   // 销毁方法
   async destroy() {
     for (const [name, module2] of this.modules.entries()) {

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

@@ -134,6 +134,8 @@ var PromotionAdapter = class {
         return this.parseXItemsForYPriceAction(action);
       case import_type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE:
         return this.parseBuyXGetYFreeAction(action);
+      case import_type.PROMOTION_ACTION_TYPES.ITEM_REWARD:
+        return this.parseItemRewardAction(action);
       default:
         return void 0;
     }
@@ -167,6 +169,24 @@ var PromotionAdapter = class {
       giftProducts: config.giftProducts || []
     };
   }
+  /**
+   * 解析 商品奖励 Action
+   */
+  parseItemRewardAction(action) {
+    const value = action.value || {};
+    const config = action.config || {};
+    return {
+      type: import_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 === void 0 || value.maxRewardQuantity === null ? void 0 : Number(value.maxRewardQuantity),
+      rewardTargets: Array.isArray(config.rewardTargets) ? config.rewardTargets : [],
+      targetSelection: config.targetSelection || "consumer_best"
+    };
+  }
   /**
    * 获取适用的商品列表
    *

package/lib/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/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

@@ -0,0 +1,51 @@
+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
+});