@pisell/pisellos 1.0.142 → 1.0.145

package/lib/model/strategy/index.js

@@ -20,394 +20,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/model/strategy/index.ts
 var strategy_exports = {};
 __export(strategy_exports, {
-  StrategyEngine: () => StrategyEngine,
-  createStrategyEngine: () => createStrategyEngine,
-  evaluate: () => evaluate
+  StrategyEngine: () => import_engine.StrategyEngine,
+  createStrategyEngine: () => import_engine.createStrategyEngine,
+  evaluate: () => import_engine.evaluate
 });
 module.exports = __toCommonJS(strategy_exports);
-var import_type = require("./type");
+var import_engine = require("./engine");
+__reExport(strategy_exports, require("./type"), module.exports);
 __reExport(strategy_exports, require("./adapter"), module.exports);
-var StrategyEngine = class {
-  constructor(options = {}) {
-    this.options = {
-      debug: options.debug ?? false,
-      enableTrace: options.enableTrace ?? false,
-      operatorHandlers: options.operatorHandlers ?? {},
-      errorHandler: options.errorHandler ?? ((error) => console.error(error))
-    };
-    this.operatorHandlers = new Map(
-      Object.entries(this.options.operatorHandlers)
-    );
-    this.initializeBuiltInOperators();
-  }
-  /**
-   * 评估策略
-   */
-  evaluate(config, context) {
-    var _a;
-    const startTime = Date.now();
-    const trace = {
-      steps: [],
-      duration: 0,
-      errors: []
-    };
-    try {
-      this.validateConfig(config);
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "validate_config",
-          status: "success",
-          duration: Date.now() - startTime
-        });
-      }
-      const evaluateStart = Date.now();
-      const evaluationResult = this.evaluateConditionGroup(
-        config.conditions,
-        context
-      );
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "evaluate_conditions",
-          status: "success",
-          duration: Date.now() - evaluateStart,
-          details: {
-            satisfied: evaluationResult.satisfied,
-            collectedActionIds: evaluationResult.actionIds
-          }
-        });
-      }
-      const actionStart = Date.now();
-      const matchedActions = this.getActionsByIds(
-        evaluationResult.actionIds,
-        config.actions
-      );
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "get_actions",
-          status: "success",
-          duration: Date.now() - actionStart,
-          details: { matchedCount: matchedActions.length }
-        });
-      }
-      const sortStart = Date.now();
-      const sortedActions = this.sortActionsByPriority(matchedActions);
-      if (this.options.enableTrace) {
-        trace.steps.push({
-          step: "sort_actions",
-          status: "success",
-          duration: Date.now() - sortStart
-        });
-      }
-      const applicable = evaluationResult.satisfied;
-      const result = {
-        success: true,
-        applicable,
-        code: applicable ? import_type.SUCCESS_CODES.SUCCESS : import_type.NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
-        message: applicable ? "Strategy is applicable" : "Conditions not met",
-        matched: {
-          conditions: applicable,
-          actionIds: evaluationResult.actionIds,
-          details: {}
-        },
-        matchedActions: sortedActions,
-        outputs: {},
-        config
-      };
-      trace.duration = Date.now() - startTime;
-      if (this.options.enableTrace) {
-        result.trace = trace;
-      }
-      return result;
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Unknown error";
-      if (this.options.enableTrace) {
-        (_a = trace.errors) == null ? void 0 : _a.push({
-          step: "evaluation",
-          error: errorMessage,
-          timestamp: Date.now()
-        });
-        trace.duration = Date.now() - startTime;
-      }
-      this.options.errorHandler(error, context);
-      return {
-        success: false,
-        applicable: false,
-        code: import_type.ERROR_CODES.EVALUATION_ERROR,
-        message: errorMessage,
-        matched: {
-          conditions: false,
-          actionIds: [],
-          details: {}
-        },
-        matchedActions: [],
-        outputs: {},
-        trace: this.options.enableTrace ? trace : void 0,
-        config
-      };
-    }
-  }
-  /**
-   * 递归评估条件组
-   *
-   * @param group 条件组
-   * @param context 运行时上下文
-   * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
-   */
-  evaluateConditionGroup(group, context) {
-    const collectedActionIds = [];
-    const isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-    if (isCurrentLayerSatisfied) {
-      collectedActionIds.push(...group.actionIds);
-      for (const rule of group.rules) {
-        if (this.isConditionGroup(rule)) {
-          const nestedResult = this.evaluateConditionGroup(rule, context);
-          collectedActionIds.push(...nestedResult.actionIds);
-        }
-      }
-    }
-    return {
-      satisfied: isCurrentLayerSatisfied,
-      actionIds: collectedActionIds
-    };
-  }
-  /**
-   * 评估条件组的逻辑运算
-   */
-  evaluateGroupLogic(group, context) {
-    const { operator, rules } = group;
-    switch (operator) {
-      case "and":
-        return rules.every((rule) => this.evaluateRule(rule, context));
-      case "or":
-        return rules.some((rule) => this.evaluateRule(rule, context));
-      case "not":
-        if (rules.length === 0)
-          return false;
-        return !this.evaluateRule(rules[0], context);
-      default:
-        throw new Error(`Unknown operator: ${operator}`);
-    }
-  }
-  /**
-   * 评估单个规则
-   */
-  evaluateRule(rule, context) {
-    if (this.isConditionGroup(rule)) {
-      return this.evaluateGroupLogic(rule, context);
-    }
-    const conditionRule = rule;
-    if (conditionRule.type === "code" && conditionRule.code) {
-      return this.evaluateCodeCondition(conditionRule.code, context);
-    }
-    return this.evaluateOperatorCondition(conditionRule, context);
-  }
-  /**
-   * 评估代码模式条件
-   */
-  evaluateCodeCondition(code, context) {
-    try {
-      const { entities, attributes, metadata } = context;
-      const evalFunc = new Function(
-        "entities",
-        "attributes",
-        "metadata",
-        `return (${code})`
-      );
-      const result = evalFunc(entities, attributes, metadata);
-      return Boolean(result);
-    } catch (error) {
-      if (this.options.debug) {
-        console.error("Code evaluation error:", error);
-      }
-      return false;
-    }
-  }
-  /**
-   * 评估运算符模式条件
-   */
-  evaluateOperatorCondition(rule, context) {
-    const { field, operator, value } = rule;
-    if (!field || !operator) {
-      return false;
-    }
-    const fieldValue = this.getFieldValue(field, context);
-    const handler = this.operatorHandlers.get(operator);
-    if (handler) {
-      return handler(fieldValue, value, rule);
-    }
-    return this.evaluateBuiltInOperator(fieldValue, operator, value);
-  }
-  /**
-   * 获取字段值
-   */
-  getFieldValue(field, context) {
-    const path = field.split(".");
-    let value = context.attributes;
-    for (const key of path) {
-      if (value && typeof value === "object" && key in value) {
-        value = value[key];
-      } else {
-        return void 0;
-      }
-    }
-    return value;
-  }
-  /**
-   * 评估内置运算符
-   */
-  evaluateBuiltInOperator(fieldValue, operator, compareValue) {
-    switch (operator) {
-      case "=":
-      case "==":
-        return fieldValue == compareValue;
-      case "!=":
-        return fieldValue != compareValue;
-      case ">":
-        return fieldValue > compareValue;
-      case ">=":
-        return fieldValue >= compareValue;
-      case "<":
-        return fieldValue < compareValue;
-      case "<=":
-        return fieldValue <= compareValue;
-      case "in":
-        return Array.isArray(compareValue) && compareValue.includes(fieldValue);
-      case "not_in":
-        return Array.isArray(compareValue) && !compareValue.includes(fieldValue);
-      case "contains":
-        if (Array.isArray(fieldValue)) {
-          return fieldValue.includes(compareValue);
-        }
-        if (typeof fieldValue === "string") {
-          return fieldValue.includes(compareValue);
-        }
-        return false;
-      case "not_contains":
-        if (Array.isArray(fieldValue)) {
-          return !fieldValue.includes(compareValue);
-        }
-        if (typeof fieldValue === "string") {
-          return !fieldValue.includes(compareValue);
-        }
-        return true;
-      case "starts_with":
-        return typeof fieldValue === "string" && fieldValue.startsWith(compareValue);
-      case "ends_with":
-        return typeof fieldValue === "string" && fieldValue.endsWith(compareValue);
-      case "regex":
-        return typeof fieldValue === "string" && new RegExp(compareValue).test(fieldValue);
-      case "between":
-        if (!Array.isArray(compareValue) || compareValue.length !== 2)
-          return false;
-        return fieldValue >= compareValue[0] && fieldValue <= compareValue[1];
-      case "is_null":
-        return fieldValue === null || fieldValue === void 0;
-      case "is_not_null":
-        return fieldValue !== null && fieldValue !== void 0;
-      case "is_empty":
-        if (Array.isArray(fieldValue))
-          return fieldValue.length === 0;
-        if (typeof fieldValue === "string")
-          return fieldValue.length === 0;
-        if (typeof fieldValue === "object")
-          return Object.keys(fieldValue).length === 0;
-        return !fieldValue;
-      case "is_not_empty":
-        if (Array.isArray(fieldValue))
-          return fieldValue.length > 0;
-        if (typeof fieldValue === "string")
-          return fieldValue.length > 0;
-        if (typeof fieldValue === "object")
-          return Object.keys(fieldValue).length > 0;
-        return Boolean(fieldValue);
-      default:
-        throw new Error(`Unsupported operator: ${operator}`);
-    }
-  }
-  /**
-   * 根据 actionIds 获取 ActionEffect 对象
-   */
-  getActionsByIds(actionIds, actions) {
-    const matchedActions = [];
-    const actionMap = new Map(actions.map((action) => [action.id, action]));
-    for (const id of actionIds) {
-      const action = actionMap.get(id);
-      if (action) {
-        matchedActions.push(action);
-      } else {
-        if (this.options.debug) {
-          console.warn(`Action with id "${id}" not found in actions array`);
-        }
-      }
-    }
-    return matchedActions;
-  }
-  /**
-   * 按 priority 排序（降序）
-   */
-  sortActionsByPriority(actions) {
-    return [...actions].sort((a, b) => {
-      const priorityA = a.priority ?? 0;
-      const priorityB = b.priority ?? 0;
-      return priorityB - priorityA;
-    });
-  }
-  /**
-   * 判断是否为条件组
-   */
-  isConditionGroup(rule) {
-    return "operator" in rule && "rules" in rule && Array.isArray(rule.rules);
-  }
-  /**
-   * 验证配置
-   */
-  validateConfig(config) {
-    if (!config) {
-      throw new Error("Strategy config is required");
-    }
-    if (!config.metadata || !config.metadata.id) {
-      throw new Error("Strategy metadata.id is required");
-    }
-    if (!config.conditions) {
-      throw new Error("Strategy conditions is required");
-    }
-    if (!Array.isArray(config.actions)) {
-      throw new Error("Strategy actions must be an array");
-    }
-  }
-  /**
-   * 初始化内置运算符处理器
-   */
-  initializeBuiltInOperators() {
-  }
-  /**
-   * 注册自定义运算符
-   */
-  registerOperator(operator, handler) {
-    this.operatorHandlers.set(operator, handler);
-  }
-  /**
-   * 获取调试信息
-   */
-  getDebugInfo() {
-    return {
-      debug: this.options.debug,
-      enableTrace: this.options.enableTrace,
-      registeredOperators: Array.from(this.operatorHandlers.keys())
-    };
-  }
-};
-function createStrategyEngine(options) {
-  return new StrategyEngine(options);
-}
-function evaluate(config, context) {
-  const engine = new StrategyEngine();
-  return engine.evaluate(config, context);
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   StrategyEngine,
   createStrategyEngine,
   evaluate,
+  ...require("./type"),
   ...require("./adapter")
 });

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

