@pisell/pisellos 2.2.303 → 2.2.305

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

@@ -557,7 +557,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     generateIdempotencyToken(): string;
     syncPaymentsToOrder<T = any>(params: SyncPaymentsToOrderParams): Promise<SyncPaymentsToOrderResult<T>>;
     createOrder(params: CommitOrderParams['query']): {
-        type: "virtual" | "appointment_booking";
+        type: "appointment_booking" | "virtual";
         platform: string;
         sales_channel: string;
         order_sales_channel: string;

package/dist/modules/Payment/cashRecommendationAlgorithm.d.ts

@@ -2,10 +2,9 @@
  * 现金支付推荐算法
  *
  * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
+ * 1. 第一项始终是精确应付金额
+ * 2. 其余推荐只能是严格大于应付金额的真实币种面额
+ * 3. 最多推荐三个更高面额
  */
 /**
  * 常见国家货币面额配置
@@ -13,7 +12,7 @@
 export declare const CURRENCY_DENOMINATIONS: Record<string, number[]>;
 /**
  * 最优支付金额推荐算法
- * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 返回精确应付金额，以及最多三个更高的真实币种面额
  *
  * @param targetAmount 目标金额
  * @param denominations 币种面值数组

package/dist/modules/Payment/cashRecommendationAlgorithm.js

@@ -8,10 +8,9 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
  * 现金支付推荐算法
  * 
  * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
+ * 1. 第一项始终是精确应付金额
+ * 2. 其余推荐只能是严格大于应付金额的真实币种面额
+ * 3. 最多推荐三个更高面额
  */
 
 /**
@@ -47,377 +46,28 @@ export var CURRENCY_DENOMINATIONS = {
   'DEFAULT': [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
 };
 
-/**
- * 支付组合类型定义
- */
-
 /**
  * 最优支付金额推荐算法
- * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 返回精确应付金额，以及最多三个更高的真实币种面额
  * 
  * @param targetAmount 目标金额
  * @param denominations 币种面值数组
  * @returns 推荐支付金额数组
  */
 export function recommendOptimalPayments(targetAmount, denominations) {
-  // 参数验证
-  if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
+  if (targetAmount <= 0 || !Number.isFinite(targetAmount)) {
     return [];
   }
-  if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
-    return [Math.ceil(targetAmount)];
-  }
-
-  // 过滤有效面额并限制搜索空间以提高性能
-  var maxReasonableDenom = targetAmount * 5; // 适度限制搜索空间
-  var validDenoms = denominations.filter(function (denom) {
-    return denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom;
-  }).slice(0, 8); // 限制面额数量以提高性能
-
-  if (validDenoms.length === 0) {
-    // 如果没有合适的面额，返回最接近的整数金额
-    return [Math.ceil(targetAmount)];
-  }
-  try {
-    // 处理精度问题，将金额转换为整数计算
-    var precision = 100; // 假设最小单位是0.01
-    var target = Math.round(targetAmount * precision);
-    var denoms = validDenoms.map(function (d) {
-      return Math.round(d * precision);
-    }).sort(function (a, b) {
-      return b - a;
-    });
-
-    // 存储不同的支付组合方案
-    var paymentOptions = [];
-
-    // 首先尝试找到精确匹配的组合
-    var exactCombination = findExactCombination(target, denoms, precision);
-    if (exactCombination) {
-      paymentOptions.push(exactCombination);
-    }
-
-    // 为了提高效率，我们将按币种数量来生成组合
-    // 1币种组合：只用一种面额
-    for (var i = 0; i < Math.min(denoms.length, 6); i++) {
-      var denom = denoms[i];
-      var count = Math.ceil(target / denom);
-      var sum = count * denom;
-      if (sum >= target && count <= 12) {
-        // 限制硬币数量以提高性能
-        paymentOptions.push({
-          combination: Array(count).fill(denom / precision),
-          sum: sum / precision,
-          coinCount: count,
-          denomTypes: 1
-        });
-      }
-    }
-
-    // 2币种组合：使用两种面额（大幅限制搜索范围以提高性能）
-    for (var _i = 0; _i < Math.min(denoms.length - 1, 5); _i++) {
-      for (var j = _i + 1; j < Math.min(denoms.length, 6); j++) {
-        var denom1 = denoms[_i];
-        var denom2 = denoms[j];
-
-        // 大幅限制搜索范围，基于目标金额动态调整
-        var maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
-        var maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
-        for (var count1 = 1; count1 <= maxCount1; count1++) {
-          for (var count2 = 1; count2 <= maxCount2; count2++) {
-            var _sum = count1 * denom1 + count2 * denom2;
-            if (_sum >= target) {
-              var combination = [].concat(_toConsumableArray(Array(count1).fill(denom1 / precision)), _toConsumableArray(Array(count2).fill(denom2 / precision)));
-              paymentOptions.push({
-                combination: combination,
-                sum: _sum / precision,
-                coinCount: count1 + count2,
-                denomTypes: 2
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // 3币种组合：使用三种面额（大幅限制搜索以提高效率）
-    for (var _i2 = 0; _i2 < Math.min(denoms.length - 2, 3); _i2++) {
-      for (var _j = _i2 + 1; _j < Math.min(denoms.length - 1, 4); _j++) {
-        for (var k = _j + 1; k < Math.min(denoms.length, 5); k++) {
-          var _denom = denoms[_i2];
-          var _denom2 = denoms[_j];
-          var denom3 = denoms[k];
-
-          // 大幅限制搜索范围
-          var _maxCount = Math.min(Math.ceil(target / _denom) + 1, 5);
-          var _maxCount2 = Math.min(Math.ceil(target / _denom2) + 1, 6);
-          var maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
-          for (var _count = 1; _count <= _maxCount; _count++) {
-            for (var _count2 = 1; _count2 <= _maxCount2; _count2++) {
-              for (var count3 = 1; count3 <= maxCount3; count3++) {
-                var _sum2 = _count * _denom + _count2 * _denom2 + count3 * denom3;
-                if (_sum2 >= target) {
-                  var _combination = [].concat(_toConsumableArray(Array(_count).fill(_denom / precision)), _toConsumableArray(Array(_count2).fill(_denom2 / precision)), _toConsumableArray(Array(count3).fill(denom3 / precision)));
-                  paymentOptions.push({
-                    combination: _combination,
-                    sum: _sum2 / precision,
-                    coinCount: _count + _count2 + count3,
-                    denomTypes: 3
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 4币种组合：使用四种面额（极度限制搜索以提高性能）
-    for (var _i3 = 0; _i3 < Math.min(denoms.length - 3, 2); _i3++) {
-      for (var _j2 = _i3 + 1; _j2 < Math.min(denoms.length - 2, 3); _j2++) {
-        for (var _k = _j2 + 1; _k < Math.min(denoms.length - 1, 4); _k++) {
-          for (var l = _k + 1; l < Math.min(denoms.length, 5); l++) {
-            var _denom3 = denoms[_i3];
-            var _denom4 = denoms[_j2];
-            var _denom5 = denoms[_k];
-            var denom4 = denoms[l];
-
-            // 极度限制搜索范围
-            var _maxCount3 = Math.min(Math.ceil(target / _denom3) + 1, 3);
-            var _maxCount4 = Math.min(Math.ceil(target / _denom4) + 1, 4);
-            var _maxCount5 = Math.min(Math.ceil(target / _denom5) + 1, 5);
-            var maxCount4 = Math.min(Math.ceil(target / denom4) + 1, 6);
-            for (var _count3 = 1; _count3 <= _maxCount3; _count3++) {
-              for (var _count4 = 1; _count4 <= _maxCount4; _count4++) {
-                for (var _count5 = 1; _count5 <= _maxCount5; _count5++) {
-                  for (var count4 = 1; count4 <= maxCount4; count4++) {
-                    var _sum3 = _count3 * _denom3 + _count4 * _denom4 + _count5 * _denom5 + count4 * denom4;
-                    if (_sum3 >= target) {
-                      var _combination2 = [].concat(_toConsumableArray(Array(_count3).fill(_denom3 / precision)), _toConsumableArray(Array(_count4).fill(_denom4 / precision)), _toConsumableArray(Array(_count5).fill(_denom5 / precision)), _toConsumableArray(Array(count4).fill(denom4 / precision)));
-                      paymentOptions.push({
-                        combination: _combination2,
-                        sum: _sum3 / precision,
-                        coinCount: _count3 + _count4 + _count5 + count4,
-                        denomTypes: 4
-                      });
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 如果没有找到任何组合，提供默认建议
-    if (paymentOptions.length === 0) {
-      // 找到大于等于目标金额的最小面额
-      var minValidDenom = validDenoms.find(function (denom) {
-        return denom >= targetAmount;
-      });
-      if (minValidDenom) {
-        return [minValidDenom];
-      } else {
-        // 使用最大面额的组合
-        var maxDenom = Math.max.apply(Math, _toConsumableArray(validDenoms));
-        var _count6 = Math.ceil(targetAmount / maxDenom);
-        return [_count6 * maxDenom];
-      }
-    }
-
-    // 移除重复和扩展组合
-    var uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
-
-    // 按币种类型数量排序，然后按总硬币数量排序，最后按金额排序
-    uniqueCombinations.sort(function (a, b) {
-      if (a.denomTypes !== b.denomTypes) {
-        return a.denomTypes - b.denomTypes;
-      }
-      if (a.coinCount !== b.coinCount) {
-        return a.coinCount - b.coinCount;
-      }
-      return a.sum - b.sum;
-    });
-
-    // 按金额去重并返回推荐的支付金额
-    var uniqueAmounts = new Set();
-    var finalResults = [];
-    for (var _i4 = 0, _uniqueCombinations = uniqueCombinations; _i4 < _uniqueCombinations.length; _i4++) {
-      var item = _uniqueCombinations[_i4];
-      var roundedAmount = Math.round(item.sum * 100) / 100; // 处理浮点数精度
-      if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
-        uniqueAmounts.add(roundedAmount);
-        finalResults.push(roundedAmount);
-      }
-    }
-    return finalResults.sort(function (a, b) {
-      return a - b;
-    });
-  } catch (error) {
-    // 发生错误时返回安全的默认值
-    console.warn('推荐支付金额计算出错:', error);
-    // 返回最接近的整数金额作为兜底
-    var safeAmount = Math.ceil(targetAmount);
-    return [targetAmount, safeAmount];
-  }
-}
-
-/**
- * 尝试找到精确匹配目标金额的组合
- */
-function findExactCombination(target, denoms, precision) {
-  // 简单的深度优先搜索，限制搜索深度
-  function dfs(remaining, denomIndex, currentCombination) {
-    if (remaining === 0) {
-      return currentCombination;
-    }
-    if (remaining < 0 || denomIndex >= denoms.length || currentCombination.length > 10) {
-      return null;
-    }
-    var denom = denoms[denomIndex];
-
-    // 尝试使用当前面额 0 到 maxCount 次
-    var maxCount = Math.min(Math.floor(remaining / denom), 8);
-    for (var count = maxCount; count >= 0; count--) {
-      var newCombination = [].concat(_toConsumableArray(currentCombination), _toConsumableArray(Array(count).fill(denom)));
-      var result = dfs(remaining - count * denom, denomIndex + 1, newCombination);
-      if (result) {
-        return result;
-      }
-    }
-    return null;
-  }
-  var exactMatch = dfs(target, 0, []);
-  if (exactMatch && exactMatch.length > 0) {
-    var denomTypes = new Set(exactMatch).size;
-    return {
-      combination: exactMatch.map(function (d) {
-        return d / precision;
-      }),
-      sum: target / precision,
-      coinCount: exactMatch.length,
-      denomTypes: denomTypes
-    };
-  }
-  return null;
-}
-
-/**
- * 移除重复和扩展组合
- * 核心原理：如果组合A包含组合B的所有硬币，并且还有额外硬币，则A是B的扩展，应该被移除
- */
-function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
-  var result = [];
-
-  // 按币种类型数量、硬币数量、金额排序，确保较简单的组合在前面
-  combinations.sort(function (a, b) {
-    if (a.denomTypes !== b.denomTypes) {
-      return a.denomTypes - b.denomTypes;
-    }
-    if (a.coinCount !== b.coinCount) {
-      return a.coinCount - b.coinCount;
-    }
-    return a.sum - b.sum;
-  });
-  for (var i = 0; i < combinations.length; i++) {
-    var current = combinations[i];
-    var shouldSkip = false;
-
-    // 检查当前组合是否与已添加的组合重复或者是扩展
-    for (var j = 0; j < result.length; j++) {
-      var existing = result[j];
-
-      // 如果完全相同，跳过
-      if (isSameCombination(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-
-      // 如果当前组合是已存在组合的扩展，跳过
-      if (isExtensionOf(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-    }
-
-    // 检查是否有其他组合是当前组合的扩展，如果有，移除那些扩展
-    if (!shouldSkip) {
-      // 移除所有当前组合的扩展
-      for (var _j3 = result.length - 1; _j3 >= 0; _j3--) {
-        if (isExtensionOf(result[_j3].combination, current.combination)) {
-          result.splice(_j3, 1);
-        }
-      }
-      result.push(current);
-    }
-  }
-  return result;
-}
-
-/**
- * 检查组合A是否是组合B的扩展（即A包含B的所有硬币，并且还有额外的硬币）
- */
-function isExtensionOf(combinationA, combinationB) {
-  // 如果A的硬币数量少于等于B，A不可能是B的扩展
-  if (combinationA.length <= combinationB.length) {
-    return false;
-  }
-
-  // 统计每个面额的数量
-  var countA = {};
-  var countB = {};
-  combinationA.forEach(function (coin) {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(function (coin) {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查B的所有面额在A中是否都有足够的数量
-  for (var coin in countB) {
-    if (!countA[coin] || countA[coin] < countB[coin]) {
-      return false;
-    }
-  }
-
-  // 检查A是否有B没有的额外硬币
-  var hasExtra = false;
-  for (var _coin in countA) {
-    if (countA[_coin] > (countB[_coin] || 0)) {
-      hasExtra = true;
-      break;
-    }
-  }
-  return hasExtra;
-}
-
-/**
- * 检查两个组合是否本质相同（相同的面额组合）
- */
-function isSameCombination(combinationA, combinationB) {
-  if (combinationA.length !== combinationB.length) {
-    return false;
-  }
-  var countA = {};
-  var countB = {};
-  combinationA.forEach(function (coin) {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(function (coin) {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查两个组合是否有相同的面额和数量
-  for (var coin in countA) {
-    if (countA[coin] !== (countB[coin] || 0)) {
-      return false;
-    }
-  }
-  for (var _coin2 in countB) {
-    if (countB[_coin2] !== (countA[_coin2] || 0)) {
-      return false;
-    }
-  }
-  return true;
+  var precision = 100;
+  var normalizedTarget = Math.round(targetAmount * precision) / precision;
+  var higherDenominations = _toConsumableArray(new Set((Array.isArray(denominations) ? denominations : []).filter(function (denomination) {
+    return denomination > 0 && Number.isFinite(denomination);
+  }).map(function (denomination) {
+    return Math.round(denomination * precision) / precision;
+  }))).filter(function (denomination) {
+    return denomination > normalizedTarget;
+  }).sort(function (a, b) {
+    return a - b;
+  }).slice(0, 3);
+  return [normalizedTarget].concat(_toConsumableArray(higherDenominations));
 }

package/dist/modules/ResourcePlanner/planner.js

@@ -294,12 +294,14 @@ function evaluateCandidateTimeGate(params) {
     };
   }
   if (policy.type === 'before_start') {
-    // Flexible-duration candidates and POS fixed-duration anchors start at
-    // minute precision. Keep that current minute selectable instead of treating
-    // the freshly generated candidate as already started because the query
-    // clock still contains seconds.
+    // POS fixed-duration candidates use the context's stable opening-minute
+    // anchor. Keep that anchored range selectable while it is still active;
+    // otherwise a minute refresh turns it into 0 capacity and incorrectly
+    // advances a create flow to the next slot. The earlier `past` gate still
+    // rejects the anchor once its booking range has ended.
+    var isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
     var usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
-    var hasNotReachedStart = usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start;
+    var hasNotReachedStart = isActivePosDurationAnchor || (usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start);
     if (hasNotReachedStart) return null;
     return {
       status: 'unavailable',
@@ -1437,6 +1439,7 @@ function buildAvailabilityCellIndex(projection) {
 function buildEvaluationContext(params) {
   var _params$resourceIds2;
   var evaluatedAt = toDateTime(params.evaluatedAt || params.projection.meta.now, params.projection.meta.timezone);
+  var durationCandidateAnchorAt = toDateTime(params.projection.meta.durationCandidateAnchorAt, params.projection.meta.timezone);
   var selectionsByGroupKey = new Map();
   (params.requirementSelections || []).forEach(function (selection) {
     var _selection$formId;
@@ -1449,6 +1452,7 @@ function buildEvaluationContext(params) {
     resourceIdSet: (_params$resourceIds2 = params.resourceIds) !== null && _params$resourceIds2 !== void 0 && _params$resourceIds2.length ? new Set(params.resourceIds.map(String)) : null,
     selectionsByGroupKey: selectionsByGroupKey,
     useExactDurationCandidateMinute: params.useExactDurationCandidateMinute === true,
+    durationCandidateAnchorAtMs: Number.isFinite(durationCandidateAnchorAt) ? floorToMinute(durationCandidateAnchorAt) : null,
     allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true
   };
 }

package/dist/modules/ResourcePlanner/types.d.ts

@@ -253,7 +253,8 @@ export interface GetProductTimeRangesRuntimeOptions {
     /**
      * Internal POS capability: fixed-duration candidates start from the stable
      * context anchor's current minute instead of rounding up to ten minutes, and
-     * that minute remains selectable during before-start cutoff evaluation.
+     * that anchored range remains selectable while active during before-start
+     * cutoff evaluation.
      * Other callers keep the legacy alignment and strict second-level cutoff.
      */
     useExactDurationCandidateMinute?: boolean;

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

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

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

@@ -1 +1,46 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "BUY_X_GET_Y_FREE_STRATEGY", {
+  enumerable: true,
+  get: function () {
+    return _examples.BUY_X_GET_Y_FREE_STRATEGY;
+  }
+});
+Object.defineProperty(exports, "ITEM_REWARD_STRATEGY", {
+  enumerable: true,
+  get: function () {
+    return _examples.ITEM_REWARD_STRATEGY;
+  }
+});
+Object.defineProperty(exports, "PromotionAdapter", {
+  enumerable: true,
+  get: function () {
+    return _adapter.PromotionAdapter;
+  }
+});
+Object.defineProperty(exports, "PromotionEvaluator", {
+  enumerable: true,
+  get: function () {
+    return _evaluator.PromotionEvaluator;
+  }
+});
+Object.defineProperty(exports, "X_ITEMS_FOR_Y_PRICE_STRATEGY", {
+  enumerable: true,
+  get: function () {
+    return _examples.X_ITEMS_FOR_Y_PRICE_STRATEGY;
+  }
+});
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _adapter.default;
+  }
+});
+var _evaluator = require("./evaluator");
+var _adapter = _interopRequireWildcard(require("./adapter"));
+var _examples = require("./examples");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }

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

@@ -557,7 +557,7 @@ export declare class OrderModule extends BaseModule implements Module, OrderModu
     generateIdempotencyToken(): string;
     syncPaymentsToOrder<T = any>(params: SyncPaymentsToOrderParams): Promise<SyncPaymentsToOrderResult<T>>;
     createOrder(params: CommitOrderParams['query']): {
-        type: "virtual" | "appointment_booking";
+        type: "appointment_booking" | "virtual";
         platform: string;
         sales_channel: string;
         order_sales_channel: string;

package/lib/modules/Payment/cashRecommendationAlgorithm.d.ts

@@ -2,10 +2,9 @@
  * 现金支付推荐算法
  *
  * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
+ * 1. 第一项始终是精确应付金额
+ * 2. 其余推荐只能是严格大于应付金额的真实币种面额
+ * 3. 最多推荐三个更高面额
  */
 /**
  * 常见国家货币面额配置
@@ -13,7 +12,7 @@
 export declare const CURRENCY_DENOMINATIONS: Record<string, number[]>;
 /**
  * 最优支付金额推荐算法
- * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 返回精确应付金额，以及最多三个更高的真实币种面额
  *
  * @param targetAmount 目标金额
  * @param denominations 币种面值数组

package/lib/modules/Payment/cashRecommendationAlgorithm.js

@@ -9,10 +9,9 @@ exports.recommendOptimalPayments = recommendOptimalPayments;
  * 现金支付推荐算法
  * 
  * 核心原理：
- * 1. 每个推荐金额都应该是独立的最优组合
- * 2. 不推荐在已有最优解基础上添加额外面额的组合
- * 3. 优先推荐使用不同数量币种的组合
- * 4. 根据组合判断去重，避免扩展组合
+ * 1. 第一项始终是精确应付金额
+ * 2. 其余推荐只能是严格大于应付金额的真实币种面额
+ * 3. 最多推荐三个更高面额
  */
 
 /**
@@ -48,364 +47,20 @@ const CURRENCY_DENOMINATIONS = exports.CURRENCY_DENOMINATIONS = {
   'DEFAULT': [100, 50, 20, 10, 5, 1, 0.5, 0.25, 0.1, 0.05, 0.01]
 };
 
-/**
- * 支付组合类型定义
- */
-
 /**
  * 最优支付金额推荐算法
- * 推荐通过不同数量面额组合刚好足够支付的最小金额
+ * 返回精确应付金额，以及最多三个更高的真实币种面额
  * 
  * @param targetAmount 目标金额
  * @param denominations 币种面值数组
  * @returns 推荐支付金额数组
  */
 function recommendOptimalPayments(targetAmount, denominations) {
-  // 参数验证
-  if (targetAmount <= 0 || !isFinite(targetAmount) || isNaN(targetAmount)) {
+  if (targetAmount <= 0 || !Number.isFinite(targetAmount)) {
     return [];
   }
-  if (!denominations || !Array.isArray(denominations) || denominations.length === 0) {
-    return [Math.ceil(targetAmount)];
-  }
-
-  // 过滤有效面额并限制搜索空间以提高性能
-  const maxReasonableDenom = targetAmount * 5; // 适度限制搜索空间
-  const validDenoms = denominations.filter(denom => denom > 0 && isFinite(denom) && !isNaN(denom) && denom <= maxReasonableDenom).slice(0, 8); // 限制面额数量以提高性能
-
-  if (validDenoms.length === 0) {
-    // 如果没有合适的面额，返回最接近的整数金额
-    return [Math.ceil(targetAmount)];
-  }
-  try {
-    // 处理精度问题，将金额转换为整数计算
-    const precision = 100; // 假设最小单位是0.01
-    const target = Math.round(targetAmount * precision);
-    const denoms = validDenoms.map(d => Math.round(d * precision)).sort((a, b) => b - a);
-
-    // 存储不同的支付组合方案
-    const paymentOptions = [];
-
-    // 首先尝试找到精确匹配的组合
-    const exactCombination = findExactCombination(target, denoms, precision);
-    if (exactCombination) {
-      paymentOptions.push(exactCombination);
-    }
-
-    // 为了提高效率，我们将按币种数量来生成组合
-    // 1币种组合：只用一种面额
-    for (let i = 0; i < Math.min(denoms.length, 6); i++) {
-      const denom = denoms[i];
-      const count = Math.ceil(target / denom);
-      const sum = count * denom;
-      if (sum >= target && count <= 12) {
-        // 限制硬币数量以提高性能
-        paymentOptions.push({
-          combination: Array(count).fill(denom / precision),
-          sum: sum / precision,
-          coinCount: count,
-          denomTypes: 1
-        });
-      }
-    }
-
-    // 2币种组合：使用两种面额（大幅限制搜索范围以提高性能）
-    for (let i = 0; i < Math.min(denoms.length - 1, 5); i++) {
-      for (let j = i + 1; j < Math.min(denoms.length, 6); j++) {
-        const denom1 = denoms[i];
-        const denom2 = denoms[j];
-
-        // 大幅限制搜索范围，基于目标金额动态调整
-        const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 8);
-        const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 10);
-        for (let count1 = 1; count1 <= maxCount1; count1++) {
-          for (let count2 = 1; count2 <= maxCount2; count2++) {
-            const sum = count1 * denom1 + count2 * denom2;
-            if (sum >= target) {
-              const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision)];
-              paymentOptions.push({
-                combination: combination,
-                sum: sum / precision,
-                coinCount: count1 + count2,
-                denomTypes: 2
-              });
-            }
-          }
-        }
-      }
-    }
-
-    // 3币种组合：使用三种面额（大幅限制搜索以提高效率）
-    for (let i = 0; i < Math.min(denoms.length - 2, 3); i++) {
-      for (let j = i + 1; j < Math.min(denoms.length - 1, 4); j++) {
-        for (let k = j + 1; k < Math.min(denoms.length, 5); k++) {
-          const denom1 = denoms[i];
-          const denom2 = denoms[j];
-          const denom3 = denoms[k];
-
-          // 大幅限制搜索范围
-          const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 5);
-          const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 6);
-          const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 8);
-          for (let count1 = 1; count1 <= maxCount1; count1++) {
-            for (let count2 = 1; count2 <= maxCount2; count2++) {
-              for (let count3 = 1; count3 <= maxCount3; count3++) {
-                const sum = count1 * denom1 + count2 * denom2 + count3 * denom3;
-                if (sum >= target) {
-                  const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision), ...Array(count3).fill(denom3 / precision)];
-                  paymentOptions.push({
-                    combination: combination,
-                    sum: sum / precision,
-                    coinCount: count1 + count2 + count3,
-                    denomTypes: 3
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 4币种组合：使用四种面额（极度限制搜索以提高性能）
-    for (let i = 0; i < Math.min(denoms.length - 3, 2); i++) {
-      for (let j = i + 1; j < Math.min(denoms.length - 2, 3); j++) {
-        for (let k = j + 1; k < Math.min(denoms.length - 1, 4); k++) {
-          for (let l = k + 1; l < Math.min(denoms.length, 5); l++) {
-            const denom1 = denoms[i];
-            const denom2 = denoms[j];
-            const denom3 = denoms[k];
-            const denom4 = denoms[l];
-
-            // 极度限制搜索范围
-            const maxCount1 = Math.min(Math.ceil(target / denom1) + 1, 3);
-            const maxCount2 = Math.min(Math.ceil(target / denom2) + 1, 4);
-            const maxCount3 = Math.min(Math.ceil(target / denom3) + 1, 5);
-            const maxCount4 = Math.min(Math.ceil(target / denom4) + 1, 6);
-            for (let count1 = 1; count1 <= maxCount1; count1++) {
-              for (let count2 = 1; count2 <= maxCount2; count2++) {
-                for (let count3 = 1; count3 <= maxCount3; count3++) {
-                  for (let count4 = 1; count4 <= maxCount4; count4++) {
-                    const sum = count1 * denom1 + count2 * denom2 + count3 * denom3 + count4 * denom4;
-                    if (sum >= target) {
-                      const combination = [...Array(count1).fill(denom1 / precision), ...Array(count2).fill(denom2 / precision), ...Array(count3).fill(denom3 / precision), ...Array(count4).fill(denom4 / precision)];
-                      paymentOptions.push({
-                        combination: combination,
-                        sum: sum / precision,
-                        coinCount: count1 + count2 + count3 + count4,
-                        denomTypes: 4
-                      });
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    // 如果没有找到任何组合，提供默认建议
-    if (paymentOptions.length === 0) {
-      // 找到大于等于目标金额的最小面额
-      const minValidDenom = validDenoms.find(denom => denom >= targetAmount);
-      if (minValidDenom) {
-        return [minValidDenom];
-      } else {
-        // 使用最大面额的组合
-        const maxDenom = Math.max(...validDenoms);
-        const count = Math.ceil(targetAmount / maxDenom);
-        return [count * maxDenom];
-      }
-    }
-
-    // 移除重复和扩展组合
-    const uniqueCombinations = removeDuplicateAndExtendedCombinations(paymentOptions, targetAmount);
-
-    // 按币种类型数量排序，然后按总硬币数量排序，最后按金额排序
-    uniqueCombinations.sort((a, b) => {
-      if (a.denomTypes !== b.denomTypes) {
-        return a.denomTypes - b.denomTypes;
-      }
-      if (a.coinCount !== b.coinCount) {
-        return a.coinCount - b.coinCount;
-      }
-      return a.sum - b.sum;
-    });
-
-    // 按金额去重并返回推荐的支付金额
-    const uniqueAmounts = new Set();
-    const finalResults = [];
-    for (const item of uniqueCombinations) {
-      const roundedAmount = Math.round(item.sum * 100) / 100; // 处理浮点数精度
-      if (!uniqueAmounts.has(roundedAmount) && finalResults.length < 10) {
-        uniqueAmounts.add(roundedAmount);
-        finalResults.push(roundedAmount);
-      }
-    }
-    return finalResults.sort((a, b) => a - b);
-  } catch (error) {
-    // 发生错误时返回安全的默认值
-    console.warn('推荐支付金额计算出错:', error);
-    // 返回最接近的整数金额作为兜底
-    const safeAmount = Math.ceil(targetAmount);
-    return [targetAmount, safeAmount];
-  }
-}
-
-/**
- * 尝试找到精确匹配目标金额的组合
- */
-function findExactCombination(target, denoms, precision) {
-  // 简单的深度优先搜索，限制搜索深度
-  function dfs(remaining, denomIndex, currentCombination) {
-    if (remaining === 0) {
-      return currentCombination;
-    }
-    if (remaining < 0 || denomIndex >= denoms.length || currentCombination.length > 10) {
-      return null;
-    }
-    const denom = denoms[denomIndex];
-
-    // 尝试使用当前面额 0 到 maxCount 次
-    const maxCount = Math.min(Math.floor(remaining / denom), 8);
-    for (let count = maxCount; count >= 0; count--) {
-      const newCombination = [...currentCombination, ...Array(count).fill(denom)];
-      const result = dfs(remaining - count * denom, denomIndex + 1, newCombination);
-      if (result) {
-        return result;
-      }
-    }
-    return null;
-  }
-  const exactMatch = dfs(target, 0, []);
-  if (exactMatch && exactMatch.length > 0) {
-    const denomTypes = new Set(exactMatch).size;
-    return {
-      combination: exactMatch.map(d => d / precision),
-      sum: target / precision,
-      coinCount: exactMatch.length,
-      denomTypes: denomTypes
-    };
-  }
-  return null;
-}
-
-/**
- * 移除重复和扩展组合
- * 核心原理：如果组合A包含组合B的所有硬币，并且还有额外硬币，则A是B的扩展，应该被移除
- */
-function removeDuplicateAndExtendedCombinations(combinations, targetAmount) {
-  const result = [];
-
-  // 按币种类型数量、硬币数量、金额排序，确保较简单的组合在前面
-  combinations.sort((a, b) => {
-    if (a.denomTypes !== b.denomTypes) {
-      return a.denomTypes - b.denomTypes;
-    }
-    if (a.coinCount !== b.coinCount) {
-      return a.coinCount - b.coinCount;
-    }
-    return a.sum - b.sum;
-  });
-  for (let i = 0; i < combinations.length; i++) {
-    const current = combinations[i];
-    let shouldSkip = false;
-
-    // 检查当前组合是否与已添加的组合重复或者是扩展
-    for (let j = 0; j < result.length; j++) {
-      const existing = result[j];
-
-      // 如果完全相同，跳过
-      if (isSameCombination(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-
-      // 如果当前组合是已存在组合的扩展，跳过
-      if (isExtensionOf(current.combination, existing.combination)) {
-        shouldSkip = true;
-        break;
-      }
-    }
-
-    // 检查是否有其他组合是当前组合的扩展，如果有，移除那些扩展
-    if (!shouldSkip) {
-      // 移除所有当前组合的扩展
-      for (let j = result.length - 1; j >= 0; j--) {
-        if (isExtensionOf(result[j].combination, current.combination)) {
-          result.splice(j, 1);
-        }
-      }
-      result.push(current);
-    }
-  }
-  return result;
-}
-
-/**
- * 检查组合A是否是组合B的扩展（即A包含B的所有硬币，并且还有额外的硬币）
- */
-function isExtensionOf(combinationA, combinationB) {
-  // 如果A的硬币数量少于等于B，A不可能是B的扩展
-  if (combinationA.length <= combinationB.length) {
-    return false;
-  }
-
-  // 统计每个面额的数量
-  const countA = {};
-  const countB = {};
-  combinationA.forEach(coin => {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(coin => {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查B的所有面额在A中是否都有足够的数量
-  for (const coin in countB) {
-    if (!countA[coin] || countA[coin] < countB[coin]) {
-      return false;
-    }
-  }
-
-  // 检查A是否有B没有的额外硬币
-  let hasExtra = false;
-  for (const coin in countA) {
-    if (countA[coin] > (countB[coin] || 0)) {
-      hasExtra = true;
-      break;
-    }
-  }
-  return hasExtra;
-}
-
-/**
- * 检查两个组合是否本质相同（相同的面额组合）
- */
-function isSameCombination(combinationA, combinationB) {
-  if (combinationA.length !== combinationB.length) {
-    return false;
-  }
-  const countA = {};
-  const countB = {};
-  combinationA.forEach(coin => {
-    countA[coin] = (countA[coin] || 0) + 1;
-  });
-  combinationB.forEach(coin => {
-    countB[coin] = (countB[coin] || 0) + 1;
-  });
-
-  // 检查两个组合是否有相同的面额和数量
-  for (const coin in countA) {
-    if (countA[coin] !== (countB[coin] || 0)) {
-      return false;
-    }
-  }
-  for (const coin in countB) {
-    if (countB[coin] !== (countA[coin] || 0)) {
-      return false;
-    }
-  }
-  return true;
+  const precision = 100;
+  const normalizedTarget = Math.round(targetAmount * precision) / precision;
+  const higherDenominations = [...new Set((Array.isArray(denominations) ? denominations : []).filter(denomination => denomination > 0 && Number.isFinite(denomination)).map(denomination => Math.round(denomination * precision) / precision))].filter(denomination => denomination > normalizedTarget).sort((a, b) => a - b).slice(0, 3);
+  return [normalizedTarget, ...higherDenominations];
 }

package/lib/modules/ResourcePlanner/planner.js

@@ -281,12 +281,14 @@ function evaluateCandidateTimeGate(params) {
     };
   }
   if (policy.type === 'before_start') {
-    // Flexible-duration candidates and POS fixed-duration anchors start at
-    // minute precision. Keep that current minute selectable instead of treating
-    // the freshly generated candidate as already started because the query
-    // clock still contains seconds.
+    // POS fixed-duration candidates use the context's stable opening-minute
+    // anchor. Keep that anchored range selectable while it is still active;
+    // otherwise a minute refresh turns it into 0 capacity and incorrectly
+    // advances a create flow to the next slot. The earlier `past` gate still
+    // rejects the anchor once its booking range has ended.
+    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
     const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
-    const hasNotReachedStart = usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start;
+    const hasNotReachedStart = isActivePosDurationAnchor || (usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start);
     if (hasNotReachedStart) return null;
     return {
       status: 'unavailable',
@@ -1249,6 +1251,7 @@ function buildAvailabilityCellIndex(projection) {
 }
 function buildEvaluationContext(params) {
   const evaluatedAt = toDateTime(params.evaluatedAt || params.projection.meta.now, params.projection.meta.timezone);
+  const durationCandidateAnchorAt = toDateTime(params.projection.meta.durationCandidateAnchorAt, params.projection.meta.timezone);
   const selectionsByGroupKey = new Map();
   (params.requirementSelections || []).forEach(selection => {
     const key = selection.requirementGroupId || String(selection.formId ?? '');
@@ -1260,6 +1263,7 @@ function buildEvaluationContext(params) {
     resourceIdSet: params.resourceIds?.length ? new Set(params.resourceIds.map(String)) : null,
     selectionsByGroupKey,
     useExactDurationCandidateMinute: params.useExactDurationCandidateMinute === true,
+    durationCandidateAnchorAtMs: Number.isFinite(durationCandidateAnchorAt) ? floorToMinute(durationCandidateAnchorAt) : null,
     allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true
   };
 }

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

@@ -253,7 +253,8 @@ export interface GetProductTimeRangesRuntimeOptions {
     /**
      * Internal POS capability: fixed-duration candidates start from the stable
      * context anchor's current minute instead of rounding up to ten minutes, and
-     * that minute remains selectable during before-start cutoff evaluation.
+     * that anchored range remains selectable while active during before-start
+     * cutoff evaluation.
      * Other callers keep the legacy alignment and strict second-level cutoff.
      */
     useExactDurationCandidateMinute?: boolean;

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

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

package/package.json

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