@pisell/pisellos 0.0.519 → 0.0.521

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

@@ -1,9 +0,0 @@
-// 导出评估器
-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";

package/dist/model/strategy/adapter/walletPass/evaluator.js

@@ -24,6 +24,25 @@ var defaultStrategyMetadataCustom = {
   deductOptionPrice: false
 };
 
+/**
+ * 条件 field → reasonCode 映射
+ * 用于将策略引擎返回的 failedField 转换为本地化文案 key
+ */
+var FIELD_REASON_CODE_MAP = {
+  orderTotalAmount: 'order_total_amount_not_enough',
+  applicableProductTotalAmount: 'applicable_product_total_amount_not_enough',
+  applicableProductCount: 'applicable_product_count_not_enough'
+};
+
+/**
+ * 用阈值替换文案中的占位符（同时兼容 ${value} 和 {value}）
+ */
+function formatReason(template, value) {
+  if (!template) return template;
+  var replacement = value === undefined || value === null ? '' : String(value);
+  return template.replace(/\$\{value\}/g, replacement).replace(/\{value\}/g, replacement);
+}
+
 /**
  * Wallet Pass 评估器
  * 用于评估哪些 voucher 可以在当前订单中使用
@@ -191,13 +210,17 @@ export var WalletPassEvaluator = /*#__PURE__*/function () {
               strategyResult: evaluationResult
             });
           } else {
-            // 根据策略评估结果的 code 映射到 locales 中的原因
-            var reasonCode = 'not_meet_the_required_conditions'; // 默认原因
-
-            // 根据策略引擎返回的 code 映射到本地化的 reasonCode
-            if (evaluationResult.code) {
-              // 可以根据具体的 code 映射到不同的原因
-              // 例如：如果是金额不足、使用次数限制等
+            var _evaluationResult$mat, _evaluationResult$mat2;
+            // 优先根据失败的 field 映射到具体的 reasonCode（更精确的失败原因）
+            var reasonCode = 'not_meet_the_required_conditions';
+            var thresholdValue = undefined;
+            var failedField = (_evaluationResult$mat = evaluationResult.matched) === null || _evaluationResult$mat === void 0 ? void 0 : _evaluationResult$mat.failedField;
+            var failedRule = (_evaluationResult$mat2 = evaluationResult.matched) === null || _evaluationResult$mat2 === void 0 || (_evaluationResult$mat2 = _evaluationResult$mat2.failedRules) === null || _evaluationResult$mat2 === void 0 ? void 0 : _evaluationResult$mat2[0];
+            if (failedField && FIELD_REASON_CODE_MAP[failedField]) {
+              reasonCode = FIELD_REASON_CODE_MAP[failedField];
+              thresholdValue = failedRule === null || failedRule === void 0 ? void 0 : failedRule.value;
+            } else if (evaluationResult.code) {
+              // 兜底：保留原有 code → reasonCode 映射
               var codeMapping = {
                 INSUFFICIENT_AMOUNT: 'not_meet_the_required_conditions',
                 USAGE_LIMIT_EXCEEDED: 'usage_limit_reached',
@@ -207,6 +230,8 @@ export var WalletPassEvaluator = /*#__PURE__*/function () {
               };
               reasonCode = codeMapping[evaluationResult.code] || 'not_meet_the_required_conditions';
             }
+            var rawText = this.getText(reasonCode);
+            var reason = thresholdValue !== undefined ? formatReason(rawText, thresholdValue) : rawText;
             results.push({
               voucher: voucher,
               isApplicable: false,
@@ -214,7 +239,7 @@ export var WalletPassEvaluator = /*#__PURE__*/function () {
               maxDeduction: 0,
               deductTaxAndFee: false,
               applicableProductIds: [],
-              reason: this.getText(reasonCode),
+              reason: reason,
               reasonCode: reasonCode,
               strategyResult: evaluationResult
             });

package/dist/model/strategy/adapter/walletPass/locales.js

@@ -5,7 +5,10 @@ export var locales = {
     'usage_limit_reached': '已达到使用次数上限',
     'max_passes_per_item_reached': '该商品已达到卡券使用上限',
     'not_available_for_this_channel': '当前渠道不可使用',
-    'not_valid_for_this_order_type': '当前订单类型不适用'
+    'not_valid_for_this_order_type': '当前订单类型不适用',
+    'order_total_amount_not_enough': '订单满 ${value} 才可用',
+    'applicable_product_total_amount_not_enough': '适用商品满 ${value} 才可用',
+    'applicable_product_count_not_enough': '至少购买 {value} 件适用商品才可用'
   },
   'en': {
     'not_meet_the_required_conditions': 'Not meet the required conditions.',
@@ -13,7 +16,10 @@ export var locales = {
     'usage_limit_reached': 'Usage limit reached.',
     'max_passes_per_item_reached': 'Max passes per item reached.',
     'not_available_for_this_channel': 'Not available for this channel.',
-    'not_valid_for_this_order_type': 'Not valid for this order type.'
+    'not_valid_for_this_order_type': 'Not valid for this order type.',
+    'order_total_amount_not_enough': 'Spend ${value} to use',
+    'applicable_product_total_amount_not_enough': '${value} on eligible items',
+    'applicable_product_count_not_enough': 'Buy {value} eligible items to use'
   },
   'zh-HK': {
     'not_meet_the_required_conditions': '未達使用條件',
@@ -21,6 +27,9 @@ export var locales = {
     'usage_limit_reached': '已達使用次數上限',
     'max_passes_per_item_reached': '該商品已達卡券使用上限',
     'not_available_for_this_channel': '當前渠道不可使用',
-    'not_valid_for_this_order_type': '當前訂單類型不適用'
+    'not_valid_for_this_order_type': '當前訂單類型不適用',
+    'order_total_amount_not_enough': '訂單滿 ${value} 才可用',
+    'applicable_product_total_amount_not_enough': '適用商品滿 ${value} 才可用',
+    'applicable_product_count_not_enough': '至少購買 {value} 件適用商品才可用'
   }
 };

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

@@ -27,17 +27,30 @@ export declare class StrategyEngine {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
     private evaluateConditionGroup;
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
+     */
+    private evaluateGroupLogicDetailed;
+    /**
+     * 评估单个规则（带失败规则收集）
+     */
+    private evaluateRuleDetailed;
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
      */
-    private evaluateGroupLogic;
+    private evaluateAtomicRule;
     /**
-     * 评估单个规则
+     * 构建失败规则信息
      */
-    private evaluateRule;
+    private buildFailedRuleInfo;
     /**
      * 评估代码模式条件
      */

package/dist/model/strategy/engine.js

@@ -6,6 +6,8 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
 function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -68,6 +70,7 @@ export var StrategyEngine = /*#__PURE__*/function () {
         errors: []
       };
       try {
+        var _evaluationResult$fai;
         // 验证配置
         this.validateConfig(config);
         if (this.options.enableTrace) {
@@ -125,11 +128,14 @@ export var StrategyEngine = /*#__PURE__*/function () {
           applicable: applicable,
           code: applicable ? SUCCESS_CODES.SUCCESS : NOT_APPLICABLE_CODES.CONDITION_NOT_MET,
           message: applicable ? 'Strategy is applicable' : 'Conditions not met',
-          matched: {
+          matched: _objectSpread({
             conditions: applicable,
             actionIds: evaluationResult.actionIds,
             details: {}
-          },
+          }, applicable ? {} : {
+            failedField: (_evaluationResult$fai = evaluationResult.failedRules[0]) === null || _evaluationResult$fai === void 0 ? void 0 : _evaluationResult$fai.field,
+            failedRules: evaluationResult.failedRules
+          }),
           matchedActions: sortedActions,
           outputs: {},
           config: config
@@ -174,19 +180,18 @@ export var StrategyEngine = /*#__PURE__*/function () {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
   }, {
     key: "evaluateConditionGroup",
     value: function evaluateConditionGroup(group, context) {
       var collectedActionIds = [];
 
-      // 评估当前层的 operator 和 rules
-      var isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-
-      // 如果当前层条件满足
-      if (isCurrentLayerSatisfied) {
-        // 收集当前层的 actionIds
+      // 评估当前层的 operator 和 rules（同时收集失败信息）
+      var _this$evaluateGroupLo = this.evaluateGroupLogicDetailed(group, context),
+        satisfied = _this$evaluateGroupLo.satisfied,
+        failedRules = _this$evaluateGroupLo.failedRules;
+      if (satisfied) {
         collectedActionIds.push.apply(collectedActionIds, _toConsumableArray(group.actionIds));
 
         // 递归评估嵌套的 ConditionGroup，收集嵌套层的 actionIds
@@ -207,54 +212,134 @@ export var StrategyEngine = /*#__PURE__*/function () {
         }
       }
       return {
-        satisfied: isCurrentLayerSatisfied,
-        actionIds: collectedActionIds
+        satisfied: satisfied,
+        actionIds: collectedActionIds,
+        failedRules: failedRules
       };
     }
 
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
      */
   }, {
-    key: "evaluateGroupLogic",
-    value: function evaluateGroupLogic(group, context) {
-      var _this = this;
+    key: "evaluateGroupLogicDetailed",
+    value: function evaluateGroupLogicDetailed(group, context) {
       var operator = group.operator,
         rules = group.rules;
       switch (operator) {
         case 'and':
-          // 所有规则都必须满足
-          return rules.every(function (rule) {
-            return _this.evaluateRule(rule, context);
-          });
+          {
+            var _iterator2 = _createForOfIteratorHelper(rules),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var rule = _step2.value;
+                var ruleResult = this.evaluateRuleDetailed(rule, context);
+                if (!ruleResult.satisfied) {
+                  return {
+                    satisfied: false,
+                    failedRules: ruleResult.failedRules
+                  };
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            return {
+              satisfied: true,
+              failedRules: []
+            };
+          }
         case 'or':
-          // 任一规则满足即可
-          return rules.some(function (rule) {
-            return _this.evaluateRule(rule, context);
-          });
+          {
+            var aggregated = [];
+            var _iterator3 = _createForOfIteratorHelper(rules),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var _rule = _step3.value;
+                var _ruleResult = this.evaluateRuleDetailed(_rule, context);
+                if (_ruleResult.satisfied) {
+                  return {
+                    satisfied: true,
+                    failedRules: []
+                  };
+                }
+                aggregated.push.apply(aggregated, _toConsumableArray(_ruleResult.failedRules));
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+            return {
+              satisfied: false,
+              failedRules: aggregated
+            };
+          }
         case 'not':
-          // 对第一个规则取反
-          if (rules.length === 0) return false;
-          return !this.evaluateRule(rules[0], context);
+          {
+            if (rules.length === 0) {
+              return {
+                satisfied: false,
+                failedRules: []
+              };
+            }
+            var _ruleResult2 = this.evaluateRuleDetailed(rules[0], context);
+            if (_ruleResult2.satisfied) {
+              // 被取反规则实际通过，导致 not 失败
+              var failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
+              return {
+                satisfied: false,
+                failedRules: failed
+              };
+            }
+            return {
+              satisfied: true,
+              failedRules: []
+            };
+          }
         default:
           throw new Error("Unknown operator: ".concat(operator));
       }
     }
 
     /**
-     * 评估单个规则
+     * 评估单个规则（带失败规则收集）
      */
   }, {
-    key: "evaluateRule",
-    value: function evaluateRule(rule, context) {
-      // 如果是嵌套的条件组，递归评估
+    key: "evaluateRuleDetailed",
+    value: function evaluateRuleDetailed(rule, context) {
       if (this.isConditionGroup(rule)) {
-        return this.evaluateGroupLogic(rule, context);
+        return this.evaluateGroupLogicDetailed(rule, context);
       }
-
-      // 原子条件规则
       var conditionRule = rule;
+      var satisfied = this.evaluateAtomicRule(conditionRule, context);
+      if (satisfied) {
+        return {
+          satisfied: true,
+          failedRules: []
+        };
+      }
+      return {
+        satisfied: false,
+        failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
+      };
+    }
 
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
+     */
+  }, {
+    key: "evaluateAtomicRule",
+    value: function evaluateAtomicRule(conditionRule, context) {
       // Code 模式：使用 eval 执行
       if (conditionRule.type === 'code' && conditionRule.code) {
         return this.evaluateCodeCondition(conditionRule.code, context);
@@ -264,6 +349,21 @@ export var StrategyEngine = /*#__PURE__*/function () {
       return this.evaluateOperatorCondition(conditionRule, context);
     }
 
+    /**
+     * 构建失败规则信息
+     */
+  }, {
+    key: "buildFailedRuleInfo",
+    value: function buildFailedRuleInfo(conditionRule, context) {
+      var actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : undefined;
+      return {
+        field: conditionRule.field,
+        operator: conditionRule.operator,
+        value: conditionRule.value,
+        actualValue: actualValue
+      };
+    }
+
     /**
      * 评估代码模式条件
      */
@@ -323,11 +423,11 @@ export var StrategyEngine = /*#__PURE__*/function () {
       // 支持点号路径，如 "order.total"
       var path = field.split('.');
       var value = context.attributes;
-      var _iterator2 = _createForOfIteratorHelper(path),
-        _step2;
+      var _iterator4 = _createForOfIteratorHelper(path),
+        _step4;
       try {
-        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-          var key = _step2.value;
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var key = _step4.value;
           if (value && _typeof(value) === 'object' && key in value) {
             value = value[key];
           } else {
@@ -335,9 +435,9 @@ export var StrategyEngine = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator2.e(err);
+        _iterator4.e(err);
       } finally {
-        _iterator2.f();
+        _iterator4.f();
       }
       return value;
     }
@@ -437,11 +537,11 @@ export var StrategyEngine = /*#__PURE__*/function () {
       var actionMap = new Map(actions.map(function (action) {
         return [action.id, action];
       }));
-      var _iterator3 = _createForOfIteratorHelper(actionIds),
-        _step3;
+      var _iterator5 = _createForOfIteratorHelper(actionIds),
+        _step5;
       try {
-        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
-          var id = _step3.value;
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var id = _step5.value;
           var action = actionMap.get(id);
           if (action) {
             matchedActions.push(action);
@@ -453,9 +553,9 @@ export var StrategyEngine = /*#__PURE__*/function () {
           }
         }
       } catch (err) {
-        _iterator3.e(err);
+        _iterator5.e(err);
       } finally {
-        _iterator3.f();
+        _iterator5.f();
       }
       return matchedActions;
     }

package/dist/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/dist/model/strategy/type.js

@@ -51,6 +51,10 @@
  * 匹配信息
  */
 
+/**
+ * 失败规则信息
+ */
+
 /**
  * 执行轨迹
  */

package/dist/modules/Payment/walletpass.js

@@ -551,7 +551,7 @@ export var WalletPassPaymentImpl = /*#__PURE__*/function () {
                 order_expect_amount: params.order_expect_amount || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.order_expect_amount),
                 order_product_amount: params.order_product_amount || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.order_product_amount),
                 order_wait_pay_amount: params.order_wait_pay_amount || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.order_wait_pay_amount),
-                order_behavior_count_customer_id: params.order_behavior_count_customer_id || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.order_behavior_count_customer_id),
+                order_behavior_count_customer_id: params.order_behavior_count_customer_id || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.order_behavior_count_customer_id) || params.customer_id || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.customer_id),
                 products: params.products || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.products),
                 prepare_payments: params.prepare_payments || (baseWalletParams === null || baseWalletParams === void 0 ? void 0 : baseWalletParams.prepare_payments),
                 multiple: 1,

package/dist/solution/BookingByStep/index.d.ts

@@ -311,7 +311,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+        weekNum: 0 | 2 | 1 | 5 | 3 | 4 | 6;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

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

@@ -45,6 +45,17 @@ var defaultStrategyMetadataCustom = {
   maxPassesPerItem: 0,
   deductOptionPrice: false
 };
+var FIELD_REASON_CODE_MAP = {
+  orderTotalAmount: "order_total_amount_not_enough",
+  applicableProductTotalAmount: "applicable_product_total_amount_not_enough",
+  applicableProductCount: "applicable_product_count_not_enough"
+};
+function formatReason(template, value) {
+  if (!template)
+    return template;
+  const replacement = value === void 0 || value === null ? "" : String(value);
+  return template.replace(/\$\{value\}/g, replacement).replace(/\{value\}/g, replacement);
+}
 var WalletPassEvaluator = class {
   constructor() {
     this.strategyConfigs = [];
@@ -101,7 +112,7 @@ var WalletPassEvaluator = class {
    * 评估可用的 vouchers
    */
   evaluate(input) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     const { orderTotalAmount, products, vouchers, strategyConfigs } = input;
     const productIds = products.map((p) => p.product_id);
     const results = [];
@@ -176,7 +187,13 @@ var WalletPassEvaluator = class {
         });
       } else {
         let reasonCode = "not_meet_the_required_conditions";
-        if (evaluationResult.code) {
+        let thresholdValue = void 0;
+        const failedField = (_c = evaluationResult.matched) == null ? void 0 : _c.failedField;
+        const failedRule = (_e = (_d = evaluationResult.matched) == null ? void 0 : _d.failedRules) == null ? void 0 : _e[0];
+        if (failedField && FIELD_REASON_CODE_MAP[failedField]) {
+          reasonCode = FIELD_REASON_CODE_MAP[failedField];
+          thresholdValue = failedRule == null ? void 0 : failedRule.value;
+        } else if (evaluationResult.code) {
           const codeMapping = {
             INSUFFICIENT_AMOUNT: "not_meet_the_required_conditions",
             USAGE_LIMIT_EXCEEDED: "usage_limit_reached",
@@ -186,6 +203,8 @@ var WalletPassEvaluator = class {
           };
           reasonCode = codeMapping[evaluationResult.code] || "not_meet_the_required_conditions";
         }
+        const rawText = this.getText(reasonCode);
+        const reason = thresholdValue !== void 0 ? formatReason(rawText, thresholdValue) : rawText;
         results.push({
           voucher,
           isApplicable: false,
@@ -193,7 +212,7 @@ var WalletPassEvaluator = class {
           maxDeduction: 0,
           deductTaxAndFee: false,
           applicableProductIds: [],
-          reason: this.getText(reasonCode),
+          reason,
           reasonCode,
           strategyResult: evaluationResult
         });

package/lib/model/strategy/adapter/walletPass/locales.js

@@ -29,7 +29,10 @@ var locales = {
     "usage_limit_reached": "已达到使用次数上限",
     "max_passes_per_item_reached": "该商品已达到卡券使用上限",
     "not_available_for_this_channel": "当前渠道不可使用",
-    "not_valid_for_this_order_type": "当前订单类型不适用"
+    "not_valid_for_this_order_type": "当前订单类型不适用",
+    "order_total_amount_not_enough": "订单满 ${value} 才可用",
+    "applicable_product_total_amount_not_enough": "适用商品满 ${value} 才可用",
+    "applicable_product_count_not_enough": "至少购买 {value} 件适用商品才可用"
   },
   "en": {
     "not_meet_the_required_conditions": "Not meet the required conditions.",
@@ -37,7 +40,10 @@ var locales = {
     "usage_limit_reached": "Usage limit reached.",
     "max_passes_per_item_reached": "Max passes per item reached.",
     "not_available_for_this_channel": "Not available for this channel.",
-    "not_valid_for_this_order_type": "Not valid for this order type."
+    "not_valid_for_this_order_type": "Not valid for this order type.",
+    "order_total_amount_not_enough": "Spend ${value} to use",
+    "applicable_product_total_amount_not_enough": "${value} on eligible items",
+    "applicable_product_count_not_enough": "Buy {value} eligible items to use"
   },
   "zh-HK": {
     "not_meet_the_required_conditions": "未達使用條件",
@@ -45,7 +51,10 @@ var locales = {
     "usage_limit_reached": "已達使用次數上限",
     "max_passes_per_item_reached": "該商品已達卡券使用上限",
     "not_available_for_this_channel": "當前渠道不可使用",
-    "not_valid_for_this_order_type": "當前訂單類型不適用"
+    "not_valid_for_this_order_type": "當前訂單類型不適用",
+    "order_total_amount_not_enough": "訂單滿 ${value} 才可用",
+    "applicable_product_total_amount_not_enough": "適用商品滿 ${value} 才可用",
+    "applicable_product_count_not_enough": "至少購買 {value} 件適用商品才可用"
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

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

@@ -27,17 +27,30 @@ export declare class StrategyEngine {
      *
      * @param group 条件组
      * @param context 运行时上下文
-     * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+     * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
      */
     private evaluateConditionGroup;
     /**
-     * 评估条件组的逻辑运算
+     * 评估条件组的逻辑运算（带失败规则收集）
+     *
+     * 失败规则收集策略：
+     * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+     * - `or`：所有分支失败时，聚合每个分支的失败规则
+     * - `not`：被取反规则实际通过时，记录该规则
+     */
+    private evaluateGroupLogicDetailed;
+    /**
+     * 评估单个规则（带失败规则收集）
+     */
+    private evaluateRuleDetailed;
+    /**
+     * 评估原子规则（不收集失败信息，仅返回布尔结果）
      */
-    private evaluateGroupLogic;
+    private evaluateAtomicRule;
     /**
-     * 评估单个规则
+     * 构建失败规则信息
      */
-    private evaluateRule;
+    private buildFailedRuleInfo;
     /**
      * 评估代码模式条件
      */

package/lib/model/strategy/engine.js

@@ -42,7 +42,7 @@ var StrategyEngine = class {
    * 评估策略
    */
   evaluate(config, context) {
-    var _a;
+    var _a, _b;
     const startTime = Date.now();
     const trace = {
       steps: [],
@@ -105,7 +105,11 @@ var StrategyEngine = class {
         matched: {
           conditions: applicable,
           actionIds: evaluationResult.actionIds,
-          details: {}
+          details: {},
+          ...applicable ? {} : {
+            failedField: (_a = evaluationResult.failedRules[0]) == null ? void 0 : _a.field,
+            failedRules: evaluationResult.failedRules
+          }
         },
         matchedActions: sortedActions,
         outputs: {},
@@ -119,7 +123,7 @@ var StrategyEngine = class {
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (this.options.enableTrace) {
-        (_a = trace.errors) == null ? void 0 : _a.push({
+        (_b = trace.errors) == null ? void 0 : _b.push({
           step: "evaluation",
           error: errorMessage,
           timestamp: Date.now()
@@ -149,12 +153,15 @@ var StrategyEngine = class {
    *
    * @param group 条件组
    * @param context 运行时上下文
-   * @returns 评估结果对象，包含条件是否满足和收集到的 actionIds
+   * @returns 评估结果对象，包含条件是否满足、收集到的 actionIds、以及失败的原子规则信息
    */
   evaluateConditionGroup(group, context) {
     const collectedActionIds = [];
-    const isCurrentLayerSatisfied = this.evaluateGroupLogic(group, context);
-    if (isCurrentLayerSatisfied) {
+    const { satisfied, failedRules } = this.evaluateGroupLogicDetailed(
+      group,
+      context
+    );
+    if (satisfied) {
       collectedActionIds.push(...group.actionIds);
       for (const rule of group.rules) {
         if (this.isConditionGroup(rule)) {
@@ -164,41 +171,98 @@ var StrategyEngine = class {
       }
     }
     return {
-      satisfied: isCurrentLayerSatisfied,
-      actionIds: collectedActionIds
+      satisfied,
+      actionIds: collectedActionIds,
+      failedRules
     };
   }
   /**
-   * 评估条件组的逻辑运算
+   * 评估条件组的逻辑运算（带失败规则收集）
+   *
+   * 失败规则收集策略：
+   * - `and`：返回第一个失败的原子规则（嵌套 group 递归取其首个失败原子规则）
+   * - `or`：所有分支失败时，聚合每个分支的失败规则
+   * - `not`：被取反规则实际通过时，记录该规则
    */
-  evaluateGroupLogic(group, context) {
+  evaluateGroupLogicDetailed(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);
+      case "and": {
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (!ruleResult.satisfied) {
+            return {
+              satisfied: false,
+              failedRules: ruleResult.failedRules
+            };
+          }
+        }
+        return { satisfied: true, failedRules: [] };
+      }
+      case "or": {
+        const aggregated = [];
+        for (const rule of rules) {
+          const ruleResult = this.evaluateRuleDetailed(rule, context);
+          if (ruleResult.satisfied) {
+            return { satisfied: true, failedRules: [] };
+          }
+          aggregated.push(...ruleResult.failedRules);
+        }
+        return { satisfied: false, failedRules: aggregated };
+      }
+      case "not": {
+        if (rules.length === 0) {
+          return { satisfied: false, failedRules: [] };
+        }
+        const ruleResult = this.evaluateRuleDetailed(rules[0], context);
+        if (ruleResult.satisfied) {
+          const failed = this.isConditionGroup(rules[0]) ? [] : [this.buildFailedRuleInfo(rules[0], context)];
+          return { satisfied: false, failedRules: failed };
+        }
+        return { satisfied: true, failedRules: [] };
+      }
       default:
         throw new Error(`Unknown operator: ${operator}`);
     }
   }
   /**
-   * 评估单个规则
+   * 评估单个规则（带失败规则收集）
    */
-  evaluateRule(rule, context) {
+  evaluateRuleDetailed(rule, context) {
     if (this.isConditionGroup(rule)) {
-      return this.evaluateGroupLogic(rule, context);
+      return this.evaluateGroupLogicDetailed(rule, context);
     }
     const conditionRule = rule;
+    const satisfied = this.evaluateAtomicRule(conditionRule, context);
+    if (satisfied) {
+      return { satisfied: true, failedRules: [] };
+    }
+    return {
+      satisfied: false,
+      failedRules: [this.buildFailedRuleInfo(conditionRule, context)]
+    };
+  }
+  /**
+   * 评估原子规则（不收集失败信息，仅返回布尔结果）
+   */
+  evaluateAtomicRule(conditionRule, context) {
     if (conditionRule.type === "code" && conditionRule.code) {
       return this.evaluateCodeCondition(conditionRule.code, context);
     }
     return this.evaluateOperatorCondition(conditionRule, context);
   }
+  /**
+   * 构建失败规则信息
+   */
+  buildFailedRuleInfo(conditionRule, context) {
+    const actualValue = conditionRule.field ? this.getFieldValue(conditionRule.field, context) : void 0;
+    return {
+      field: conditionRule.field,
+      operator: conditionRule.operator,
+      value: conditionRule.value,
+      actualValue
+    };
+  }
   /**
    * 评估代码模式条件
    */

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/Payment/walletpass.js

@@ -389,7 +389,7 @@ var WalletPassPaymentImpl = class {
         order_expect_amount: params.order_expect_amount || (baseWalletParams == null ? void 0 : baseWalletParams.order_expect_amount),
         order_product_amount: params.order_product_amount || (baseWalletParams == null ? void 0 : baseWalletParams.order_product_amount),
         order_wait_pay_amount: params.order_wait_pay_amount || (baseWalletParams == null ? void 0 : baseWalletParams.order_wait_pay_amount),
-        order_behavior_count_customer_id: params.order_behavior_count_customer_id || (baseWalletParams == null ? void 0 : baseWalletParams.order_behavior_count_customer_id),
+        order_behavior_count_customer_id: params.order_behavior_count_customer_id || (baseWalletParams == null ? void 0 : baseWalletParams.order_behavior_count_customer_id) || params.customer_id || (baseWalletParams == null ? void 0 : baseWalletParams.customer_id),
         products: params.products || (baseWalletParams == null ? void 0 : baseWalletParams.products),
         prepare_payments: params.prepare_payments || (baseWalletParams == null ? void 0 : baseWalletParams.prepare_payments),
         multiple: 1,

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

@@ -311,7 +311,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         date: string;
         status: string;
         week: string;
-        weekNum: 0 | 2 | 1 | 3 | 4 | 5 | 6;
+        weekNum: 0 | 2 | 1 | 5 | 3 | 4 | 6;
     }[]>;
     submitTimeSlot(timeSlots: TimeSliceItem): void;
     private getScheduleDataByIds;

package/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "@pisell/pisellos",
-  "version": "0.0.519",
+  "version": "0.0.521",
   "description": "一个可扩展的前端模块化SDK框架，支持插件系统",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",