@pisell/pisellos 0.10.42 → 0.10.44

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/ProductList/index.d.ts

@@ -1,6 +1,6 @@
 import { Module, PisellCore } from '../../types';
 import { BaseModule } from '../BaseModule';
-import { ProductListLoadProductsParams } from './types';
+import { ProductListLoadProductsParams, ProductListStoreQueryParams } from './types';
 import { ProductData } from '../Product/types';
 export * from './types';
 export declare class ProductList extends BaseModule implements Module {
@@ -52,6 +52,7 @@ export declare class ProductList extends BaseModule implements Module {
     getRawProductPriceSources(ids: number[]): Map<number, ProductData>;
     getProducts(): Promise<ProductData[]>;
     getProduct(id: number): Promise<ProductData | undefined>;
+    queryProducts(params?: ProductListStoreQueryParams): Promise<ProductData[]>;
     getProductByIds(ids: number[]): Promise<ProductData[] | undefined>;
     addProduct(products: ProductData[]): Promise<void>;
     selectProducts(products: ProductData[]): Promise<void>;

package/dist/modules/ProductList/index.js

@@ -29,6 +29,19 @@ import dayjs from 'dayjs';
 import { isProductQueryHandledByOsServer, PRODUCT_QUERY_DATA_VARIANT_RELATIONS, resolveClientDataVariants } from "./clientDataVariants";
 import { isCustomerUserPlatform } from "../../utils/platform";
 export * from "./types";
+function normalizeQuerySet(values) {
+  if (!Array.isArray(values) || values.length === 0) return null;
+  var normalized = values.map(function (value) {
+    return String(value !== null && value !== void 0 ? value : '').trim();
+  }).filter(Boolean);
+  return normalized.length ? new Set(normalized) : null;
+}
+function matchesAny(values, querySet) {
+  if (!querySet) return true;
+  return values.some(function (value) {
+    return querySet.has(String(value !== null && value !== void 0 ? value : '').trim());
+  });
+}
 export var ProductList = /*#__PURE__*/function (_BaseModule) {
   _inherits(ProductList, _BaseModule);
   var _super = _createSuper(ProductList);
@@ -468,26 +481,93 @@ export var ProductList = /*#__PURE__*/function (_BaseModule) {
       return getProduct;
     }()
   }, {
-    key: "getProductByIds",
+    key: "queryProducts",
     value: function () {
-      var _getProductByIds = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(ids) {
-        var products;
+      var _queryProducts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+        var params,
+          includeIds,
+          excludeIds,
+          categoryIds,
+          collectionIds,
+          extensionTypes,
+          statuses,
+          channelApplications,
+          codeOrBarcode,
+          products,
+          _args9 = arguments;
         return _regeneratorRuntime().wrap(function _callee9$(_context9) {
           while (1) switch (_context9.prev = _context9.next) {
             case 0:
-              _context9.next = 2;
-              return this.core.effects.emit("".concat(this.name, ":onGetProductByIds"), this.store.list);
-            case 2:
-              products = this.store.list.filter(function (product) {
-                return ids.includes(product.id);
+              params = _args9.length > 0 && _args9[0] !== undefined ? _args9[0] : {};
+              includeIds = normalizeQuerySet(params.includeIds);
+              excludeIds = normalizeQuerySet(params.excludeIds);
+              categoryIds = normalizeQuerySet(params.categoryIds);
+              collectionIds = normalizeQuerySet(params.collectionIds);
+              extensionTypes = normalizeQuerySet(params.extensionTypes);
+              statuses = normalizeQuerySet(params.statuses);
+              channelApplications = normalizeQuerySet(params.channelApplications);
+              codeOrBarcode = typeof params.codeOrBarcode === 'string' ? params.codeOrBarcode.trim() : '';
+              products = (this.store.list || []).filter(function (product) {
+                var _product$id, _product$extension_ty, _product$status;
+                var productId = String((_product$id = product.id) !== null && _product$id !== void 0 ? _product$id : '').trim();
+                if (includeIds && !includeIds.has(productId)) return false;
+                if (excludeIds && excludeIds.has(productId)) return false;
+                if (categoryIds) {
+                  var productCategoryIds = (product.categories || []).flatMap(function (category) {
+                    var _category$pivot;
+                    return [category === null || category === void 0 ? void 0 : category.id, category === null || category === void 0 || (_category$pivot = category.pivot) === null || _category$pivot === void 0 ? void 0 : _category$pivot.product_category_id];
+                  });
+                  if (!matchesAny(productCategoryIds, categoryIds)) return false;
+                }
+                if (collectionIds) {
+                  var productCollectionIds = (product.collection || []).map(function (collection) {
+                    return collection === null || collection === void 0 ? void 0 : collection.id;
+                  });
+                  if (!matchesAny(productCollectionIds, collectionIds)) return false;
+                }
+                if (extensionTypes && !extensionTypes.has(String((_product$extension_ty = product.extension_type) !== null && _product$extension_ty !== void 0 ? _product$extension_ty : '').trim())) return false;
+                if (statuses && !statuses.has(String((_product$status = product.status) !== null && _product$status !== void 0 ? _product$status : '').trim())) return false;
+                if (channelApplications) {
+                  if (!matchesAny(product.channel_application || [], channelApplications)) return false;
+                }
+                if (codeOrBarcode) {
+                  var code = typeof product.code === 'string' ? product.code.trim() : '';
+                  var barcode = typeof product.barcode === 'string' ? product.barcode.trim() : '';
+                  if (code !== codeOrBarcode && barcode !== codeOrBarcode) return false;
+                }
+                return true;
               });
-              return _context9.abrupt("return", products);
-            case 4:
+              return _context9.abrupt("return", cloneDeep(products));
+            case 11:
             case "end":
               return _context9.stop();
           }
         }, _callee9, this);
       }));
+      function queryProducts() {
+        return _queryProducts.apply(this, arguments);
+      }
+      return queryProducts;
+    }()
+  }, {
+    key: "getProductByIds",
+    value: function () {
+      var _getProductByIds = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(ids) {
+        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              _context10.next = 2;
+              return this.core.effects.emit("".concat(this.name, ":onGetProductByIds"), this.store.list);
+            case 2:
+              return _context10.abrupt("return", this.queryProducts({
+                includeIds: ids
+              }));
+            case 3:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
       function getProductByIds(_x8) {
         return _getProductByIds.apply(this, arguments);
       }
@@ -496,10 +576,10 @@ export var ProductList = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "addProduct",
     value: function () {
-      var _addProduct = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(products) {
+      var _addProduct = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(products) {
         var _this6 = this;
-        return _regeneratorRuntime().wrap(function _callee10$(_context10) {
-          while (1) switch (_context10.prev = _context10.next) {
+        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
             case 0:
               // list 需要根据 id 去重
               if (!this.store.list) {
@@ -522,9 +602,9 @@ export var ProductList = /*#__PURE__*/function (_BaseModule) {
               this.core.effects.emit("".concat(this.name, ":changed"), this.store.list);
             case 4:
             case "end":
-              return _context10.stop();
+              return _context11.stop();
           }
-        }, _callee10, this);
+        }, _callee11, this);
       }));
       function addProduct(_x9) {
         return _addProduct.apply(this, arguments);
@@ -534,16 +614,16 @@ export var ProductList = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "selectProducts",
     value: function () {
-      var _selectProducts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11(products) {
-        return _regeneratorRuntime().wrap(function _callee11$(_context11) {
-          while (1) switch (_context11.prev = _context11.next) {
+      var _selectProducts = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(products) {
+        return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
             case 0:
               this.store.selectProducts = products;
             case 1:
             case "end":
-              return _context11.stop();
+              return _context12.stop();
           }
-        }, _callee11, this);
+        }, _callee12, this);
       }));
       function selectProducts(_x10) {
         return _selectProducts.apply(this, arguments);

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

@@ -15,6 +15,16 @@ export interface ProductListLoadProductsParams {
     /** 智能定价条件上下文，仅影响策略命中，不参与商品集合筛选 */
     strategy_context?: Record<string, any>;
 }
+export interface ProductListStoreQueryParams {
+    includeIds?: Array<number | string>;
+    excludeIds?: Array<number | string>;
+    categoryIds?: Array<number | string>;
+    collectionIds?: Array<number | string>;
+    extensionTypes?: string[];
+    statuses?: ProductData['status'][];
+    channelApplications?: string[];
+    codeOrBarcode?: string;
+}
 export interface ProductListData {
     list: ProductData[];
     selectProducts: ProductData[];

package/dist/modules/Rules/index.js

@@ -1813,7 +1813,8 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
 
               // 计算折扣后的价格（使用 getDiscountAmount，内部已处理 maxDeductionAmount）
               var discountedPrice = getDiscountAmount(_selectedDiscount2, product.origin_total, product.origin_total);
-              var bundleDiscountAmount = new Decimal(product.origin_total || 0).minus(discountedPrice).toNumber();
+              var bundleDiscountAmountPerItem = new Decimal(product.origin_total || 0).minus(discountedPrice).toNumber();
+              var bundleDiscountAmount = new Decimal(bundleDiscountAmountPerItem).mul(_appliedUseCount).toNumber();
               debugger;
               var _discountDetail = {
                 amount: bundleDiscountAmount,

package/dist/server/index.d.ts

@@ -421,6 +421,7 @@ declare class Server {
     private shouldUseLocalOrderQuery;
     /**
      * 预约查询是否走本地：
+     * - 日历周/月/资源视图通过 compact_fields 显式标识，始终走远端；
      * - 当 sales_time_between 的开始和结束都不是今天时，走远端；
      * - 其余情况走本地。
      */
@@ -524,6 +525,12 @@ declare class Server {
     private stringifyCheckoutResourceIdentifier;
     private normalizeCheckoutSubmitData;
     private ensureCheckoutOrderNumbers;
+    /**
+     * Notes 允许在本地草稿阶段暂存空订单目标；checkout 的统一出口负责用最终
+     * shop_order_number 完成绑定并校验，保证后端请求、pending、设备任务和打印
+     * 都使用同一份完整快照。
+     */
+    private finalizeCheckoutSalesNotes;
     private dispatchCheckoutSyncTask;
     private dispatchPrintOtherReceiptTask;
     private buildPrintOtherReceiptIdempotencyKey;