@pisell/pisellos 0.10.42 → 0.10.44

package/lib/modules/Order/utils.js

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "buildManualProductDiscountItem", {
 });
 exports.buildPointCardSnapshotFromWalletPassList = buildPointCardSnapshotFromWalletPassList;
 exports.buildSubmitPayload = buildSubmitPayload;
+exports.buildVirtualCurrencySnapshotFromList = buildVirtualCurrencySnapshotFromList;
 exports.calculateOrderProductsDeposit = calculateOrderProductsDeposit;
 exports.clearTempOrderHolderAssignments = clearTempOrderHolderAssignments;
 exports.composeLinePrice = composeLinePrice;
@@ -74,6 +75,7 @@ exports.normalizePointCardSnapshotItem = normalizePointCardSnapshotItem;
 exports.normalizeProductSkuOptions = normalizeProductSkuOptions;
 exports.normalizeSubmitBooking = normalizeSubmitBooking;
 exports.normalizeSubmitCollectPaxValue = normalizeSubmitCollectPaxValue;
+exports.normalizeVirtualCurrencySnapshotItem = normalizeVirtualCurrencySnapshotItem;
 exports.productRequiresFormSubject = productRequiresFormSubject;
 exports.resolveEffectivePerUnitDiscount = resolveEffectivePerUnitDiscount;
 exports.resolveIsFormSubject = resolveIsFormSubject;
@@ -129,9 +131,11 @@ var _decimal = _interopRequireDefault(require("decimal.js"));
 var _utils = require("../Holder/utils");
 var _utils2 = require("../../solution/ScanOrder/utils");
 var _orderCollectionIdentity = require("./utils/orderCollectionIdentity");
+var _salesNotes = require("./salesNotes");
 var _manualProductDiscount = require("./utils/manualProductDiscount");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 const POINT_CARD_SNAPSHOT_TAG = 'point_card';
+const VIRTUAL_CURRENCY_SNAPSHOT_TAG = 'virtual_currency';
 function isPlainObject(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -169,6 +173,101 @@ function buildPointCardSnapshotFromWalletPassList(value) {
     return result;
   }, []);
 }
+function normalizeSnapshotNameMap(value) {
+  if (typeof value === 'string' || typeof value === 'number') {
+    const normalizedText = String(value).trim();
+    return normalizedText ? {
+      original: normalizedText
+    } : {};
+  }
+  if (!isPlainObject(value)) return {};
+  return Object.entries(value).reduce((result, [locale, text]) => {
+    if (!locale.trim()) return result;
+    if (typeof text !== 'string' && typeof text !== 'number') return result;
+    const normalizedText = String(text).trim();
+    if (normalizedText) result[locale] = normalizedText;
+    return result;
+  }, {});
+}
+function buildVirtualCurrencySnapshotName(value) {
+  if (!isPlainObject(value)) return {};
+  const amountFormat = String(value.amount_format ?? '').trim();
+  let configuredName;
+  if (amountFormat === '{{amount}} {{unit}}') {
+    configuredName = value.unit_label;
+  } else if (amountFormat === '{{amount}} {{sym}}') {
+    configuredName = value.symbol;
+  } else {
+    return {};
+  }
+  const configuredNameMap = normalizeSnapshotNameMap(configuredName);
+  const shortNameMap = normalizeSnapshotNameMap(value.short_name);
+
+  // The configured unit/symbol is resolved before short_name. If it already
+  // carries a global fallback, keep it authoritative so (for example)
+  // short_name.en cannot mask unit_label.original. When it only has explicit
+  // locale entries, merge short_name so other receipt locales can still fall
+  // back after the configured value has no match.
+  const hasConfiguredGlobalFallback = ['original', 'auto', 'default', 'en'].some(locale => Boolean(configuredNameMap[locale]));
+  if (hasConfiguredGlobalFallback) return configuredNameMap;
+  return {
+    ...shortNameMap,
+    ...configuredNameMap
+  };
+}
+function normalizeVirtualCurrencySnapshotItem(value) {
+  if (!isPlainObject(value)) return null;
+  const id = normalizeSnapshotScalar(value.id);
+  if (id === undefined) return null;
+  if (String(value.tag || '').trim().toLowerCase() !== VIRTUAL_CURRENCY_SNAPSHOT_TAG) {
+    return null;
+  }
+  const snapshot = {
+    id,
+    tag: 'virtual_currency',
+    product_name: String(value.product_name ?? ''),
+    par_value: String(value.par_value ?? ''),
+    used_par_value: String(value.used_par_value ?? ''),
+    name: normalizeSnapshotNameMap(value.name)
+  };
+  const productId = normalizeSnapshotScalar(value.product_id);
+  if (productId !== undefined) {
+    snapshot.product_id = productId;
+  }
+  return snapshot;
+}
+function normalizeVirtualCurrencySnapshotList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.reduce((result, item) => {
+    const normalized = normalizeVirtualCurrencySnapshotItem(item);
+    if (normalized) result.push(normalized);
+    return result;
+  }, []);
+}
+function buildVirtualCurrencySnapshotFromList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.reduce((result, item) => {
+    if (!isPlainObject(item)) return result;
+    const id = normalizeSnapshotScalar(item.id);
+    if (id === undefined) return result;
+    const sourceTag = String(item.tag ?? '').trim().toLowerCase();
+    if (sourceTag !== VIRTUAL_CURRENCY_SNAPSHOT_TAG) return result;
+    const snapshot = {
+      id,
+      tag: 'virtual_currency',
+      product_name: String(item.product_name ?? ''),
+      par_value: String(item.par_value ?? ''),
+      used_par_value: String(item.used_par_value ?? ''),
+      name: buildVirtualCurrencySnapshotName(item.virtual_currency_display)
+    };
+    const productId = normalizeSnapshotScalar(item.product_id);
+    if (productId !== undefined) {
+      snapshot.product_id = productId;
+    }
+    result.push(snapshot);
+    return result;
+  }, []);
+}
 function normalizeOrderMetaList(value) {
   if (value === undefined) return undefined;
   if (!isPlainObject(value)) return undefined;
@@ -176,6 +275,9 @@ function normalizeOrderMetaList(value) {
   if (Object.prototype.hasOwnProperty.call(value, 'point_cards_snapshot')) {
     normalized.point_cards_snapshot = buildPointCardSnapshotFromWalletPassList(value.point_cards_snapshot);
   }
+  if (Object.prototype.hasOwnProperty.call(value, 'virtual_currency_snapshot')) {
+    normalized.virtual_currency_snapshot = normalizeVirtualCurrencySnapshotList(value.virtual_currency_snapshot);
+  }
   if (Object.keys(normalized).length > 0) return normalized;
   return {};
 }
@@ -1225,6 +1327,7 @@ function createDefaultTempOrder(params) {
     request_unique_idempotency_token: '',
     vouchers: [],
     products: [],
+    notes: [],
     bookings: [],
     payments: [],
     surcharges: [],
@@ -1234,7 +1337,11 @@ function createDefaultTempOrder(params) {
     holder: null,
     metadata: {},
     _extend: {
-      productsByUid: {}
+      productsByUid: {},
+      salesNotesState: {
+        loaded: true,
+        dirty: false
+      }
     }
   };
 }
@@ -1318,6 +1425,7 @@ function buildSubmitPayload(params) {
     create_date: _createDate,
     holder_id: _holderId,
     payment_status: _paymentStatus,
+    notes: _notes,
     ...tempOrderRest
   } = tempOrder;
   const resolvedBusinessCode = businessCode ?? tempOrder.business_code;
@@ -1381,6 +1489,11 @@ function buildSubmitPayload(params) {
         ...rest
       };
     })(),
