@pisell/pisellos 2.3.73 → 2.3.75

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

@@ -1,49 +1,15 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/model/strategy/adapter/walletPass/utils.ts
-var utils_exports = {};
-__export(utils_exports, {
-  getApplicableProductIds: () => getApplicableProductIds,
-  getBundleItemIsDiscountPrice: () => getBundleItemIsDiscountPrice,
-  getBundleItemIsMarkupOrDiscountPrice: () => getBundleItemIsMarkupOrDiscountPrice,
-  getBundleItemIsMarkupPrice: () => getBundleItemIsMarkupPrice,
-  getBundleItemIsOriginalPrice: () => getBundleItemIsOriginalPrice,
-  getBundleItemPrice: () => getBundleItemPrice,
-  getMainProductPrice: () => getMainProductPrice,
-  getProductQuantity: () => getProductQuantity,
-  processVouchers: () => processVouchers,
-  recalculateVouchers: () => recalculateVouchers,
-  resolveWalletPassLineKey: () => resolveWalletPassLineKey
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(utils_exports);
-var import_decimal = __toESM(require("decimal.js"));
-var DEFAULT_WALLET_PASS_CALCULATION_CONFIG = {
+exports.getProductQuantity = exports.getMainProductPrice = exports.getBundleItemPrice = exports.getBundleItemIsOriginalPrice = exports.getBundleItemIsMarkupPrice = exports.getBundleItemIsMarkupOrDiscountPrice = exports.getBundleItemIsDiscountPrice = exports.getApplicableProductIds = void 0;
+exports.processVouchers = processVouchers;
+exports.recalculateVouchers = recalculateVouchers;
+exports.resolveWalletPassLineKey = resolveWalletPassLineKey;
+var _decimal = _interopRequireDefault(require("decimal.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_WALLET_PASS_CALCULATION_CONFIG = {
   maxDeductionAmount: 99999,
   maxUsagePerOrder: 0,
   allowCrossProduct: true,
@@ -55,338 +21,477 @@ var DEFAULT_WALLET_PASS_CALCULATION_CONFIG = {
 function getWalletPassCalculationConfig(voucher) {
   return {
     ...DEFAULT_WALLET_PASS_CALCULATION_CONFIG,
-    ...(voucher == null ? void 0 : voucher.config) || {}
+    ...(voucher?.config || {})
   };
 }
-var getProductQuantity = (product) => {
+
+/** 订单商品数量 */
+const getProductQuantity = product => {
   return product.quantity || product.product_quantity || 1;
 };
+
+/**
+ * 订单商品行唯一键，用于 maxPassesPerItem 按行、按件配额（同 SPU 不同规格视为不同行）。
+ */
+exports.getProductQuantity = getProductQuantity;
 function resolveWalletPassLineKey(product, indexInOrder) {
-  const m = (product == null ? void 0 : product.metadata) || {};
+  const m = product?.metadata || {};
   const u1 = m.product_unique;
-  if (u1 != null && String(u1).length > 0)
-    return String(u1);
+  if (u1 != null && String(u1).length > 0) return String(u1);
   const u2 = m.unique_identification_number;
-  if (u2 != null && String(u2).length > 0)
-    return String(u2);
-  if ((product == null ? void 0 : product.id) != null && String(product.id).length > 0)
-    return `order_item:${product.id}`;
-  if ((product == null ? void 0 : product.product_unique_string) != null && String(product.product_unique_string).length > 0) {
+  if (u2 != null && String(u2).length > 0) return String(u2);
+  if (product?.id != null && String(product.id).length > 0) return `order_item:${product.id}`;
+  if (product?.product_unique_string != null && String(product.product_unique_string).length > 0) {
     return String(product.product_unique_string);
   }
   return `order_line_${indexInOrder}`;
 }
 function getExpandedOrderLineQuantity(p) {
-  if ((p == null ? void 0 : p._orderLineQuantity) != null && p._orderLineQuantity > 0)
-    return p._orderLineQuantity;
+  if (p?._orderLineQuantity != null && p._orderLineQuantity > 0) return p._orderLineQuantity;
   return getProductQuantity(p);
 }
+
+/** 该行允许消耗的「券次」上限：maxPassesPerItem × 订单行件数 */
 function getMaxPassSlotsForExpandedLine(maxPassesPerItem, p) {
-  if (maxPassesPerItem <= 0)
-    return Infinity;
+  if (maxPassesPerItem <= 0) return Infinity;
   return maxPassesPerItem * getExpandedOrderLineQuantity(p);
 }
+
+/**
+ * 本次抵扣占用多少「券次」配额：有抵扣时至少占 1，并与按金额折算的件数挂钩，不超过剩余额度。
+ */
 function computePassSlotsIncrement(deductAmount, deductQty, maxPassesPerItem, orderLineQuantity, currentUsage) {
-  if (maxPassesPerItem <= 0 || !deductAmount.greaterThan(0))
-    return 0;
+  if (maxPassesPerItem <= 0 || !deductAmount.greaterThan(0)) return 0;
   const cap = maxPassesPerItem * orderLineQuantity;
   const room = Math.max(0, cap - currentUsage);
-  if (room <= 0)
-    return 0;
+  if (room <= 0) return 0;
   const raw = Math.max(1, Math.ceil(Number(deductQty)) || 1);
   return Math.min(raw, room);
 }
 function applyMaxPassUsageIncrements(usageMap, walletPassProductId, maxPassesPerItem, deductionDetails) {
-  deductionDetails.forEach((detail) => {
-    var _a;
+  deductionDetails.forEach(detail => {
     const lineKey = detail.lineKey;
-    if (!lineKey || maxPassesPerItem <= 0)
-      return;
+    if (!lineKey || maxPassesPerItem <= 0) return;
     const orderLineQty = detail.orderLineQuantity != null && detail.orderLineQuantity > 0 ? detail.orderLineQuantity : 1;
-    const cur = ((_a = usageMap.get(walletPassProductId)) == null ? void 0 : _a.get(lineKey)) || 0;
-    const inc = computePassSlotsIncrement(
-      new import_decimal.default(detail.deductAmount),
-      detail.deductQuantity,
-      maxPassesPerItem,
-      orderLineQty,
-      cur
-    );
-    if (inc <= 0)
-      return;
-    if (!usageMap.has(walletPassProductId))
-      usageMap.set(walletPassProductId, /* @__PURE__ */ new Map());
+    const cur = usageMap.get(walletPassProductId)?.get(lineKey) || 0;
+    const inc = computePassSlotsIncrement(new _decimal.default(detail.deductAmount), detail.deductQuantity, maxPassesPerItem, orderLineQty, cur);
+    if (inc <= 0) return;
+    if (!usageMap.has(walletPassProductId)) usageMap.set(walletPassProductId, new Map());
     const inner = usageMap.get(walletPassProductId);
     inner.set(lineKey, cur + inc);
   });
 }
-var getRecommendedAmount = (voucher) => {
-  const { config, recommended_usage_amount, recommended_pure_product_usage_amount } = voucher;
-  const deductTaxAndFee = (config == null ? void 0 : config.deductTaxAndFee) ?? true;
+
+// 辅助函数：根据 deductTaxAndFee 配置获取推荐使用金额
+const getRecommendedAmount = voucher => {
+  const {
+    config,
+    recommended_usage_amount,
+    recommended_pure_product_usage_amount
+  } = voucher;
+  const deductTaxAndFee = config?.deductTaxAndFee ?? true; // 默认开启抵扣税费
+
+  // 扫码接口的 recommended_* 金额包含搜索时已选券的上下文，可能只是当时的
+  // 剩余可抵扣额。取消其他券后，前端重算需要回到资产自身金额基准，再由
+  // 剩余订单金额、适用商品金额和策略上限重新裁剪。
   const rawRecalculationBaseAmount = voucher._wallet_asset_recalculation_base_amount;
-  if (rawRecalculationBaseAmount !== void 0 && rawRecalculationBaseAmount !== null) {
+  if (rawRecalculationBaseAmount !== undefined && rawRecalculationBaseAmount !== null) {
     const recalculationBaseAmount = Number(rawRecalculationBaseAmount);
     if (Number.isFinite(recalculationBaseAmount) && recalculationBaseAmount >= 0) {
       return recalculationBaseAmount;
     }
   }
+
+  // 如果开启抵扣税费，使用 recommended_usage_amount（包含税费）
+  // 如果关闭抵扣税费，使用 recommended_pure_product_usage_amount（仅商品金额）
   return deductTaxAndFee ? recommended_usage_amount : recommended_pure_product_usage_amount ?? recommended_usage_amount;
 };
-var getApplicableProductIds = (voucher) => {
-  const { available_product_type, available_product_ids } = voucher;
-  const productType = available_product_type || "product_all";
-  if (productType === "product_all") {
+
+// 辅助函数：获取适用商品ID列表
+const getApplicableProductIds = voucher => {
+  const {
+    available_product_type,
+    available_product_ids
+  } = voucher;
+
+  // 如果没有 available_product_type，默认为 product_all
+  const productType = available_product_type || 'product_all';
+
+  // product_all 时，返回 null 表示适用所有商品
+  if (productType === 'product_all') {
     return null;
   }
-  if (productType === "product_collection" || productType === "products") {
+
+  // product_collection 或 products 时，返回指定的商品ID列表
+  if (productType === 'product_collection' || productType === 'products') {
     return available_product_ids || [];
   }
+
+  // 其他情况默认返回空数组（不适用任何商品）
   return [];
 };
-var getApplicableProductsAmount = (voucher, productsData) => {
+
+// 辅助函数：计算适用商品的总金额（基于剩余金额）
+exports.getApplicableProductIds = getApplicableProductIds;
+const getApplicableProductsAmount = (voucher, productsData) => {
   const applicableProductIds = getApplicableProductIds(voucher);
-  const { config } = voucher;
-  const deductTaxAndFee = (config == null ? void 0 : config.deductTaxAndFee) ?? true;
-  const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
+  const {
+    config
+  } = voucher;
+  const deductTaxAndFee = config?.deductTaxAndFee ?? true;
+
+  // 根据券的配置选择使用哪个金额字段
+  const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
+
+  // 如果为 null，适用于所有商品
   if (applicableProductIds === null) {
-    return productsData.filter((p) => p[amountField].greaterThan(0)).reduce((sum, p) => sum.plus(p[amountField]), new import_decimal.default(0));
+    return productsData.filter(p => p[amountField].greaterThan(0)).reduce((sum, p) => sum.plus(p[amountField]), new _decimal.default(0));
   }
+
+  // 如果为空数组，不适用任何商品
   if (applicableProductIds.length === 0) {
-    return new import_decimal.default(0);
+    return new _decimal.default(0);
   }
-  return productsData.filter((p) => applicableProductIds.includes(p.product_id) && p[amountField].greaterThan(0)).reduce((sum, p) => sum.plus(p[amountField]), new import_decimal.default(0));
+
+  // 计算指定商品的总金额
+  return productsData.filter(p => applicableProductIds.includes(p.product_id) && p[amountField].greaterThan(0)).reduce((sum, p) => sum.plus(p[amountField]), new _decimal.default(0));
 };
-var getApplicableProducts = (voucher, productsData) => {
+
+// 辅助函数：获取适用的商品列表
+const getApplicableProducts = (voucher, productsData) => {
   const applicableProductIds = getApplicableProductIds(voucher);
+
+  // 如果为 null，适用于所有商品
   if (applicableProductIds === null) {
     return productsData;
   }
+
+  // 如果为空数组，不适用任何商品
   if (applicableProductIds.length === 0) {
     return [];
   }
-  return productsData.filter((p) => applicableProductIds.includes(p.product_id));
+
+  // 返回指定的商品列表
+  return productsData.filter(p => applicableProductIds.includes(p.product_id));
 };
+
+/**
+ * 优惠券处理函数
+ * @param applicableVouchers 可用的券列表
+ * @param orderTotalAmount 订单总金额
+ * @param products 订单商品列表
+ * @returns 返回推荐券列表和全部列表，每个券包含 _available_max_amount 和 _unified_available_status
+ */
 function processVouchers(applicableVouchers, orderTotalAmount, products) {
+  // 拆分商品数据，同时维护含税和不含税两个金额池
+  // remainingAmountWithTax: 含税费的剩余可抵扣金额
+  // remainingAmountPure: 纯商品金额（不含税费）的剩余可抵扣金额
+  // 在抵扣时，会根据券的 deductTaxAndFee 配置选择从哪个金额池扣除
   const productsCopy = expandProductsWithBundleItems(products, true);
-  let remainingOrderAmount = new import_decimal.default(orderTotalAmount);
+  let remainingOrderAmount = new _decimal.default(orderTotalAmount); // 订单剩余应付金额
+
+  // ========== 辅助工具：maxPassesPerItem（按订单行 + 件数）追踪 ==========
   const getItemPassUsage = (usageMap, walletPassProductId, lineKey) => {
-    var _a;
-    return ((_a = usageMap.get(walletPassProductId)) == null ? void 0 : _a.get(lineKey)) || 0;
+    return usageMap.get(walletPassProductId)?.get(lineKey) || 0;
   };
-  const filterByMaxPassesPerItem = (products2, usageMap, walletPassProductId, maxPassesPerItem) => {
-    if (maxPassesPerItem <= 0)
-      return products2;
-    return products2.filter((p) => {
+
+  // 按 maxPassesPerItem 过滤：排除已达到该行「券次」上限的展开行（按 _walletPassLineKey）
+  const filterByMaxPassesPerItem = (products, usageMap, walletPassProductId, maxPassesPerItem) => {
+    if (maxPassesPerItem <= 0) return products;
+    return products.filter(p => {
       const lineKey = p._walletPassLineKey;
-      if (!lineKey)
-        return true;
+      if (!lineKey) return true;
       return getItemPassUsage(usageMap, walletPassProductId, lineKey) < getMaxPassSlotsForExpandedLine(maxPassesPerItem, p);
     });
   };
+  // ================================================================
+
+  // 辅助函数：计算单张券的 _available_max_amount
   const calculateAvailableMaxAmount = (voucher, productsData, itemPassUsage) => {
-    const { config } = voucher;
-    const { maxDeductionAmount = 0, allowCrossProduct = true, applicableProductLimit = 0, deductTaxAndFee = true, maxPassesPerItem = 0 } = config ?? {};
+    const {
+      config
+    } = voucher;
+    const {
+      maxDeductionAmount = 0,
+      allowCrossProduct = true,
+      applicableProductLimit = 0,
+      deductTaxAndFee = true,
+      maxPassesPerItem = 0
+    } = config ?? {};
+
+    // 根据 deductTaxAndFee 配置获取推荐金额
     const recommendedAmount = getRecommendedAmount(voucher);
-    const baseAmount = import_decimal.default.min(
-      new import_decimal.default(recommendedAmount),
-      new import_decimal.default(maxDeductionAmount)
-    );
-    const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
-    const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
-    let applicableProducts = getApplicableProducts(voucher, productsData).filter((p) => p[amountField].greaterThan(0));
+
+    // 基础值 = min(recommendedAmount, maxDeductionAmount)
+    const baseAmount = _decimal.default.min(new _decimal.default(recommendedAmount), new _decimal.default(maxDeductionAmount));
+
+    // 根据券的配置选择使用哪个单价字段和金额字段
+    const unitPriceField = deductTaxAndFee ? 'unitPriceWithTax' : 'unitPricePure';
+    const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
+
+    // 获取适用商品列表（只筛选有剩余金额的商品）
+    let applicableProducts = getApplicableProducts(voucher, productsData).filter(p => p[amountField].greaterThan(0));
+
+    // 按 maxPassesPerItem 过滤：排除已达到单商品可用卡券上限的商品
     if (itemPassUsage) {
       applicableProducts = filterByMaxPassesPerItem(applicableProducts, itemPassUsage, voucher.product_id, maxPassesPerItem);
     }
     if (applicableProducts.length === 0) {
-      return new import_decimal.default(0);
+      return new _decimal.default(0);
     }
-    let finalApplicableAmount = new import_decimal.default(0);
+
+    // 根据跨商品配置计算适用商品金额
+    let finalApplicableAmount = new _decimal.default(0);
     if (allowCrossProduct) {
+      // 跨商品券：可以抵扣多个商品
       if (applicableProductLimit > 0) {
+        // 有数量限制：按剩余金额从高到低排序，按动态计算的可抵扣数量累计直到达到 limit
         const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
         let remainingLimit = applicableProductLimit;
         for (const product of sortedProducts) {
-          if (remainingLimit <= 0)
-            break;
+          if (remainingLimit <= 0) break;
+          // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
           const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
           const deductQty = Math.min(currentAvailableQty, remainingLimit);
-          const deductAmount = import_decimal.default.min(
-            product[unitPriceField].times(deductQty),
-            product[amountField]
-          );
+          // 实际可抵扣金额 = min(数量 * 单价, 剩余金额)
+          const deductAmount = _decimal.default.min(product[unitPriceField].times(deductQty), product[amountField]);
           finalApplicableAmount = finalApplicableAmount.plus(deductAmount);
           remainingLimit -= deductQty;
         }
       } else {
-        finalApplicableAmount = applicableProducts.reduce(
-          (sum, p) => sum.plus(p[amountField]),
-          new import_decimal.default(0)
-        );
+        // 无数量限制：所有适用商品的剩余金额总和
+        finalApplicableAmount = applicableProducts.reduce((sum, p) => sum.plus(p[amountField]), new _decimal.default(0));
       }
     } else {
-      const maxProduct = applicableProducts.reduce(
-        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
-      );
+      // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
+      const maxProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
+      // maxPassesPerItem 限制每张券最多抵扣的单位数
       if (maxPassesPerItem > 0) {
-        finalApplicableAmount = import_decimal.default.min(
-          maxProduct[unitPriceField].times(maxPassesPerItem),
-          maxProduct[amountField]
-        );
+        finalApplicableAmount = _decimal.default.min(maxProduct[unitPriceField].times(maxPassesPerItem), maxProduct[amountField]);
       } else {
         finalApplicableAmount = maxProduct[amountField];
       }
     }
-    return import_decimal.default.min(baseAmount, finalApplicableAmount, remainingOrderAmount);
+
+    // 返回最小值
+    return _decimal.default.min(baseAmount, finalApplicableAmount, remainingOrderAmount);
   };
-  const isVoucherAvailable = (voucher, productsData, usedVoucherCounts2, itemPassUsage) => {
-    const { config, product_id } = voucher;
+
+  // 辅助函数：判断券是否可用，返回可用性和原因代码
+  const isVoucherAvailable = (voucher, productsData, usedVoucherCounts, itemPassUsage) => {
+    const {
+      config,
+      product_id
+    } = voucher;
+
+    // 根据 deductTaxAndFee 配置获取推荐金额
     const recommendedAmount = getRecommendedAmount(voucher);
+
+    // 余额为 0
     if (recommendedAmount <= 0) {
-      return { isAvailable: false, reasonCode: "not_meet_the_required_conditions" };
+      return {
+        isAvailable: false,
+        reasonCode: 'not_meet_the_required_conditions'
+      };
     }
+
+    // 订单金额已抵扣完
     if (remainingOrderAmount.lessThanOrEqualTo(0)) {
-      return { isAvailable: false, reasonCode: "exceeds_the_maximum_deduction_limit" };
+      return {
+        isAvailable: false,
+        reasonCode: 'exceeds_the_maximum_deduction_limit'
+      };
     }
+
+    // 适用商品金额已被抵扣完
     const applicableAmount = getApplicableProductsAmount(voucher, productsData);
     if (applicableAmount.lessThanOrEqualTo(0)) {
-      return { isAvailable: false, reasonCode: "not_meet_the_required_conditions" };
+      return {
+        isAvailable: false,
+        reasonCode: 'not_meet_the_required_conditions'
+      };
     }
-    if (((config == null ? void 0 : config.maxUsagePerOrder) || 0) > 0) {
-      const usedCount = usedVoucherCounts2.get(product_id) || 0;
-      if (usedCount >= ((config == null ? void 0 : config.maxUsagePerOrder) || 0)) {
-        return { isAvailable: false, reasonCode: "usage_limit_reached" };
+
+    // 检查 maxUsagePerOrder（同 product_id 的券），0 表示不限制
+    if ((config?.maxUsagePerOrder || 0) > 0) {
+      const usedCount = usedVoucherCounts.get(product_id) || 0;
+      if (usedCount >= (config?.maxUsagePerOrder || 0)) {
+        return {
+          isAvailable: false,
+          reasonCode: 'usage_limit_reached'
+        };
       }
     }
-    const maxPassesPerItem = (config == null ? void 0 : config.maxPassesPerItem) || 0;
+
+    // 检查 maxPassesPerItem：如果所有适用商品都已达到单商品可用卡券上限，则不可用
+    const maxPassesPerItem = config?.maxPassesPerItem || 0;
     if (maxPassesPerItem > 0 && itemPassUsage) {
-      const deductTaxAndFee = (config == null ? void 0 : config.deductTaxAndFee) ?? true;
-      const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
-      const availableAfterPassLimit = getApplicableProducts(voucher, productsData).filter((p) => p[amountField].greaterThan(0)).filter((p) => {
+      const deductTaxAndFee = config?.deductTaxAndFee ?? true;
+      const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
+      const availableAfterPassLimit = getApplicableProducts(voucher, productsData).filter(p => p[amountField].greaterThan(0)).filter(p => {
         const lineKey = p._walletPassLineKey;
-        if (!lineKey)
-          return true;
+        if (!lineKey) return true;
         return getItemPassUsage(itemPassUsage, product_id, lineKey) < getMaxPassSlotsForExpandedLine(maxPassesPerItem, p);
       });
       if (availableAfterPassLimit.length === 0) {
-        return { isAvailable: false, reasonCode: "max_passes_per_item_reached" };
+        return {
+          isAvailable: false,
+          reasonCode: 'max_passes_per_item_reached'
+        };
       }
     }
-    return { isAvailable: true };
+    return {
+      isAvailable: true
+    };
   };
-  const usedVoucherCountsForAll = /* @__PURE__ */ new Map();
-  const allVouchersWithStatus = applicableVouchers.map((voucher) => {
-    const _available_max_amount = calculateAvailableMaxAmount(
-      voucher,
-      productsCopy
-    );
-    const availabilityResult = isVoucherAvailable(
-      voucher,
-      productsCopy,
-      usedVoucherCountsForAll
-    );
+
+  // ========== 第一步：为所有券计算初始的 _available_max_amount 和 _unified_available_status ==========
+  const usedVoucherCountsForAll = new Map();
+  const allVouchersWithStatus = applicableVouchers.map(voucher => {
+    const _available_max_amount = calculateAvailableMaxAmount(voucher, productsCopy);
+    const availabilityResult = isVoucherAvailable(voucher, productsCopy, usedVoucherCountsForAll);
     const _unified_available_status = availabilityResult.isAvailable ? 1 : 0;
     return {
       ...voucher,
       _available_max_amount: _available_max_amount.toNumber(),
       // 转换为数字
       _unified_available_status,
-      ...availabilityResult.reasonCode && { reasonCode: availabilityResult.reasonCode }
+      ...(availabilityResult.reasonCode && {
+        reasonCode: availabilityResult.reasonCode
+      })
     };
   });
+
+  // ========== 第二步：计算推荐券列表 ==========
   const recommendedVouchers = [];
-  const usedVoucherCounts = /* @__PURE__ */ new Map();
+  const usedVoucherCounts = new Map(); // 跟踪每个券 ID 的使用次数
+
+  // 重置商品余额追踪（同时维护含税和不含税两个金额池）
   const productsForRecommendation = expandProductsWithBundleItems(products, true);
-  remainingOrderAmount = new import_decimal.default(orderTotalAmount);
-  const itemPassUsageMap = /* @__PURE__ */ new Map();
-  const applyVoucher = (voucher) => {
-    const availabilityCheck = isVoucherAvailable(
-      voucher,
-      productsForRecommendation,
-      usedVoucherCounts,
-      itemPassUsageMap
-    );
+  remainingOrderAmount = new _decimal.default(orderTotalAmount);
+  // 追踪推荐阶段每个 Wallet Pass 商品对每个订单商品行的已使用卡券次数（按行唯一键）
+  const itemPassUsageMap = new Map();
+
+  /**
+  // 分类券：未跨商品券 vs 跨商品券
+  const nonCrossProductVouchers = applicableVouchers.filter(
+    (v) => !v.config?.allowCrossProduct,
+  );
+  const crossProductVouchers = applicableVouchers.filter(
+    (v) => v.config?.allowCrossProduct,
+  );
+   // 按 tag 分组
+  const groupByType = (vouchers: any[]) => {
+    const groups = new Map<string, any[]>();
+    vouchers.forEach((v) => {
+      const tag = v.tag;
+      if (!groups.has(tag)) {
+        groups.set(tag, []);
+      }
+      groups.get(tag)!.push(v);
+    });
+    return groups;
+  };
+   // 对每组券按金额（balance）从大到小排序
+  const sortVouchersByAmount = (vouchers: Voucher[]) => {
+    return [...vouchers].sort((a, b) => getRecommendedAmount(b) - getRecommendedAmount(a));
+  };
+   */
+
+  // 处理单张券的抵扣
+  const applyVoucher = voucher => {
+    // 检查是否可用
+    const availabilityCheck = isVoucherAvailable(voucher, productsForRecommendation, usedVoucherCounts, itemPassUsageMap);
     if (!availabilityCheck.isAvailable) {
       return false;
     }
-    const { config, id, product_id } = voucher;
-    const { maxDeductionAmount = 0, allowCrossProduct = true, applicableProductLimit = 0, deductTaxAndFee = true, maxPassesPerItem = 0 } = config ?? {};
-    const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
-    const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
-    let applicableProducts = getApplicableProducts(
-      voucher,
-      productsForRecommendation
-    ).filter((p) => p[amountField].greaterThan(0));
+    const {
+      config,
+      id,
+      product_id
+    } = voucher;
+    const {
+      maxDeductionAmount = 0,
+      allowCrossProduct = true,
+      applicableProductLimit = 0,
+      deductTaxAndFee = true,
+      maxPassesPerItem = 0
+    } = config ?? {};
+
+    // 根据券的配置选择使用哪个单价字段和金额字段
+    const unitPriceField = deductTaxAndFee ? 'unitPriceWithTax' : 'unitPricePure';
+    const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
+
+    // 获取适用商品（只筛选有剩余金额的商品）
+    let applicableProducts = getApplicableProducts(voucher, productsForRecommendation).filter(p => p[amountField].greaterThan(0));
+
+    // 按 maxPassesPerItem 过滤：排除已达到单商品可用卡券上限的商品
     applicableProducts = filterByMaxPassesPerItem(applicableProducts, itemPassUsageMap, product_id, maxPassesPerItem);
-    if (applicableProducts.length === 0)
-      return false;
-    const usageAmount = typeof voucher.edit_current_amount === "number" ? voucher.edit_current_amount : getRecommendedAmount(voucher);
-    const baseAmount = import_decimal.default.min(
-      new import_decimal.default(usageAmount),
-      new import_decimal.default(maxDeductionAmount)
-    );
-    let calculatedAvailableMaxAmount = new import_decimal.default(0);
+    if (applicableProducts.length === 0) return false;
+
+    // ========== 关键修改：在应用券之前，基于当前剩余金额计算 _available_max_amount ==========
+    // 优先使用用户手动编辑的金额，否则根据 deductTaxAndFee 配置获取推荐金额
+    const usageAmount = typeof voucher.edit_current_amount === 'number' ? voucher.edit_current_amount : getRecommendedAmount(voucher);
+    const baseAmount = _decimal.default.min(new _decimal.default(usageAmount), new _decimal.default(maxDeductionAmount));
+    let calculatedAvailableMaxAmount = new _decimal.default(0);
     if (allowCrossProduct) {
+      // 跨商品券：按 quantity 限制计算可抵扣金额
       if (applicableProductLimit > 0) {
+        // 按剩余金额从高到低排序
         const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
         let remainingLimit = applicableProductLimit;
         for (const product of sortedProducts) {
-          if (remainingLimit <= 0)
-            break;
+          if (remainingLimit <= 0) break;
+          // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
           const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
           const deductQty = Math.min(currentAvailableQty, remainingLimit);
-          const deductAmount = import_decimal.default.min(
-            product[unitPriceField].times(deductQty),
-            product[amountField]
-          );
+          // 实际可抵扣金额 = min(数量 * 单价, 剩余金额)
+          const deductAmount = _decimal.default.min(product[unitPriceField].times(deductQty), product[amountField]);
           calculatedAvailableMaxAmount = calculatedAvailableMaxAmount.plus(deductAmount);
           remainingLimit -= deductQty;
         }
       } else {
-        calculatedAvailableMaxAmount = applicableProducts.reduce(
-          (sum, p) => sum.plus(p[amountField]),
-          new import_decimal.default(0)
-        );
+        // 无数量限制：所有适用商品的剩余金额总和
+        calculatedAvailableMaxAmount = applicableProducts.reduce((sum, p) => sum.plus(p[amountField]), new _decimal.default(0));
       }
     } else {
-      const maxProduct = applicableProducts.reduce(
-        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
-      );
+      // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
+      const maxProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
+      // maxPassesPerItem 限制每张券最多抵扣的单位数
       if (maxPassesPerItem > 0) {
-        calculatedAvailableMaxAmount = import_decimal.default.min(
-          maxProduct[unitPriceField].times(maxPassesPerItem),
-          maxProduct[amountField]
-        );
+        calculatedAvailableMaxAmount = _decimal.default.min(maxProduct[unitPriceField].times(maxPassesPerItem), maxProduct[amountField]);
       } else {
         calculatedAvailableMaxAmount = maxProduct[amountField];
       }
     }
-    const availableMaxAmount = import_decimal.default.min(
-      baseAmount,
-      calculatedAvailableMaxAmount,
-      remainingOrderAmount
-    );
-    const maxDeduction = import_decimal.default.min(
-      new import_decimal.default(usageAmount),
-      new import_decimal.default(maxDeductionAmount),
-      remainingOrderAmount
-    );
+
+    // 取最小值：min(recommended_usage_amount, maxDeductionAmount, 适用商品金额, 订单剩余金额)
+    const availableMaxAmount = _decimal.default.min(baseAmount, calculatedAvailableMaxAmount, remainingOrderAmount);
+    // ======================================================================================
+
+    // 计算本次抵扣金额（使用同样的 usageAmount）
+    const maxDeduction = _decimal.default.min(new _decimal.default(usageAmount), new _decimal.default(maxDeductionAmount), remainingOrderAmount);
     let deductionLeft = maxDeduction;
     const deductionDetails = [];
     if (allowCrossProduct) {
-      const sortedProducts = [...applicableProducts].sort(
-        (a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1
-      );
+      // 跨商品券：按剩余金额从高到低抵扣，受 applicableProductLimit 限制
+      const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
       let remainingLimit = applicableProductLimit > 0 ? applicableProductLimit : Infinity;
       for (const product of sortedProducts) {
-        if (deductionLeft.lessThanOrEqualTo(0) || remainingLimit <= 0)
-          break;
+        if (deductionLeft.lessThanOrEqualTo(0) || remainingLimit <= 0) break;
+
+        // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
         const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
         const availableQty = Math.min(currentAvailableQty, remainingLimit);
-        const maxDeductForProduct = import_decimal.default.min(
-          product[unitPriceField].times(availableQty),
-          product[amountField]
-        );
-        const actualDeductAmount = import_decimal.default.min(deductionLeft, maxDeductForProduct);
+
+        // 计算本商品最大可抵扣金额 = min(数量 * 单价, 剩余金额)
+        const maxDeductForProduct = _decimal.default.min(product[unitPriceField].times(availableQty), product[amountField]);
+        const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
+
+        // 计算实际抵扣的数量（用于记录和配额计算）
         const actualDeductQty = Math.ceil(actualDeductAmount.dividedBy(product[unitPriceField]).toNumber());
+
+        // 只更新商品的剩余金额，不更新 remainingQuantity
         product[amountField] = product[amountField].minus(actualDeductAmount);
         deductionLeft = deductionLeft.minus(actualDeductAmount);
         remainingLimit -= actualDeductQty;
@@ -398,23 +503,24 @@ function processVouchers(applicableVouchers, orderTotalAmount, products) {
           orderLineQuantity: getExpandedOrderLineQuantity(product),
           deductAmount: actualDeductAmount.toNumber(),
           // 转换为数字
-          deductQuantity: actualDeductQty
-          // 抵扣涉及的数量（用于记录）
+          deductQuantity: actualDeductQty // 抵扣涉及的数量（用于记录）
         });
       }
     } else {
-      const targetProduct = applicableProducts.reduce(
-        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
-      );
+      // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
+      const targetProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
+
+      // maxPassesPerItem 限制每张券最多抵扣的单位数
       let maxDeductForProduct = targetProduct[amountField];
       if (maxPassesPerItem > 0) {
-        maxDeductForProduct = import_decimal.default.min(
-          targetProduct[unitPriceField].times(maxPassesPerItem),
-          targetProduct[amountField]
-        );
+        maxDeductForProduct = _decimal.default.min(targetProduct[unitPriceField].times(maxPassesPerItem), targetProduct[amountField]);
       }
-      const actualDeductAmount = import_decimal.default.min(deductionLeft, maxDeductForProduct);
+      const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
+
+      // 计算实际抵扣的数量
       const actualDeductQty = Math.ceil(actualDeductAmount.dividedBy(targetProduct[unitPriceField]).toNumber());
+
+      // 只更新商品的剩余金额，不更新 remainingQuantity
       targetProduct[amountField] = targetProduct[amountField].minus(actualDeductAmount);
       deductionLeft = deductionLeft.minus(actualDeductAmount);
       deductionDetails.push({
@@ -429,9 +535,14 @@ function processVouchers(applicableVouchers, orderTotalAmount, products) {
     }
     const totalDeducted = maxDeduction.minus(deductionLeft);
     if (totalDeducted.greaterThan(0)) {
+      // 更新订单剩余金额
       remainingOrderAmount = remainingOrderAmount.minus(totalDeducted);
+
+      // 更新券使用次数（按 product_id 统计）
       usedVoucherCounts.set(product_id, (usedVoucherCounts.get(product_id) || 0) + 1);
       applyMaxPassUsageIncrements(itemPassUsageMap, product_id, maxPassesPerItem, deductionDetails);
+
+      // 添加到推荐列表（包含基于当前剩余金额计算的 available_max_amount）
       recommendedVouchers.push({
         ...voucher,
         actualDeduction: totalDeducted.toNumber(),
@@ -445,17 +556,47 @@ function processVouchers(applicableVouchers, orderTotalAmount, products) {
     }
     return false;
   };
-  applicableVouchers.forEach((voucher) => {
+
+  /**
+  // 第一轮：处理未跨商品券
+  const nonCrossGroups = groupByType(nonCrossProductVouchers);
+  nonCrossGroups.forEach((vouchersInGroup) => {
+    const sortedVouchers = sortVouchersByAmount(vouchersInGroup);
+    sortedVouchers.forEach((voucher) => {
+      applyVoucher(voucher);
+    });
+  });
+   // 第二轮：处理跨商品券
+  const crossGroups = groupByType(crossProductVouchers);
+  crossGroups.forEach((vouchersInGroup) => {
+    const sortedVouchers = sortVouchersByAmount(vouchersInGroup);
+    sortedVouchers.forEach((voucher) => {
+      applyVoucher(voucher);
+    });
+  });
+  */
+
+  // 直接按 applicableVouchers 的顺序处理所有券
+  applicableVouchers.forEach(voucher => {
     applyVoucher(voucher);
   });
-  const recommendedMap = /* @__PURE__ */ new Map();
-  recommendedVouchers.forEach((v) => {
+
+  // recommendedVouchers 已经包含了基于应用时计算的 _available_max_amount 和 _unified_available_status
+
+  // ========== 第三步：构建 all 数组，以 recommended 为基础 ==========
+  // 创建 recommended 券的 Map，以 id 为 key
+  const recommendedMap = new Map();
+  recommendedVouchers.forEach(v => {
     recommendedMap.set(v.id, v);
   });
-  const allWithEnhancedData = allVouchersWithStatus.map((voucher) => {
+
+  // 遍历所有券，如果在 recommended 中则使用增强数据，否则使用基础数据
+  const allWithEnhancedData = allVouchersWithStatus.map(voucher => {
     if (recommendedMap.has(voucher.id)) {
+      // 使用 recommended 中的增强数据
       return recommendedMap.get(voucher.id);
     } else {
+      // 不在 recommended 中的券，补充基础字段
       return {
         ...voucher,
         actualDeduction: 0,
@@ -469,28 +610,41 @@ function processVouchers(applicableVouchers, orderTotalAmount, products) {
     transformList: allWithEnhancedData
   };
 }
+
+/**
+ * 重新计算优惠券状态（基于已选券的增量计算）
+ * @param allVouchers 所有原始券列表
+ * @param selectedVouchers 已选中的券列表（按选中顺序）
+ * @param orderTotalAmount 订单总金额
+ * @param products 订单商品列表
+ * @returns 返回更新后的所有券列表和已选券的详细抵扣信息
+ */
 function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, products) {
+  // 深拷贝并拆分商品列表（包含主商品和原价子商品，同时维护含税和不含税两个金额池），用于计算
   const productsForCalc = expandProductsWithBundleItems(products, true);
-  let remainingOrderAmount = new import_decimal.default(orderTotalAmount);
+  let remainingOrderAmount = new _decimal.default(orderTotalAmount);
   const selectedWithDetails = [];
-  const usedVoucherCounts = /* @__PURE__ */ new Map();
-  const itemPassUsageMap = /* @__PURE__ */ new Map();
+  const usedVoucherCounts = new Map();
+
+  // 追踪每个 Wallet Pass 商品对每个订单商品行的已使用卡券次数（按行唯一键）
+  const itemPassUsageMap = new Map();
   const getItemPassUsageRecalc = (walletPassProductId, lineKey) => {
-    var _a;
-    return ((_a = itemPassUsageMap.get(walletPassProductId)) == null ? void 0 : _a.get(lineKey)) || 0;
+    return itemPassUsageMap.get(walletPassProductId)?.get(lineKey) || 0;
   };
-  const filterByMaxPassesPerItemRecalc = (products2, walletPassProductId, maxPassesPerItem) => {
-    if (maxPassesPerItem <= 0)
-      return products2;
-    return products2.filter((p) => {
+  const filterByMaxPassesPerItemRecalc = (products, walletPassProductId, maxPassesPerItem) => {
+    if (maxPassesPerItem <= 0) return products;
+    return products.filter(p => {
       const lineKey = p._walletPassLineKey;
-      if (!lineKey)
-        return true;
+      if (!lineKey) return true;
       return getItemPassUsageRecalc(walletPassProductId, lineKey) < getMaxPassSlotsForExpandedLine(maxPassesPerItem, p);
     });
   };
-  selectedVouchers.forEach((selectedVoucher) => {
-    const { product_id } = selectedVoucher;
+
+  // 第一步：按顺序应用已选中的券，计算实际抵扣
+  selectedVouchers.forEach(selectedVoucher => {
+    const {
+      product_id
+    } = selectedVoucher;
     const config = getWalletPassCalculationConfig(selectedVoucher);
     const {
       maxDeductionAmount,
@@ -509,18 +663,22 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
         deductionDetails: [],
         _available_max_amount: 0,
         _unified_available_status: 0,
-        reasonCode: "usage_limit_reached"
+        reasonCode: 'usage_limit_reached'
       });
       return;
     }
-    const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
-    const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
-    let applicableProducts = getApplicableProducts(
-      selectedVoucher,
-      productsForCalc
-    ).filter((p) => p[amountField].greaterThan(0));
+
+    // 根据券的配置选择使用哪个单价字段和金额字段
+    const unitPriceField = deductTaxAndFee ? 'unitPriceWithTax' : 'unitPricePure';
+    const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
+
+    // 获取适用商品（只筛选有剩余金额的商品）
+    let applicableProducts = getApplicableProducts(selectedVoucher, productsForCalc).filter(p => p[amountField].greaterThan(0));
+
+    // 按 maxPassesPerItem 过滤：排除已达到该行券次上限的展开行
     applicableProducts = filterByMaxPassesPerItemRecalc(applicableProducts, selectedVoucher.product_id, maxPassesPerItem);
     if (applicableProducts.length === 0) {
+      // 无适用商品，跳过
       selectedWithDetails.push({
         ...selectedVoucher,
         config,
@@ -528,34 +686,38 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
         deductionDetails: [],
         _available_max_amount: 0,
         _unified_available_status: 0,
-        reasonCode: "not_meet_the_required_conditions"
+        reasonCode: 'not_meet_the_required_conditions'
       });
       return;
     }
-    const usageAmount = typeof selectedVoucher.edit_current_amount === "number" ? selectedVoucher.edit_current_amount : selectedVoucher._available_max_amount ?? getRecommendedAmount(selectedVoucher);
-    const maxDeduction = import_decimal.default.min(
-      new import_decimal.default(usageAmount),
-      new import_decimal.default(maxDeductionAmount),
-      remainingOrderAmount
-    );
+
+    // 计算本次抵扣金额：
+    // - 用户手动编辑时以编辑金额为准；
+    // - 自动推荐/重算时沿用上一轮基于剩余待付金额算出的 _available_max_amount，
+    //   避免 recalculateVouchers 又回退到后端单券 recommended_usage_amount 造成超付。
+    const usageAmount = typeof selectedVoucher.edit_current_amount === 'number' ? selectedVoucher.edit_current_amount : selectedVoucher._available_max_amount ?? getRecommendedAmount(selectedVoucher);
+    const maxDeduction = _decimal.default.min(new _decimal.default(usageAmount), new _decimal.default(maxDeductionAmount), remainingOrderAmount);
     let deductionLeft = maxDeduction;
     const deductionDetails = [];
     if (allowCrossProduct) {
-      const sortedProducts = [...applicableProducts].sort(
-        (a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1
-      );
+      // 跨商品券：按剩余金额从高到低抵扣，受 applicableProductLimit 限制
+      const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
       let remainingLimit = applicableProductLimit > 0 ? applicableProductLimit : Infinity;
       for (const product of sortedProducts) {
-        if (deductionLeft.lessThanOrEqualTo(0) || remainingLimit <= 0)
-          break;
+        if (deductionLeft.lessThanOrEqualTo(0) || remainingLimit <= 0) break;
+
+        // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
         const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
         const availableQty = Math.min(currentAvailableQty, remainingLimit);
-        const maxDeductForProduct = import_decimal.default.min(
-          product[unitPriceField].times(availableQty),
-          product[amountField]
-        );
-        const actualDeductAmount = import_decimal.default.min(deductionLeft, maxDeductForProduct);
+
+        // 计算本商品最大可抵扣金额 = min(数量 * 单价, 剩余金额)
+        const maxDeductForProduct = _decimal.default.min(product[unitPriceField].times(availableQty), product[amountField]);
+        const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
+
+        // 计算实际抵扣的数量（用于记录和配额计算）
         const actualDeductQty = Math.ceil(actualDeductAmount.dividedBy(product[unitPriceField]).toNumber());
+
+        // 只更新商品的剩余金额，不更新 remainingQuantity
         product[amountField] = product[amountField].minus(actualDeductAmount);
         deductionLeft = deductionLeft.minus(actualDeductAmount);
         remainingLimit -= actualDeductQty;
@@ -567,23 +729,24 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
           orderLineQuantity: getExpandedOrderLineQuantity(product),
           deductAmount: actualDeductAmount.toNumber(),
           // 转换为数字
-          deductQuantity: actualDeductQty
-          // 抵扣涉及的数量（用于记录）
+          deductQuantity: actualDeductQty // 抵扣涉及的数量（用于记录）
         });
       }
     } else {
-      const targetProduct = applicableProducts.reduce(
-        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
-      );
+      // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
+      const targetProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
+
+      // maxPassesPerItem 限制每张券最多抵扣的单位数
       let maxDeductForProduct = targetProduct[amountField];
       if (maxPassesPerItem > 0) {
-        maxDeductForProduct = import_decimal.default.min(
-          targetProduct[unitPriceField].times(maxPassesPerItem),
-          targetProduct[amountField]
-        );
+        maxDeductForProduct = _decimal.default.min(targetProduct[unitPriceField].times(maxPassesPerItem), targetProduct[amountField]);
       }
-      const actualDeductAmount = import_decimal.default.min(deductionLeft, maxDeductForProduct);
+      const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
+
+      // 计算实际抵扣的数量
       const actualDeductQty = Math.ceil(actualDeductAmount.dividedBy(targetProduct[unitPriceField]).toNumber());
+
+      // 只更新商品的剩余金额，不更新 remainingQuantity
       targetProduct[amountField] = targetProduct[amountField].minus(actualDeductAmount);
       deductionLeft = deductionLeft.minus(actualDeductAmount);
       deductionDetails.push({
@@ -597,6 +760,8 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       });
     }
     const totalDeducted = maxDeduction.minus(deductionLeft);
+
+    // 更新订单剩余金额
     remainingOrderAmount = remainingOrderAmount.minus(totalDeducted);
     applyMaxPassUsageIncrements(itemPassUsageMap, selectedVoucher.product_id, maxPassesPerItem, deductionDetails);
     selectedWithDetails.push({
@@ -613,15 +778,20 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       usedVoucherCounts.set(product_id, usedCount + 1);
     }
   });
-  const selectedIds = new Set(selectedVouchers.map((v) => v.id));
-  const allWithUpdatedStatus = allVouchers.map((voucher) => {
+
+  // 第二步：为所有券重新计算 _available_max_amount 和 _unified_available_status
+  const selectedIds = new Set(selectedVouchers.map(v => v.id));
+  const allWithUpdatedStatus = allVouchers.map(voucher => {
+    // 如果是已选中的券，使用详细计算结果
     if (selectedIds.has(voucher.id)) {
-      const selectedDetail = selectedWithDetails.find(
-        (v) => v.id === voucher.id
-      );
+      const selectedDetail = selectedWithDetails.find(v => v.id === voucher.id);
       return selectedDetail || voucher;
     }
-    const { product_id } = voucher;
+
+    // 未选中的券，重新计算其可用状态
+    const {
+      product_id
+    } = voucher;
     const config = getWalletPassCalculationConfig(voucher);
     const {
       maxDeductionAmount,
@@ -630,83 +800,78 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       deductTaxAndFee,
       maxPassesPerItem
     } = config;
-    const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
-    const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
+
+    // 根据券的配置选择使用哪个单价字段和金额字段
+    const unitPriceField = deductTaxAndFee ? 'unitPriceWithTax' : 'unitPricePure';
+    const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
+
+    // 根据 deductTaxAndFee 配置获取推荐金额
     const recommendedAmount = getRecommendedAmount(voucher);
+
+    // 检查基本可用性
     let isAvailable = true;
-    let calculatedMaxAmount = new import_decimal.default(0);
+    let calculatedMaxAmount = new _decimal.default(0);
     let reasonCode;
     if (recommendedAmount <= 0) {
       isAvailable = false;
-      reasonCode = "not_meet_the_required_conditions";
+      reasonCode = 'not_meet_the_required_conditions';
     } else if (remainingOrderAmount.lessThanOrEqualTo(0)) {
       isAvailable = false;
-      reasonCode = "exceeds_the_maximum_deduction_limit";
+      reasonCode = 'exceeds_the_maximum_deduction_limit';
     } else {
+      // 检查 maxUsagePerOrder（按 product_id 统计），0 表示不限制
       if (config.maxUsagePerOrder > 0) {
         const usedCount = usedVoucherCounts.get(product_id) || 0;
         if (usedCount >= config.maxUsagePerOrder) {
           isAvailable = false;
-          reasonCode = "usage_limit_reached";
+          reasonCode = 'usage_limit_reached';
         }
       }
       if (isAvailable) {
-        let applicableProducts = getApplicableProducts(
-          voucher,
-          productsForCalc
-        ).filter((p) => p[amountField].greaterThan(0));
+        // 获取适用商品（只筛选有剩余金额的商品）
+        let applicableProducts = getApplicableProducts(voucher, productsForCalc).filter(p => p[amountField].greaterThan(0));
+
+        // 按 maxPassesPerItem 过滤：排除已达到单商品可用卡券上限的商品
         applicableProducts = filterByMaxPassesPerItemRecalc(applicableProducts, product_id, maxPassesPerItem);
         if (applicableProducts.length === 0) {
           isAvailable = false;
-          reasonCode = "not_meet_the_required_conditions";
+          reasonCode = 'not_meet_the_required_conditions';
         } else {
-          const baseAmount = import_decimal.default.min(
-            new import_decimal.default(recommendedAmount),
-            new import_decimal.default(maxDeductionAmount)
-          );
+          // 计算 _available_max_amount
+          const baseAmount = _decimal.default.min(new _decimal.default(recommendedAmount), new _decimal.default(maxDeductionAmount));
           if (allowCrossProduct) {
             if (applicableProductLimit > 0) {
+              // 按剩余金额从高到低排序，按动态计算的可抵扣数量累计直到达到 limit
               const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
               let remainingLimit = applicableProductLimit;
               for (const product of sortedProducts) {
-                if (remainingLimit <= 0)
-                  break;
+                if (remainingLimit <= 0) break;
+                // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
                 const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
                 const deductQty = Math.min(currentAvailableQty, remainingLimit);
-                const deductAmount = import_decimal.default.min(
-                  product[unitPriceField].times(deductQty),
-                  product[amountField]
-                );
+                // 实际可抵扣金额 = min(数量 * 单价, 剩余金额)
+                const deductAmount = _decimal.default.min(product[unitPriceField].times(deductQty), product[amountField]);
                 calculatedMaxAmount = calculatedMaxAmount.plus(deductAmount);
                 remainingLimit -= deductQty;
               }
             } else {
-              calculatedMaxAmount = applicableProducts.reduce(
-                (sum, p) => sum.plus(p[amountField]),
-                new import_decimal.default(0)
-              );
+              // 无数量限制：所有适用商品的剩余金额总和
+              calculatedMaxAmount = applicableProducts.reduce((sum, p) => sum.plus(p[amountField]), new _decimal.default(0));
             }
           } else {
-            const maxProduct = applicableProducts.reduce(
-              (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
-            );
+            // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
+            const maxProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
+            // maxPassesPerItem 限制每张券最多抵扣的单位数
             if (maxPassesPerItem > 0) {
-              calculatedMaxAmount = import_decimal.default.min(
-                maxProduct[unitPriceField].times(maxPassesPerItem),
-                maxProduct[amountField]
-              );
+              calculatedMaxAmount = _decimal.default.min(maxProduct[unitPriceField].times(maxPassesPerItem), maxProduct[amountField]);
             } else {
               calculatedMaxAmount = maxProduct[amountField];
             }
           }
-          calculatedMaxAmount = import_decimal.default.min(
-            baseAmount,
-            calculatedMaxAmount,
-            remainingOrderAmount
-          );
+          calculatedMaxAmount = _decimal.default.min(baseAmount, calculatedMaxAmount, remainingOrderAmount);
           if (calculatedMaxAmount.lessThanOrEqualTo(0)) {
             isAvailable = false;
-            reasonCode = "exceeds_the_maximum_deduction_limit";
+            reasonCode = 'exceeds_the_maximum_deduction_limit';
           }
         }
       }
@@ -717,7 +882,9 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       _available_max_amount: calculatedMaxAmount.toNumber(),
       // 转换为数字
       _unified_available_status: isAvailable ? 1 : 0,
-      ...reasonCode && { reasonCode }
+      ...(reasonCode && {
+        reasonCode
+      })
     };
   });
   return {
@@ -725,47 +892,87 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
     selectedWithDetails
   };
 }
-var getMainProductPrice = (product, isDeductTaxAndFee) => {
-  var _a, _b, _c, _d, _e;
-  let mainProductPrice = new import_decimal.default((product == null ? void 0 : product.main_product_selling_price) || ((_a = product.metadata) == null ? void 0 : _a.main_product_selling_price) || 0);
-  for (let bundleItem of (product == null ? void 0 : product.product_bundle) || []) {
+
+/**
+ * 获取主商品价格（单价，不含舍入余数）
+ * @param product 商品
+ * @param isDeductTaxAndFee 是否抵扣税费与附加费
+ * @returns 商品单价
+ */
+const getMainProductPrice = (product, isDeductTaxAndFee) => {
+  let mainProductPrice = new _decimal.default(product?.main_product_selling_price || product.metadata?.main_product_selling_price || 0);
+  for (let bundleItem of product?.product_bundle || []) {
+    // 子商品是加价或减价才需要计算
     if (getBundleItemIsMarkupOrDiscountPrice(bundleItem)) {
-      const bundleItemPrice = new import_decimal.default(bundleItem.bundle_selling_price ?? 0);
+      // 子商品价格
+      const bundleItemPrice = new _decimal.default(bundleItem.bundle_selling_price ?? 0);
       mainProductPrice = mainProductPrice.add(bundleItemPrice.times(bundleItem.num));
     }
   }
-  let taxFee = new import_decimal.default((product == null ? void 0 : product.tax_fee) || ((_b = product == null ? void 0 : product.metadata) == null ? void 0 : _b.main_product_attached_bundle_tax_fee) || 0).add(((_c = product == null ? void 0 : product.metadata) == null ? void 0 : _c.tax_fee_rounding_remainder) || 0);
+  let taxFee = new _decimal.default(product?.tax_fee || product?.metadata?.main_product_attached_bundle_tax_fee || 0).add(product?.metadata?.tax_fee_rounding_remainder || 0);
   if (product.is_price_include_tax === 1) {
-    taxFee = new import_decimal.default(0);
+    taxFee = new _decimal.default(0);
   }
-  const surchargeFee = new import_decimal.default(((_d = product == null ? void 0 : product.metadata) == null ? void 0 : _d.main_product_attached_bundle_surcharge_fee) || 0).add(((_e = product == null ? void 0 : product.metadata) == null ? void 0 : _e.surcharge_rounding_remainder) || 0);
+
+  // 税费
+  // 附加费
+  const surchargeFee = new _decimal.default(product?.metadata?.main_product_attached_bundle_surcharge_fee || 0).add(product?.metadata?.surcharge_rounding_remainder || 0);
+
+  // 税费附加费总额
   const taxAndFeeTotal = taxFee.add(surchargeFee);
+
+  // 如果需要抵扣税费与附加费，则加上税费附加费总额
   if (isDeductTaxAndFee) {
     mainProductPrice = mainProductPrice.add(taxAndFeeTotal);
   }
   return mainProductPrice.toNumber();
 };
-var getBundleItemPrice = (bundleItem, parentQuantity, isDeductTaxAndFee) => {
-  var _a;
+
+/**
+ * 获取套餐子商品价格（不含舍入余数）
+ * @param bundleItem 套餐子商品
+ * @param parentQuantity 父商品数量
+ * @param isDeductTaxAndFee 是否抵扣税费与附加费
+ * @returns 子商品总价格（不含舍入余数）
+ */
+exports.getMainProductPrice = getMainProductPrice;
+const getBundleItemPrice = (bundleItem, parentQuantity, isDeductTaxAndFee) => {
+  // 子商品基础价格 = bundle_selling_price * num * 主商品数量
   const totalQuantity = bundleItem.num * parentQuantity;
-  let bundleItemPrice = new import_decimal.default(bundleItem.bundle_selling_price ?? 0).times(totalQuantity);
+  let bundleItemPrice = new _decimal.default(bundleItem.bundle_selling_price ?? 0).times(totalQuantity);
+
+  // 根据 deductTaxAndFee 配置决定是否加上税费和附加费
   if (isDeductTaxAndFee) {
-    let taxFee = new import_decimal.default(bundleItem.tax_fee ?? 0).times(totalQuantity);
+    // 税费
+    let taxFee = new _decimal.default(bundleItem.tax_fee ?? 0).times(totalQuantity);
     if (bundleItem.is_price_include_tax === 1) {
-      taxFee = new import_decimal.default(0);
+      taxFee = new _decimal.default(0);
     }
-    const surchargeFee = new import_decimal.default(((_a = bundleItem.metadata) == null ? void 0 : _a.surcharge_fee) ?? 0).times(totalQuantity);
+    // 附加费
+    const surchargeFee = new _decimal.default(bundleItem.metadata?.surcharge_fee ?? 0).times(totalQuantity);
     bundleItemPrice = bundleItemPrice.add(taxFee).add(surchargeFee);
   }
   return bundleItemPrice.toNumber();
 };
-var expandProductsWithBundleItems = (products, deductTaxAndFee) => {
+
+/**
+ * 将商品数据拆分，包含主商品和原价子商品
+ * @param products 原始商品列表
+ * @param deductTaxAndFee 是否抵扣税费与附加费（已废弃，保留参数以兼容旧代码）
+ * @returns 拆分后的商品数据（包含主商品和子商品，同时维护含税和不含税两个金额池，以及单价和剩余数量）
+ */
+exports.getBundleItemPrice = getBundleItemPrice;
+const expandProductsWithBundleItems = (products, deductTaxAndFee) => {
   const expandedProducts = [];
   products.forEach((product, indexInOrder) => {
     const productQuantity = getProductQuantity(product);
     const parentLineKey = resolveWalletPassLineKey(product, indexInOrder);
+
+    // 计算主商品单价（含税和不含税）
     const unitPriceWithTax = getMainProductPrice(product, true);
     const unitPricePure = getMainProductPrice(product, false);
+
+    // 1. 添加主商品（同时计算含税和不含税两个金额，以及单价和剩余数量）
     expandedProducts.push({
       ...product,
       is_bundle_item: false,
@@ -773,22 +980,27 @@ var expandProductsWithBundleItems = (products, deductTaxAndFee) => {
       _walletPassLineKey: parentLineKey,
       _orderLineQuantity: productQuantity,
       // 单价（用于按 quantity 计算抵扣）
-      unitPriceWithTax: new import_decimal.default(unitPriceWithTax),
-      unitPricePure: new import_decimal.default(unitPricePure),
+      unitPriceWithTax: new _decimal.default(unitPriceWithTax),
+      unitPricePure: new _decimal.default(unitPricePure),
       // 剩余可抵扣数量
       remainingQuantity: productQuantity,
       // 含税费的剩余金额
-      remainingAmountWithTax: new import_decimal.default(unitPriceWithTax).times(productQuantity),
+      remainingAmountWithTax: new _decimal.default(unitPriceWithTax).times(productQuantity),
       // 纯商品金额（不含税费）
-      remainingAmountPure: new import_decimal.default(unitPricePure).times(productQuantity)
+      remainingAmountPure: new _decimal.default(unitPricePure).times(productQuantity)
     });
+
+    // 2. 添加原价子商品（作为独立商品项）
     if (product.product_bundle && product.product_bundle.length > 0) {
-      product.product_bundle.forEach((bundleItem) => {
+      product.product_bundle.forEach(bundleItem => {
         if (getBundleItemIsOriginalPrice(bundleItem)) {
           const bundleQuantity = bundleItem.num * productQuantity;
           const bundleLineKey = `${parentLineKey}#bundle:${bundleItem.bundle_id}:${bundleItem.bundle_product_id}`;
-          const bundleUnitPriceWithTax = new import_decimal.default(getBundleItemPrice(bundleItem, 1, true)).dividedBy(bundleItem.num);
-          const bundleUnitPricePure = new import_decimal.default(getBundleItemPrice(bundleItem, 1, false)).dividedBy(bundleItem.num);
+          // 计算子商品单价（注意：getBundleItemPrice 返回的是总价，需要除以数量得到单价）
+          const bundleUnitPriceWithTax = new _decimal.default(getBundleItemPrice(bundleItem, 1, true)).dividedBy(bundleItem.num);
+          const bundleUnitPricePure = new _decimal.default(getBundleItemPrice(bundleItem, 1, false)).dividedBy(bundleItem.num);
+
+          // 原价子商品作为独立商品
           expandedProducts.push({
             ...bundleItem,
             product_id: bundleItem.bundle_product_id,
@@ -805,9 +1017,9 @@ var expandProductsWithBundleItems = (products, deductTaxAndFee) => {
             // 剩余可抵扣数量
             remainingQuantity: bundleQuantity,
             // 含税费的剩余金额
-            remainingAmountWithTax: new import_decimal.default(getBundleItemPrice(bundleItem, productQuantity, true)),
+            remainingAmountWithTax: new _decimal.default(getBundleItemPrice(bundleItem, productQuantity, true)),
             // 纯商品金额（不含税费）
-            remainingAmountPure: new import_decimal.default(getBundleItemPrice(bundleItem, productQuantity, false))
+            remainingAmountPure: new _decimal.default(getBundleItemPrice(bundleItem, productQuantity, false))
           });
         }
       });
@@ -815,29 +1027,27 @@ var expandProductsWithBundleItems = (products, deductTaxAndFee) => {
   });
   return expandedProducts;
 };
-var getBundleItemIsOriginalPrice = (item) => {
-  return (item == null ? void 0 : item.price_type) === "markup" && (item == null ? void 0 : item.price_type_ext) === "product_price";
+
+// bundle商品是否是原价
+const getBundleItemIsOriginalPrice = item => {
+  return item?.price_type === 'markup' && item?.price_type_ext === 'product_price';
 };
-var getBundleItemIsMarkupPrice = (item) => {
-  return (item == null ? void 0 : item.price_type) === "markup" && ((item == null ? void 0 : item.price_type_ext) === "" || !(item == null ? void 0 : item.price_type_ext));
+
+// bundle商品是否是加价
+exports.getBundleItemIsOriginalPrice = getBundleItemIsOriginalPrice;
+const getBundleItemIsMarkupPrice = item => {
+  return item?.price_type === 'markup' && (item?.price_type_ext === '' || !item?.price_type_ext);
 };
-var getBundleItemIsDiscountPrice = (item) => {
-  return (item == null ? void 0 : item.price_type) === "markdown" && ((item == null ? void 0 : item.price_type_ext) === "" || !(item == null ? void 0 : item.price_type_ext));
+
+// bundle商品是否是减价
+exports.getBundleItemIsMarkupPrice = getBundleItemIsMarkupPrice;
+const getBundleItemIsDiscountPrice = item => {
+  return item?.price_type === 'markdown' && (item?.price_type_ext === '' || !item?.price_type_ext);
 };
-var getBundleItemIsMarkupOrDiscountPrice = (item) => {
+
+// bundle商品是否是加价或减价
+exports.getBundleItemIsDiscountPrice = getBundleItemIsDiscountPrice;
+const getBundleItemIsMarkupOrDiscountPrice = item => {
   return getBundleItemIsMarkupPrice(item) || getBundleItemIsDiscountPrice(item);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getApplicableProductIds,
-  getBundleItemIsDiscountPrice,
-  getBundleItemIsMarkupOrDiscountPrice,
-  getBundleItemIsMarkupPrice,
-  getBundleItemIsOriginalPrice,
-  getBundleItemPrice,
-  getMainProductPrice,
-  getProductQuantity,
-  processVouchers,
-  recalculateVouchers,
-  resolveWalletPassLineKey
-});
+exports.getBundleItemIsMarkupOrDiscountPrice = getBundleItemIsMarkupOrDiscountPrice;