@pisell/pisellos 2.1.119 → 2.1.121

package/dist/model/strategy/strategy-example.js

@@ -0,0 +1,331 @@
+/**
+ * 策略模型使用示例
+ */
+
+import { createStrategyEngine, evaluate } from "./index";
+// ============================================
+// 示例1: 简单的代金券（单层条件）
+// ============================================
+
+var voucherConfig = {
+  metadata: {
+    id: 'VOUCHER_10',
+    name: '10元代金券',
+    type: 'wallet_pass',
+    calculationType: 'single'
+  },
+  conditions: {
+    operator: 'and',
+    rules: [{
+      type: 'operator',
+      dimension: 'scope_product',
+      field: 'productId',
+      operator: 'in',
+      value: [60734, 60735]
+    }, {
+      type: 'operator',
+      dimension: 'scope_channel',
+      field: 'channel',
+      operator: 'in',
+      value: ['pos', 'mini_program']
+    }, {
+      type: 'operator',
+      dimension: 'transaction',
+      field: 'applicableProductTotal',
+      operator: '>=',
+      value: 100
+    }, {
+      type: 'operator',
+      dimension: 'limit_usage',
+      field: 'perUserUsedCount',
+      operator: '<',
+      value: 1
+    }],
+    actionIds: ['deduct_10']
+  },
+  actions: [{
+    id: 'deduct_10',
+    type: 'DEDUCT_AMOUNT',
+    value: 10,
+    valueType: 'number',
+    valueUnit: '元',
+    target: 'applicable_products',
+    priority: 1,
+    config: {
+      allowCrossProduct: true,
+      deductTaxAndFee: true
+    }
+  }]
+};
+
+// 运行时上下文
+var voucherContext = {
+  entities: {
+    order: {
+      id: 'ORDER_001',
+      total: 150,
+      items: [{
+        productId: 60734,
+        quantity: 2,
+        price: 75
+      }]
+    },
+    customer: {
+      id: 'USER_001',
+      level: 'vip'
+    }
+  },
+  attributes: {
+    productId: 60734,
+    channel: 'pos',
+    applicableProductTotal: 150,
+    perUserUsedCount: 0
+  },
+  metadata: {
+    timestamp: Date.now(),
+    locale: 'zh-CN'
+  }
+};
+
+// ============================================
+// 示例2: 阶梯式满减（嵌套条件）
+// ============================================
+
+var tieredDiscountConfig = {
+  metadata: {
+    id: 'TIERED_DISCOUNT',
+    name: '阶梯满减',
+    type: 'promotion',
+    calculationType: 'single'
+  },
+  conditions: {
+    operator: 'or',
+    rules: [
+    // 档位1：100-199 减10
+    {
+      operator: 'and',
+      rules: [{
+        type: 'operator',
+        dimension: 'transaction',
+        field: 'orderTotal',
+        operator: '>=',
+        value: 100
+      }, {
+        type: 'operator',
+        dimension: 'transaction',
+        field: 'orderTotal',
+        operator: '<',
+        value: 200
+      }],
+      actionIds: ['deduct_10']
+    },
+    // 档位2：200-299 减25
+    {
+      operator: 'and',
+      rules: [{
+        type: 'operator',
+        dimension: 'transaction',
+        field: 'orderTotal',
+        operator: '>=',
+        value: 200
+      }, {
+        type: 'operator',
+        dimension: 'transaction',
+        field: 'orderTotal',
+        operator: '<',
+        value: 300
+      }],
+      actionIds: ['deduct_25']
+    },
+    // 档位3：>= 300 减40
+    {
+      operator: 'and',
+      rules: [{
+        type: 'operator',
+        dimension: 'transaction',
+        field: 'orderTotal',
+        operator: '>=',
+        value: 300
+      }],
+      actionIds: ['deduct_40']
+    }],
+    actionIds: []
+  },
+  actions: [{
+    id: 'deduct_10',
+    type: 'DEDUCT_AMOUNT',
+    value: 10,
+    target: 'order',
+    priority: 1
+  }, {
+    id: 'deduct_25',
+    type: 'DEDUCT_AMOUNT',
+    value: 25,
+    target: 'order',
+    priority: 2
+  }, {
+    id: 'deduct_40',
+    type: 'DEDUCT_AMOUNT',
+    value: 40,
+    target: 'order',
+    priority: 3
+  }]
+};
+var tieredContext = {
+  entities: {
+    order: {
+      id: 'ORDER_002',
+      total: 250
+    }
+  },
+  attributes: {
+    orderTotal: 250
+  },
+  metadata: {
+    timestamp: Date.now()
+  }
+};
+
+// ============================================
+// 示例3: 使用 Code 模式的条件
+// ============================================
+
+var codeConditionConfig = {
+  metadata: {
+    id: 'CODE_CONDITION_EXAMPLE',
+    name: '代码条件示例',
+    type: 'custom'
+  },
+  conditions: {
+    operator: 'and',
+    rules: [
+    // 使用 code 模式
+    {
+      type: 'code',
+      code: 'attributes.orderTotal >= 100 && entities.customer.level === "vip"'
+    },
+    // 混合使用 operator 模式
+    {
+      type: 'operator',
+      field: 'productCount',
+      operator: '>=',
+      value: 2
+    }],
+    actionIds: ['vip_discount']
+  },
+  actions: [{
+    id: 'vip_discount',
+    type: 'DISCOUNT_RATE',
+    value: 0.85,
+    target: 'order',
+    priority: 1
+  }]
+};
+var codeContext = {
+  entities: {
+    customer: {
+      id: 'USER_002',
+      level: 'vip'
+    },
+    order: {
+      id: 'ORDER_003',
+      total: 150
+    }
+  },
+  attributes: {
+    orderTotal: 150,
+    productCount: 3
+  },
+  metadata: {
+    timestamp: Date.now()
+  }
+};
+
+// ============================================
+// 执行示例
+// ============================================
+
+function runExamples() {
+  console.log('====== 策略模型使用示例 ======\n');
+
+  // 创建引擎实例（开启调试和追踪）
+  var engine = createStrategyEngine({
+    debug: true,
+    enableTrace: true
+  });
+
+  // 示例1: 代金券
+  console.log('示例1: 10元代金券');
+  var result1 = engine.evaluate(voucherConfig, voucherContext);
+  console.log('结果:', JSON.stringify(result1, null, 2));
+  console.log('\n');
+
+  // 示例2: 阶梯满减
+  console.log('示例2: 阶梯满减（订单金额250）');
+  var result2 = engine.evaluate(tieredDiscountConfig, tieredContext);
+  console.log('结果:', JSON.stringify(result2, null, 2));
+  console.log('\n');
+
+  // 示例3: Code 模式
+  console.log('示例3: Code 模式条件');
+  var result3 = engine.evaluate(codeConditionConfig, codeContext);
+  console.log('结果:', JSON.stringify(result3, null, 2));
+  console.log('\n');
+
+  // 快速评估（不需要创建引擎实例）
+  console.log('示例4: 快速评估');
+  var result4 = evaluate(voucherConfig, voucherContext);
+  console.log('适用:', result4.applicable);
+  console.log('匹配动作数:', result4.matchedActions.length);
+  console.log('\n');
+
+  // 注册自定义运算符
+  console.log('示例5: 自定义运算符');
+  engine.registerOperator('divisible_by', function (fieldValue, compareValue) {
+    return Number(fieldValue) % Number(compareValue) === 0;
+  });
+  var customOperatorConfig = {
+    metadata: {
+      id: 'CUSTOM_OP',
+      name: '自定义运算符',
+      type: 'test'
+    },
+    conditions: {
+      operator: 'and',
+      rules: [{
+        type: 'operator',
+        field: 'amount',
+        operator: 'divisible_by',
+        value: 10
+      }],
+      actionIds: ['bonus']
+    },
+    actions: [{
+      id: 'bonus',
+      type: 'ADD_POINTS',
+      value: 100,
+      target: 'customer'
+    }]
+  };
+  var customContext = {
+    entities: {},
+    attributes: {
+      amount: 50
+    },
+    metadata: {
+      timestamp: Date.now()
+    }
+  };
+  var result5 = engine.evaluate(customOperatorConfig, customContext);
+  console.log('结果:', result5.applicable ? '适用' : '不适用');
+  console.log('匹配动作:', result5.matchedActions);
+
+  // 调试信息
+  console.log('\n引擎调试信息:', engine.getDebugInfo());
+}
+
+// 运行示例（如果直接执行此文件）
+if (require.main === module) {
+  runExamples();
+}
+export { runExamples };

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