@@ -165,6 +165,23 @@ export interface MatchedInfo {
     actionIds: string[];
     /** 详细匹配信息 */
     details: Record<string, any>;
+    /** 顶层第一个失败的 field（仅在 conditions=false 时存在，便于直接消费） */
+    failedField?: string;
+    /** 失败的原子规则列表（仅在 conditions=false 时存在；or 全失败时可能有多条） */
+    failedRules?: FailedRuleInfo[];
+}
+/**
+ * 失败规则信息
+ */
+export interface FailedRuleInfo {
+    /** 字段名 */
+    field?: string;
+    /** 运算符 */
+    operator?: string;
+    /** 配置的比较值（阈值） */
+    value?: any;
+    /** 实际取到的字段值 */
+    actualValue?: any;
 }
 /**
  * 执行轨迹

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

@@ -1,6 +1,6 @@
 import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { Discount, DiscountModuleAPI } from './types';
+import { Discount, DiscountModuleAPI, DiscountWithReason } from './types';
 export declare class DiscountModule extends BaseModule implements Module, DiscountModuleAPI {
     protected defaultName: string;
     protected defaultVersion: string;
@@ -24,10 +24,12 @@ export declare class DiscountModule extends BaseModule implements Module, Discou
         with_wallet_pass_holder: 0 | 1;
         request_timezone: string;
     }): Promise<Discount[]>;
-    batchSearch(code: string, customerId?: number): Promise<Discount[]>;
+    batchSearch(code: string, customerId?: number): Promise<DiscountWithReason>;
     batchSearchByProductIds(productIds: number[]): Promise<any>;
     filterEnabledDiscountList(discountList: Discount[]): Discount[];
     private checkUsageCreditsLimit;
+    filterEnabledDiscountListWithReason(discountList: Discount[]): DiscountWithReason;
+    private checkUsageCreditsLimitWithFailKey;
     uniqueByProductId(discountList: Discount[]): Discount[];
     filterDiscountListByProductIds(discountList: Discount[], productIds: number[]): Discount[];
     calcDiscountApplicableProductTotalPrice(discount: Discount): number | undefined;

package/lib/modules/Discount/index.js

@@ -107,15 +107,16 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
       code,
       translate_flag: 1,
       tags: ["good_pass", "product_discount_card"],
-      available: 1,
+      // available: 1,
       relation_product: 1,
       with: ["extensionData", "customScheduleSnapshot", "holder.detail"],
       order_behavior_count: 1,
       order_behavior_count_customer_id: customerId || 1,
+      unified_status_info_flag: 1,
       request_timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
     });
-    const resultDiscountList = this.filterEnabledDiscountList((result == null ? void 0 : result.data) || []) || [];
-    return resultDiscountList;
+    const resultDiscountWithReason = this.filterEnabledDiscountListWithReason((result == null ? void 0 : result.data) || []) || [];
+    return resultDiscountWithReason;
   }
   async batchSearchByProductIds(productIds) {
     const result = await this.request.get(`/machinecode/batch-search`, {
@@ -170,6 +171,64 @@ var DiscountModule = class extends import_BaseModule.BaseModule {
     }
     return true;
   }
+  // 过滤启用且可用的优惠券，并返回校验失败原因
+  filterEnabledDiscountListWithReason(discountList) {
+    let lists = discountList.filter((discount) => discount.limit_status === "enable").filter((discount) => {
+      const remaining = new import_decimal.default((discount == null ? void 0 : discount.par_value) || 0).minus(new import_decimal.default((discount == null ? void 0 : discount.used_par_value) || 0)).greaterThan(0);
+      return remaining;
+    }).map((discount) => {
+      const limitFailKey = this.checkUsageCreditsLimitWithFailKey(discount);
+      return {
+        ...discount,
+        usageLimitFailKey: limitFailKey
+      };
+    });
+    const availableLists = lists.filter((item) => !item.usageLimitFailKey && item.unified_available_status !== 0);
+    const currentFailDiscount = lists.find((item) => item.usageLimitFailKey);
+    return {
+      discountList: availableLists,
+      unavailableReasonKey: currentFailDiscount == null ? void 0 : currentFailDiscount.usageLimitFailKey
+    };
+  }
+  // 检查使用次数限制，并返回校验失败原因
+  checkUsageCreditsLimitWithFailKey(discount) {
+    if (!discount.extension_data || discount.extension_data.length === 0) {
+      return null;
+    }
+    const usageCreditsData = discount.extension_data.find(
+      (data) => data.field_key === "usage_credits"
+    );
+    if (!usageCreditsData) {
+      return null;
+    }
+    const value = usageCreditsData.value;
+    if (value.total_credits && value.total_credits > 0) {
+      if ((discount.total_order_behavior_count || 0) >= value.total_credits) {
+        return "total_credits";
+      }
+    }
+    if (value.per_user_limit && value.per_user_limit > 0) {
+      if ((discount.customer_order_behavior_count || 0) >= value.per_user_limit) {
+        return "per_user_limit";
+      }
+    }
+    if (value.max_per_day && value.max_per_day > 0) {
+      if ((discount.today_order_behavior_count || 0) >= value.max_per_day) {
+        return "max_per_day";
+      }
+    }
+    if (value.max_per_week && value.max_per_week > 0) {
+      if ((discount.week_order_behavior_count || 0) >= value.max_per_week) {
+        return "max_per_week";
+      }
+    }
+    if (value.max_per_month && value.max_per_month > 0) {
+      if ((discount.month_order_behavior_count || 0) >= value.max_per_month) {
+        return "max_per_month";
+      }
+    }
+    return null;
+  }
   // 根据productIds去重
   uniqueByProductId(discountList) {
     return (0, import_utils.uniqueById)(discountList, "product_id");

package/lib/modules/Discount/types.d.ts

@@ -63,6 +63,11 @@ interface UsageCreditsValue {
     max_per_week: number;
     max_per_month: number;
 }
+export type DiscountFilterRejectKey = 'total_credits' | 'per_user_limit' | 'max_per_day' | 'max_per_week' | 'max_per_month';
+export interface DiscountWithReason {
+    discountList: Discount[];
+    unavailableReasonKey: DiscountFilterRejectKey | null;
+}
 interface ExtensionData {
     id: number;
     shop_id: number;
@@ -147,6 +152,8 @@ export interface Discount {
     start_date?: string;
     start_time?: string;
     discount_rule_uncheck_flag?: boolean;
+    usageLimitFailKey?: string | null;
+    unified_available_status?: number | undefined | null;
 }
 export interface DiscountState {
     discountList: Discount[];

package/lib/solution/ShopDiscount/index.d.ts

@@ -46,6 +46,7 @@ export declare class ShopDiscountImpl extends BaseModule implements Module {
         discountList: Discount[];
         type: "server" | "clientCalc";
         unavailableReason?: UnavailableReason;
+        unavailableReasonKey?: string | null;
     }>;
     calcDiscountApplicableProductTotalPrice(discount: Discount): number | undefined;
     private getCustomer;

package/lib/solution/ShopDiscount/index.js

@@ -282,7 +282,8 @@ var ShopDiscountImpl = class extends import_BaseModule.BaseModule {
   async scanCode(code, customerId) {
     var _a, _b, _c;
     try {
-      const resultDiscountList = await ((_a = this.store.discount) == null ? void 0 : _a.batchSearch(code, customerId)) || [];
+      const resultDiscountWithReason = await ((_a = this.store.discount) == null ? void 0 : _a.batchSearch(code, customerId)) || { discountList: [], unavailableReasonKey: null };
+      const { discountList: resultDiscountList, unavailableReasonKey } = resultDiscountWithReason;
       const rulesModule = this.store.rules;
       if (!rulesModule) {
         return {
@@ -298,7 +299,8 @@ var ShopDiscountImpl = class extends import_BaseModule.BaseModule {
           type: "server",
           isAvailable: false,
           productList: this.store.productList || [],
-          discountList: this.getDiscountList()
+          discountList: this.getDiscountList(),
+          unavailableReasonKey
         };
       }
       const withScanList = resultDiscountList.map((item) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "1.0.142",
+  "version": "1.0.145",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "format": "prettier --write \"src/**/*.{ts,tsx,js,jsx,json,md}\"",
     "changeset": "changeset",
     "version": "changeset version",
-    "release": "changeset publish --registry=https://registry.npmjs.com/ && npm run sync && git push",
+    "release": "changeset publish && npm run sync && git push",
     "example": "npx parcel-bundler examples/index.html",
     "docs": "typedoc --out docs src/index.ts",
     "sync": "node sync.js",