+    ...(tempOrder._extend?.salesNotesState?.dirty ? {
+      notes: (0, _salesNotes.encodeSalesNotes)(tempOrder.notes || [], {
+        allowUnresolvedOrderTarget: true
+      })
+    } : {}),
     products: (tempOrder.products || []).map(product => normalizeSubmitProduct(product, {
       virtualSettlementMode
     })),

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/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/lib/modules/ProductList/index.js

@@ -25,6 +25,15 @@ Object.keys(_types).forEach(function (key) {
   });
 });
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function normalizeQuerySet(values) {
+  if (!Array.isArray(values) || values.length === 0) return null;
+  const normalized = values.map(value => String(value ?? '').trim()).filter(Boolean);
+  return normalized.length ? new Set(normalized) : null;
+}
+function matchesAny(values, querySet) {
+  if (!querySet) return true;
+  return values.some(value => querySet.has(String(value ?? '').trim()));
+}
 class ProductList extends _BaseModule.BaseModule {
   defaultName = 'productList';
   defaultVersion = '1.0.0';
@@ -281,10 +290,46 @@ class ProductList extends _BaseModule.BaseModule {
     const product = this.store.list.find(product => product.id === id);
     return product ? (0, _lodashEs.cloneDeep)(product) : undefined;
   }
+  async queryProducts(params = {}) {
+    const includeIds = normalizeQuerySet(params.includeIds);
+    const excludeIds = normalizeQuerySet(params.excludeIds);
+    const categoryIds = normalizeQuerySet(params.categoryIds);
+    const collectionIds = normalizeQuerySet(params.collectionIds);
+    const extensionTypes = normalizeQuerySet(params.extensionTypes);
+    const statuses = normalizeQuerySet(params.statuses);
+    const channelApplications = normalizeQuerySet(params.channelApplications);
+    const codeOrBarcode = typeof params.codeOrBarcode === 'string' ? params.codeOrBarcode.trim() : '';
+    const products = (this.store.list || []).filter(product => {
+      const productId = String(product.id ?? '').trim();
+      if (includeIds && !includeIds.has(productId)) return false;
+      if (excludeIds && excludeIds.has(productId)) return false;
+      if (categoryIds) {
+        const productCategoryIds = (product.categories || []).flatMap(category => [category?.id, category?.pivot?.product_category_id]);
+        if (!matchesAny(productCategoryIds, categoryIds)) return false;
+      }
+      if (collectionIds) {
+        const productCollectionIds = (product.collection || []).map(collection => collection?.id);
+        if (!matchesAny(productCollectionIds, collectionIds)) return false;
+      }
+      if (extensionTypes && !extensionTypes.has(String(product.extension_type ?? '').trim())) return false;
+      if (statuses && !statuses.has(String(product.status ?? '').trim())) return false;
+      if (channelApplications) {
+        if (!matchesAny(product.channel_application || [], channelApplications)) return false;
+      }
+      if (codeOrBarcode) {
+        const code = typeof product.code === 'string' ? product.code.trim() : '';
+        const barcode = typeof product.barcode === 'string' ? product.barcode.trim() : '';
+        if (code !== codeOrBarcode && barcode !== codeOrBarcode) return false;
+      }
+      return true;
+    });
+    return (0, _lodashEs.cloneDeep)(products);
+  }
   async getProductByIds(ids) {
     await this.core.effects.emit(`${this.name}:onGetProductByIds`, this.store.list);
-    const products = this.store.list.filter(product => ids.includes(product.id));
-    return products;
+    return this.queryProducts({
+      includeIds: ids
+    });
   }
   async addProduct(products) {
     // list 需要根据 id 去重

package/lib/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[];