@@ -0,0 +1,228 @@
+/**
+ * 策略配置主结构
+ */
+export interface StrategyConfig<T = Record<string, any>> {
+    /** 元信息 */
+    metadata: StrategyMetadata<T>;
+    /** 条件组（可嵌套，每层可绑定动作） */
+    conditions: ConditionGroup;
+    /** 动作列表（带唯一ID） */
+    actions: ActionEffect[];
+    /** 展示配置（可选） */
+    display?: DisplayConfig;
+}
+/**
+ * 策略元信息
+ */
+export interface StrategyMetadata<T = Record<string, any>> {
+    /** 策略ID */
+    id: string;
+    /** 策略名称 */
+    name: string | Record<string, string>;
+    /** 策略类型（完全可扩展） */
+    type: string;
+    /** 计算类型 */
+    calculationType?: 'single' | 'cumulative';
+    /** 版本 */
+    version?: string;
+    /** 描述 */
+    description?: string | Record<string, string>;
+    /** 自定义元数据 */
+    custom?: T;
+}
+/**
+ * 条件组（支持嵌套）
+ */
+export interface ConditionGroup {
+    /** 逻辑运算符 */
+    operator: 'and' | 'or' | 'not';
+    /** 条件规则列表（可以是单条件或嵌套的条件组） */
+    rules: Array<ConditionRule | ConditionGroup>;
+    /** 关联的动作ID列表（必填，可以为空数组） */
+    actionIds: string[];
+}
+/**
+ * 条件规则（原子条件）
+ * 支持 code 模式使用 eval 执行
+ */
+export interface ConditionRule {
+    /** 类型 */
+    type: 'code' | 'operator';
+    /** 代码（code模式使用，使用eval执行） */
+    code?: string;
+    /** 维度（完全可扩展） */
+    dimension?: string;
+    /** 字段名 */
+    field?: string;
+    /** 运算符 */
+    operator?: string;
+    /** 比较值 */
+    value?: any;
+    /** 值类型 */
+    valueType?: 'number' | 'string' | 'boolean' | 'array' | 'object' | 'date';
+    /** 值单位 */
+    valueUnit?: string;
+    /** 额外配置 */
+    config?: Record<string, any>;
+}
+/**
+ * 动作效果
+ */
+export interface ActionEffect {
+    /** 动作的唯一标识 */
+    id: string;
+    /** 效果类型（完全可扩展） */
+    type: string;
+    /** 运算符（可选） */
+    operator?: string;
+    /** 值 */
+    value: any;
+    /** 值类型 */
+    valueType?: 'number' | 'string' | 'boolean' | 'array' | 'object';
+    /** 值单位 */
+    valueUnit?: string;
+    /** 作用目标 */
+    target: string;
+    /** 优先级（数字越大优先级越高） */
+    priority?: number;
+    /** 配置（完全可扩展） */
+    config?: Record<string, any>;
+}
+/**
+ * 展示配置
+ */
+export interface DisplayConfig {
+    /** 商品卡片展示 */
+    productCard?: {
+        text: string | Record<string, string>;
+        type: 'tag' | 'badge' | 'label';
+        image?: string;
+        style?: Record<string, any>;
+    };
+    /** 详情页展示 */
+    detail?: {
+        title: string | Record<string, string>;
+        description: string | Record<string, string>;
+        image?: string;
+    };
+    /** 自定义展示配置 */
+    custom?: Record<string, any>;
+}
+/**
+ * 运行时上下文结构
+ */
+export interface RuntimeContext {
+    /** 实体数据（完全开放，由业务层定义） */
+    entities: Record<string, any>;
+    /** 属性数据（扁平化的计算值，用于条件判断） */
+    attributes: Record<string, any>;
+    /** 上下文元数据 */
+    metadata: ContextMetadata;
+}
+/**
+ * 上下文元数据
+ */
+export interface ContextMetadata {
+    /** 请求ID（用于追踪） */
+    requestId?: string;
+    /** 时间戳 */
+    timestamp: number;
+    /** 语言 */
+    locale?: string;
+    /** 自定义元数据 */
+    custom?: Record<string, any>;
+}
+/**
+ * 评估结果结构
+ */
+export interface EvaluationResult {
+    /** 是否成功执行（引擎层面） */
+    success: boolean;
+    /** 策略是否适用（业务层面） */
+    applicable: boolean;
+    /** 结果码 */
+    code: string;
+    /** 消息（多语言key或直接文本） */
+    message?: string;
+    /** 匹配信息 */
+    matched: MatchedInfo;
+    /** 匹配的动作列表（按priority排序） */
+    matchedActions: ActionEffect[];
+    /** 输出结果（完全开放，由适配器定义） */
+    outputs: Record<string, any>;
+    /** 执行轨迹（可选，用于调试） */
+    trace?: ExecutionTrace;
+    /** 策略配置 */
+    config: StrategyConfig;
+}
+/**
+ * 匹配信息
+ */
+export interface MatchedInfo {
+    /** 条件是否满足 */
+    conditions: boolean;
+    /** 收集到的 actionIds */
+    actionIds: string[];
+    /** 详细匹配信息 */
+    details: Record<string, any>;
+}
+/**
+ * 执行轨迹
+ */
+export interface ExecutionTrace {
+    /** 执行步骤 */
+    steps: TraceStep[];
+    /** 总耗时（毫秒） */
+    duration: number;
+    /** 错误信息 */
+    errors?: Array<{
+        step: string;
+        error: string;
+        timestamp: number;
+    }>;
+}
+/**
+ * 追踪步骤
+ */
+export interface TraceStep {
+    /** 步骤名称 */
+    step: string;
+    /** 步骤状态 */
+    status: 'success' | 'failed' | 'skipped';
+    /** 耗时（毫秒） */
+    duration: number;
+    /** 详细信息 */
+    details?: Record<string, any>;
+}
+/** 成功码 */
+export declare const SUCCESS_CODES: {
+    readonly SUCCESS: "SUCCESS";
+};
+/** 不适用码 */
+export declare const NOT_APPLICABLE_CODES: {
+    readonly CONDITION_NOT_MET: "CONDITION_NOT_MET";
+};
+/** 错误码 */
+export declare const ERROR_CODES: {
+    readonly INVALID_CONFIG: "INVALID_CONFIG";
+    readonly INVALID_CONTEXT: "INVALID_CONTEXT";
+    readonly EVALUATION_ERROR: "EVALUATION_ERROR";
+    readonly UNKNOWN_ERROR: "UNKNOWN_ERROR";
+};
+/**
+ * 引擎配置选项
+ */
+export interface EngineOptions {
+    /** 是否启用调试模式 */
+    debug?: boolean;
+    /** 是否启用追踪 */
+    enableTrace?: boolean;
+    /** 运算符处理器映射 */
+    operatorHandlers?: Record<string, OperatorHandler>;
+    /** 自定义错误处理器 */
+    errorHandler?: (error: Error, context: RuntimeContext) => void;
+}
+/**
+ * 运算符处理器
+ */
+export type OperatorHandler = (fieldValue: any, compareValue: any, rule: ConditionRule) => boolean;

