@pisell/pisellos 2.2.47 → 2.2.49

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

@@ -1,206 +0,0 @@
-import type { EvaluationResult, RuntimeContext } from '../../type';
-import type { BusinessAdapter } from '../type';
-import type { PromotionBusinessData, PromotionTransformResult } from './type';
-import { PromotionEvaluator } from './evaluator';
-export { PromotionEvaluator };
-/**
- * Promotion 适配器
- *
- * 用于将促销活动业务数据转换为策略引擎可识别的格式
- * 策略引擎只负责匹配，具体的优惠计算由业务层完成
- */
-export declare class PromotionAdapter implements BusinessAdapter {
-    name: string;
-    version: string;
-    /**
-     * 准备运行时上下文
-     *
-     * 将业务数据转换为策略引擎可识别的 RuntimeContext
-     */
-    prepareContext(businessData: PromotionBusinessData): RuntimeContext;
-    /**
-     * 转换执行结果
-     *
-     * 将策略引擎的通用结果转换为业务层需要的格式
-     * 主要是整理 matchedActions，让业务层更容易使用
-     */
-    transformResult(result: EvaluationResult, businessData?: PromotionBusinessData): PromotionTransformResult;
-    /**
-     * 格式化配置
-     */
-    formatConfig(result: EvaluationResult, businessData?: PromotionBusinessData): {
-        result: EvaluationResult;
-        businessData?: PromotionBusinessData;
-    };
-    /**
-     * 格式化日期时间
-     */
-    private formatDateTime;
-    /**
-     * 解析 Action 详情
-     *
-     * 将 matchedAction 转换为更易用的结构
-     */
-    private parseActionDetail;
-    /**
-     * 解析 X件Y元 Action
-     */
-    private parseXItemsForYPriceAction;
-    /**
-     * 解析 买X送Y Action
-     */
-    private parseBuyXGetYFreeAction;
-    /**
-     * 获取适用的商品列表
-     *
-     * 从购物车商品中筛选出符合策略条件的商品
-     */
-    private getApplicableProducts;
-    /**
-     * 查找商品匹配规则
-     */
-    private findProductMatchRule;
-    /**
-     * 检查商品是否匹配
-     */
-    private isProductMatch;
-}
-export default PromotionAdapter;
-/**
- * X件Y元策略配置示例
- *
- * 业务规则：
- * - 每X件商品固定价格Y元（可累计）
- * - 支持跨商品组合（A+B可以凑成一组）
- * - 买5件 = 2组优惠 + 1件原价
- *
- * 商品匹配规则：
- * - product_variant_id = 0 表示匹配任意变体
- * - product_variant_id != 0 表示精确匹配该变体
- */
-export declare const X_ITEMS_FOR_Y_PRICE_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: {
-            x: number;
-            price: number;
-        };
-        valueType: string;
-        target: string;
-        priority: number;
-        config: {
-            allowCrossProduct: boolean;
-            cumulative: boolean;
-        };
-    }[];
-};
-/**
- * 买X送Y策略配置示例
- *
- * 业务规则：
- * - 买X件送Y件（可累计：买2送2、买3送3...）
- * - 赠品由用户从列表中选择
- *
- * 商品匹配规则：
- * - product_variant_id = 0 表示匹配任意变体
- * - product_variant_id != 0 表示精确匹配该变体
- */
-export declare const BUY_X_GET_Y_FREE_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: {
-            buyQuantity: number;
-            freeQuantity: number;
-        };
-        valueType: string;
-        target: string;
-        priority: number;
-        config: {
-            cumulative: boolean;
-            giftProducts: {
-                product_id: number;
-                product_variant_id: number;
-            }[];
-        };
-    }[];
-};

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