package/dist/model/strategy/type.js

@@ -0,0 +1,94 @@
+// ============================================
+// 核心接口定义
+// ============================================
+
+/**
+ * 策略配置主结构
+ */
+
+/**
+ * 策略元信息
+ */
+
+/**
+ * 条件组（支持嵌套）
+ */
+
+/**
+ * 条件规则（原子条件）
+ * 支持 code 模式使用 eval 执行
+ */
+
+/**
+ * 动作效果
+ */
+
+/**
+ * 展示配置
+ */
+
+// ============================================
+// 运行时上下文
+// ============================================
+
+/**
+ * 运行时上下文结构
+ */
+
+/**
+ * 上下文元数据
+ */
+
+// ============================================
+// 执行结果
+// ============================================
+
+/**
+ * 评估结果结构
+ */
+
+/**
+ * 匹配信息
+ */
+
+/**
+ * 执行轨迹
+ */
+
+/**
+ * 追踪步骤
+ */
+
+// ============================================
+// 结果码定义
+// ============================================
+
+/** 成功码 */
+export var SUCCESS_CODES = {
+  SUCCESS: 'SUCCESS'
+};
+
+/** 不适用码 */
+export var NOT_APPLICABLE_CODES = {
+  CONDITION_NOT_MET: 'CONDITION_NOT_MET'
+};
+
+/** 错误码 */
+export var ERROR_CODES = {
+  INVALID_CONFIG: 'INVALID_CONFIG',
+  INVALID_CONTEXT: 'INVALID_CONTEXT',
+  EVALUATION_ERROR: 'EVALUATION_ERROR',
+  UNKNOWN_ERROR: 'UNKNOWN_ERROR'
+};
+
+// ============================================
+// 策略引擎配置
+// ============================================
+
+/**
+ * 引擎配置选项
+ */
+
+/**
+ * 运算符处理器
+ */

package/dist/modules/Cart/utils/cartProduct.js

@@ -350,6 +350,7 @@ export var formatBundleToOrigin = function formatBundleToOrigin(bundle) {
       option: formatOptionsToOrigin(getBundleValueByKey('option')),
       discount_list: d.discount_list,
       "bundle_selling_price": d === null || d === void 0 ? void 0 : d.price,
+      "custom_price": d === null || d === void 0 ? void 0 : d.price,
       metadata: {
         custom_product_bundle_map_id: d._id,
         product_discount_difference: product_discount_difference

package/dist/modules/OpenData/index.d.ts

@@ -0,0 +1,24 @@
+import { Module, PisellCore, ModuleOptions } from '../../types';
+import { BaseModule } from '../BaseModule';
+import type { ScheduleModule } from '../Schedule';
+import type { OpenDataConfig, OpenDataFetchParams, OpenDataAvailabilityResult } from './types';
+export * from './types';
+export { computeAvailability } from './utils';
+export declare class OpenDataModule extends BaseModule implements Module {
+    protected defaultName: string;
+    protected defaultVersion: string;
+    private request;
+    private window;
+    private store;
+    private cacheId;
+    private openCache;
+    private fatherModule;
+    private otherParams;
+    constructor(name?: string, version?: string);
+    initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
+    fetchOpenData(params: OpenDataFetchParams): Promise<OpenDataConfig>;
+    getOpenData(): OpenDataConfig | null;
+    getLastFetchedAt(): number | null;
+    checkAvailability(scheduleModule?: ScheduleModule): OpenDataAvailabilityResult;
+    storeChange(): void;
+}