@@ -1,386 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __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: () => BUY_X_GET_Y_FREE_STRATEGY,
-  PromotionAdapter: () => PromotionAdapter,
-  PromotionEvaluator: () => import_evaluator.PromotionEvaluator,
-  X_ITEMS_FOR_Y_PRICE_STRATEGY: () => X_ITEMS_FOR_Y_PRICE_STRATEGY,
-  default: () => promotion_default
-});
-module.exports = __toCommonJS(promotion_exports);
-var import_type = require("./type");
-var import_evaluator = require("./evaluator");
-var PromotionAdapter = class {
-  constructor() {
-    this.name = "PromotionAdapter";
-    this.version = "1.0.0";
-  }
-  /**
-   * 准备运行时上下文
-   *
-   * 将业务数据转换为策略引擎可识别的 RuntimeContext
-   */
-  prepareContext(businessData) {
-    const { products, currentProduct, channel, custom } = businessData;
-    const now = /* @__PURE__ */ new Date();
-    const currentDateTime = this.formatDateTime(now);
-    const evaluatingProduct = currentProduct || (products.length > 0 ? products[0] : null);
-    return {
-      entities: {
-        products,
-        currentProduct: evaluatingProduct
-      },
-      attributes: {
-        // 当前时间（格式化字符串，用于时间条件判断）
-        currentDateTime,
-        // 当前评估的商品信息（用于 product_match 运算符）
-        productIdAndVariantId: evaluatingProduct ? {
-          product_id: evaluatingProduct.product_id,
-          product_variant_id: evaluatingProduct.product_variant_id
-        } : null,
-        // 渠道
-        channel: channel || "",
-        // 商品总数量
-        totalQuantity: products.reduce((sum, p) => sum + p.quantity, 0),
-        // 商品总金额
-        totalAmount: products.reduce((sum, p) => sum + p.price * p.quantity, 0),
-        // 自定义属性
-        ...custom
-      },
-      metadata: {
-        timestamp: Date.now()
-      }
-    };
-  }
-  /**
-   * 转换执行结果
-   *
-   * 将策略引擎的通用结果转换为业务层需要的格式
-   * 主要是整理 matchedActions，让业务层更容易使用
-   */
-  transformResult(result, businessData) {
-    const applicableProducts = businessData ? this.getApplicableProducts(result, businessData) : [];
-    if (!result.applicable) {
-      return {
-        isApplicable: false,
-        applicableProducts: [],
-        reason: result.message,
-        reasonCode: result.code,
-        strategyResult: result
-      };
-    }
-    const matchedAction = result.matchedActions[0];
-    if (!matchedAction) {
-      return {
-        isApplicable: false,
-        applicableProducts: [],
-        reason: "No matched action",
-        reasonCode: "NO_ACTION",
-        strategyResult: result
-      };
-    }
-    const actionDetail = this.parseActionDetail(matchedAction);
-    return {
-      isApplicable: true,
-      actionType: matchedAction.type,
-      actionDetail,
-      applicableProducts,
-      strategyResult: result
-    };
-  }
-  /**
-   * 格式化配置
-   */
-  formatConfig(result, businessData) {
-    return { result, businessData };
-  }
-  // ============================================
-  // 私有辅助方法
-  // ============================================
-  /**
-   * 格式化日期时间
-   */
-  formatDateTime(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    const hours = String(date.getHours()).padStart(2, "0");
-    const minutes = String(date.getMinutes()).padStart(2, "0");
-    const seconds = String(date.getSeconds()).padStart(2, "0");
-    return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
-  }
-  /**
-   * 解析 Action 详情
-   *
-   * 将 matchedAction 转换为更易用的结构
-   */
-  parseActionDetail(action) {
-    switch (action.type) {
-      case import_type.PROMOTION_ACTION_TYPES.X_ITEMS_FOR_Y_PRICE:
-        return this.parseXItemsForYPriceAction(action);
-      case import_type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE:
-        return this.parseBuyXGetYFreeAction(action);
-      default:
-        return void 0;
-    }
-  }
-  /**
-   * 解析 X件Y元 Action
-   */
-  parseXItemsForYPriceAction(action) {
-    const value = action.value || {};
-    const config = action.config || {};
-    return {
-      type: import_type.PROMOTION_ACTION_TYPES.X_ITEMS_FOR_Y_PRICE,
-      x: value.x || 2,
-      price: value.price || 0,
-      allowCrossProduct: config.allowCrossProduct ?? true,
-      cumulative: config.cumulative ?? true
-    };
-  }
-  /**
-   * 解析 买X送Y Action
-   */
-  parseBuyXGetYFreeAction(action) {
-    const value = action.value || {};
-    const config = action.config || {};
-    return {
-      type: import_type.PROMOTION_ACTION_TYPES.BUY_X_GET_Y_FREE,
-      buyQuantity: value.buyQuantity || 1,
-      freeQuantity: value.freeQuantity || 1,
-      giftSelectionMode: config.giftSelectionMode || "user_select",
-      cumulative: config.cumulative ?? true,
-      giftProducts: config.giftProducts || []
-    };
-  }
-  /**
-   * 获取适用的商品列表
-   *
-   * 从购物车商品中筛选出符合策略条件的商品
-   */
-  getApplicableProducts(result, businessData) {
-    const { products } = businessData;
-    const productMatchRule = this.findProductMatchRule(result.config);
-    if (!productMatchRule) {
-      return products;
-    }
-    const configProducts = productMatchRule.value;
-    return products.filter(
-      (product) => this.isProductMatch(product, configProducts)
-    );
-  }
-  /**
-   * 查找商品匹配规则
-   */
-  findProductMatchRule(config) {
-    var _a;
-    if (!((_a = config == null ? void 0 : config.conditions) == null ? void 0 : _a.rules)) {
-      return null;
-    }
-    return config.conditions.rules.find(
-      (rule) => rule.field === "productIdAndVariantId" && (rule.operator === "product_match" || rule.operator === "object_in")
-    );
-  }
-  /**
-   * 检查商品是否匹配
-   */
-  isProductMatch(product, configProducts) {
-    return configProducts.some((config) => {
-      if (config.product_id !== product.product_id) {
-        return false;
-      }
-      if (config.product_variant_id === 0) {
-        return true;
-      }
-      return config.product_variant_id === product.product_variant_id;
-    });
-  }
-};
-var promotion_default = PromotionAdapter;
-var X_ITEMS_FOR_Y_PRICE_STRATEGY = {
-  metadata: {
-    id: "STRATEGY_001",
-    name: {
-      en: "2 items for $10",
-      "zh-CN": "2杯10元",
-      "zh-HK": "2杯10元"
-    },
-    type: "promotion",
-    custom: {
-      display: {
-        product_card: {
-          text: {
-            en: "2 for $10",
-            "zh-CN": "2杯10元",
-            "zh-HK": "2杯10元"
-          },
-          type: "tag"
-        }
-      }
-    }
-  },
-  conditions: {
-    operator: "and",
-    rules: [
-      {
-        type: "operator",
-        field: "currentDateTime",
-        value: "2023-01-01 00:00:00",
-        operator: ">="
-      },
-      {
-        type: "operator",
-        field: "currentDateTime",
-        value: "2027-01-01 00:00:00",
-        operator: "<="
-      },
-      {
-        type: "operator",
-        field: "productIdAndVariantId",
-        value: [
-          {
-            product_id: 60736,
-            product_variant_id: 0
-            // 0 = 匹配任意变体
-          },
-          {
-            product_id: 60737,
-            product_variant_id: 0
-            // 0 = 匹配任意变体
-          }
-        ],
-        operator: "product_match"
-      }
-    ],
-    actionIds: ["1"]
-  },
-  actions: [
-    {
-      id: "1",
-      type: "X_ITEMS_FOR_Y_PRICE",
-      value: {
-        x: 2,
-        // 每X件
-        price: 10
-        // 固定价格Y元
-      },
-      valueType: "object",
-      target: "product",
-      priority: 1,
-      config: {
-        allowCrossProduct: true,
-        // 允许跨商品组合（A+B可以凑成一组）
-        cumulative: true
-        // 可累计（买5件 = 2组优惠 + 1件原价）
-      }
-    }
-  ]
-};
-var BUY_X_GET_Y_FREE_STRATEGY = {
-  metadata: {
-    id: "STRATEGY_002",
-    name: {
-      en: "Buy 1 Get 1 Free",
-      "zh-CN": "买1送1",
-      "zh-HK": "買1送1"
-    },
-    type: "promotion",
-    custom: {
-      display: {
-        product_card: {
-          text: {
-            en: "Buy 1 Get 1",
-            "zh-CN": "买1送1",
-            "zh-HK": "買1送1"
-          },
-          type: "tag"
-        }
-      }
-    }
-  },
-  conditions: {
-    operator: "and",
-    rules: [
-      {
-        type: "operator",
-        field: "currentDateTime",
-        value: "2023-01-01 00:00:00",
-        operator: ">="
-      },
-      {
-        type: "operator",
-        field: "currentDateTime",
-        value: "2027-01-01 00:00:00",
-        operator: "<="
-      },
-      {
-        type: "operator",
-        field: "productIdAndVariantId",
-        value: [
-          {
-            product_id: 60736,
-            product_variant_id: 0
-            // 0 = 匹配任意变体
-          },
-          {
-            product_id: 60737,
-            product_variant_id: 0
-            // 0 = 匹配任意变体
-          }
-        ],
-        operator: "product_match"
-      }
-    ],
-    actionIds: ["1"]
-  },
-  actions: [
-    {
-      id: "1",
-      type: "BUY_X_GET_Y_FREE",
-      value: {
-        buyQuantity: 1,
-        // 买X件
-        freeQuantity: 1
-        // 送Y件
-      },
-      valueType: "object",
-      target: "product",
-      priority: 1,
-      config: {
-        // 可累计（买2送2、买3送3...）
-        cumulative: true,
-        // 可选的赠品列表
-        giftProducts: [
-          { product_id: 60757, product_variant_id: 0 },
-          { product_id: 38782, product_variant_id: 0 },
-          { product_id: 60749, product_variant_id: 27267 }
-        ]
-      }
-    }
-  ]
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BUY_X_GET_Y_FREE_STRATEGY,
-  PromotionAdapter,
-  PromotionEvaluator,
-  X_ITEMS_FOR_Y_PRICE_STRATEGY
-});