@pisell/pisellos 0.0.569 → 0.10.2

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

@@ -1,471 +1,372 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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
 });
-exports.getTaxAndFeeRoundingRemainder = exports.getProductQuantity = exports.getProductDiscountDifference = exports.getMainProductPrice = exports.getBundleItemTaxAndFeeRoundingRemainder = exports.getBundleItemPrice = exports.getBundleItemIsOriginalPrice = exports.getBundleItemIsMarkupPrice = exports.getBundleItemIsMarkupOrDiscountPrice = exports.getBundleItemIsDiscountPrice = exports.getBundleItemDiscountDifference = 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 getProductQuantity = product => {
+module.exports = __toCommonJS(utils_exports);
+var import_decimal = __toESM(require("decimal.js"));
+var getProductQuantity = (product) => {
   return product.quantity || product.product_quantity || 1;
 };
-
-/**
- * 订单商品行唯一键，用于 maxPassesPerItem 按行、按件配额（同 SPU 不同规格视为不同行）。
- */
-exports.getProductQuantity = getProductQuantity;
 function resolveWalletPassLineKey(product, indexInOrder) {
-  const m = product?.metadata || {};
+  const m = (product == null ? void 0 : 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?.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) {
+  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) {
     return String(product.product_unique_string);
   }
   return `order_line_${indexInOrder}`;
 }
 function getExpandedOrderLineQuantity(p) {
-  if (p?._orderLineQuantity != null && p._orderLineQuantity > 0) return p._orderLineQuantity;
+  if ((p == null ? void 0 : 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 => {
+  deductionDetails.forEach((detail) => {
+    var _a;
     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 = 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 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 inner = usageMap.get(walletPassProductId);
     inner.set(lineKey, cur + inc);
   });
 }
-
-// 辅助函数：根据 deductTaxAndFee 配置获取推荐使用金额
-const getRecommendedAmount = voucher => {
-  const {
-    config,
-    recommended_usage_amount,
-    recommended_pure_product_usage_amount
-  } = voucher;
-  const deductTaxAndFee = config?.deductTaxAndFee ?? true; // 默认开启抵扣税费
-
-  // 如果开启抵扣税费，使用 recommended_usage_amount（包含税费）
-  // 如果关闭抵扣税费，使用 recommended_pure_product_usage_amount（仅商品金额）
+var getRecommendedAmount = (voucher) => {
+  console.log("voucher312", voucher);
+  const { config, recommended_usage_amount, recommended_pure_product_usage_amount } = voucher;
+  const deductTaxAndFee = (config == null ? void 0 : config.deductTaxAndFee) ?? true;
   return deductTaxAndFee ? recommended_usage_amount : recommended_pure_product_usage_amount ?? recommended_usage_amount;
 };
-
-// 辅助函数：获取适用商品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') {
+var getApplicableProductIds = (voucher) => {
+  const { available_product_type, available_product_ids } = voucher;
+  const productType = available_product_type || "product_all";
+  if (productType === "product_all") {
     return null;
   }
-
-  // product_collection 或 products 时，返回指定的商品ID列表
-  if (productType === 'product_collection' || productType === 'products') {
+  if (productType === "product_collection" || productType === "products") {
     return available_product_ids || [];
   }
-
-  // 其他情况默认返回空数组（不适用任何商品）
   return [];
 };
-
-// 辅助函数：计算适用商品的总金额（基于剩余金额）
-exports.getApplicableProductIds = getApplicableProductIds;
-const getApplicableProductsAmount = (voucher, productsData) => {
+var getApplicableProductsAmount = (voucher, productsData) => {
   const applicableProductIds = getApplicableProductIds(voucher);
-  const {
-    config
-  } = voucher;
-  const deductTaxAndFee = config?.deductTaxAndFee ?? true;
-
-  // 根据券的配置选择使用哪个金额字段
-  const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
-
-  // 如果为 null，适用于所有商品
+  const { config } = voucher;
+  const deductTaxAndFee = (config == null ? void 0 : config.deductTaxAndFee) ?? true;
+  const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
   if (applicableProductIds === null) {
-    return productsData.filter(p => p[amountField].greaterThan(0)).reduce((sum, p) => sum.plus(p[amountField]), new _decimal.default(0));
+    return productsData.filter((p) => p[amountField].greaterThan(0)).reduce((sum, p) => sum.plus(p[amountField]), new import_decimal.default(0));
   }
-
-  // 如果为空数组，不适用任何商品
   if (applicableProductIds.length === 0) {
-    return new _decimal.default(0);
+    return 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));
+  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));
 };
-
-// 辅助函数：获取适用的商品列表
-const getApplicableProducts = (voucher, productsData) => {
+var 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 配置选择从哪个金额池扣除
+  console.log(products, "products123");
   const productsCopy = expandProductsWithBundleItems(products, true);
-  let remainingOrderAmount = new _decimal.default(orderTotalAmount); // 订单剩余应付金额
-
-  // ========== 辅助工具：maxPassesPerItem（按订单行 + 件数）追踪 ==========
+  let remainingOrderAmount = new import_decimal.default(orderTotalAmount);
   const getItemPassUsage = (usageMap, walletPassProductId, lineKey) => {
-    return usageMap.get(walletPassProductId)?.get(lineKey) || 0;
+    var _a;
+    return ((_a = usageMap.get(walletPassProductId)) == null ? void 0 : _a.get(lineKey)) || 0;
   };
-
-  // 按 maxPassesPerItem 过滤：排除已达到该行「券次」上限的展开行（按 _walletPassLineKey）
-  const filterByMaxPassesPerItem = (products, usageMap, walletPassProductId, maxPassesPerItem) => {
-    if (maxPassesPerItem <= 0) return products;
-    return products.filter(p => {
+  const filterByMaxPassesPerItem = (products2, usageMap, walletPassProductId, maxPassesPerItem) => {
+    if (maxPassesPerItem <= 0)
+      return products2;
+    return products2.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 ?? {};
-
-    // 根据 deductTaxAndFee 配置获取推荐金额
+    const { config } = voucher;
+    const { maxDeductionAmount = 0, allowCrossProduct = true, applicableProductLimit = 0, deductTaxAndFee = true, maxPassesPerItem = 0 } = config ?? {};
     const recommendedAmount = getRecommendedAmount(voucher);
-
-    // 基础值 = 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 过滤：排除已达到单商品可用卡券上限的商品
+    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));
     if (itemPassUsage) {
       applicableProducts = filterByMaxPassesPerItem(applicableProducts, itemPassUsage, voucher.product_id, maxPassesPerItem);
     }
     if (applicableProducts.length === 0) {
-      return new _decimal.default(0);
+      return new import_decimal.default(0);
     }
-
-    // 根据跨商品配置计算适用商品金额
-    let finalApplicableAmount = new _decimal.default(0);
+    let finalApplicableAmount = new import_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;
-          // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
+          if (remainingLimit <= 0)
+            break;
           const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
           const deductQty = Math.min(currentAvailableQty, remainingLimit);
-          // 实际可抵扣金额 = min(数量 * 单价, 剩余金额)
-          const deductAmount = _decimal.default.min(product[unitPriceField].times(deductQty), product[amountField]);
+          const deductAmount = import_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 _decimal.default(0));
+        finalApplicableAmount = applicableProducts.reduce(
+          (sum, p) => sum.plus(p[amountField]),
+          new import_decimal.default(0)
+        );
       }
     } else {
-      // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
-      const maxProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
-      // maxPassesPerItem 限制每张券最多抵扣的单位数
+      const maxProduct = applicableProducts.reduce(
+        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
+      );
       if (maxPassesPerItem > 0) {
-        finalApplicableAmount = _decimal.default.min(maxProduct[unitPriceField].times(maxPassesPerItem), maxProduct[amountField]);
+        finalApplicableAmount = import_decimal.default.min(
+          maxProduct[unitPriceField].times(maxPassesPerItem),
+          maxProduct[amountField]
+        );
       } else {
         finalApplicableAmount = maxProduct[amountField];
       }
     }
-
-    // 返回最小值
-    return _decimal.default.min(baseAmount, finalApplicableAmount, remainingOrderAmount);
+    return import_decimal.default.min(baseAmount, finalApplicableAmount, remainingOrderAmount);
   };
-
-  // 辅助函数：判断券是否可用，返回可用性和原因代码
-  const isVoucherAvailable = (voucher, productsData, usedVoucherCounts, itemPassUsage) => {
-    const {
-      config,
-      id,
-      product_id
-    } = voucher;
-
-    // 根据 deductTaxAndFee 配置获取推荐金额
+  const isVoucherAvailable = (voucher, productsData, usedVoucherCounts2, itemPassUsage) => {
+    const { config, id, product_id } = voucher;
     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" };
     }
-
-    // 检查 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'
-        };
+    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" };
       }
     }
-
-    // 检查 maxPassesPerItem：如果所有适用商品都已达到单商品可用卡券上限，则不可用
-    const maxPassesPerItem = config?.maxPassesPerItem || 0;
+    const maxPassesPerItem = (config == null ? void 0 : config.maxPassesPerItem) || 0;
     if (maxPassesPerItem > 0 && itemPassUsage) {
-      const deductTaxAndFee = config?.deductTaxAndFee ?? true;
-      const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
-      const availableAfterPassLimit = getApplicableProducts(voucher, productsData).filter(p => p[amountField].greaterThan(0)).filter(p => {
+      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 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 };
   };
-
-  // ========== 第一步：为所有券计算初始的 _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 usedVoucherCountsForAll = /* @__PURE__ */ 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 = new Map(); // 跟踪每个券 ID 的使用次数
-
-  // 重置商品余额追踪（同时维护含税和不含税两个金额池）
+  const usedVoucherCounts = /* @__PURE__ */ new Map();
   const productsForRecommendation = expandProductsWithBundleItems(products, true);
-  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);
+  remainingOrderAmount = new import_decimal.default(orderTotalAmount);
+  const itemPassUsageMap = /* @__PURE__ */ new Map();
+  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));
-
-    // 按 maxPassesPerItem 过滤：排除已达到单商品可用卡券上限的商品
+    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));
     applicableProducts = filterByMaxPassesPerItem(applicableProducts, itemPassUsageMap, product_id, maxPassesPerItem);
-    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 (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 (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;
-          // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
+          if (remainingLimit <= 0)
+            break;
           const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
           const deductQty = Math.min(currentAvailableQty, remainingLimit);
-          // 实际可抵扣金额 = min(数量 * 单价, 剩余金额)
-          const deductAmount = _decimal.default.min(product[unitPriceField].times(deductQty), product[amountField]);
+          const deductAmount = import_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 _decimal.default(0));
+        calculatedAvailableMaxAmount = applicableProducts.reduce(
+          (sum, p) => sum.plus(p[amountField]),
+          new import_decimal.default(0)
+        );
       }
     } else {
-      // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
-      const maxProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
-      // maxPassesPerItem 限制每张券最多抵扣的单位数
+      const maxProduct = applicableProducts.reduce(
+        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
+      );
       if (maxPassesPerItem > 0) {
-        calculatedAvailableMaxAmount = _decimal.default.min(maxProduct[unitPriceField].times(maxPassesPerItem), maxProduct[amountField]);
+        calculatedAvailableMaxAmount = import_decimal.default.min(
+          maxProduct[unitPriceField].times(maxPassesPerItem),
+          maxProduct[amountField]
+        );
       } else {
         calculatedAvailableMaxAmount = maxProduct[amountField];
       }
     }
-
-    // 取最小值：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);
+    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
+    );
     let deductionLeft = maxDeduction;
     const deductionDetails = [];
     if (allowCrossProduct) {
-      // 跨商品券：按剩余金额从高到低抵扣，受 applicableProductLimit 限制
-      const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
+      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;
-
-        // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
+        if (deductionLeft.lessThanOrEqualTo(0) || remainingLimit <= 0)
+          break;
         const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
         const availableQty = Math.min(currentAvailableQty, remainingLimit);
-
-        // 计算本商品最大可抵扣金额 = min(数量 * 单价, 剩余金额)
-        const maxDeductForProduct = _decimal.default.min(product[unitPriceField].times(availableQty), product[amountField]);
-        const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
-
-        // 计算实际抵扣的数量（用于记录和配额计算）
+        const maxDeductForProduct = import_decimal.default.min(
+          product[unitPriceField].times(availableQty),
+          product[amountField]
+        );
+        const actualDeductAmount = import_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;
@@ -477,24 +378,23 @@ 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);
-
-      // maxPassesPerItem 限制每张券最多抵扣的单位数
+      const targetProduct = applicableProducts.reduce(
+        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
+      );
       let maxDeductForProduct = targetProduct[amountField];
       if (maxPassesPerItem > 0) {
-        maxDeductForProduct = _decimal.default.min(targetProduct[unitPriceField].times(maxPassesPerItem), targetProduct[amountField]);
+        maxDeductForProduct = import_decimal.default.min(
+          targetProduct[unitPriceField].times(maxPassesPerItem),
+          targetProduct[amountField]
+        );
       }
-      const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
-
-      // 计算实际抵扣的数量
+      const actualDeductAmount = import_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({
@@ -509,14 +409,9 @@ 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(),
@@ -530,47 +425,17 @@ function processVouchers(applicableVouchers, orderTotalAmount, products) {
     }
     return false;
   };
-
-  /**
-  // 第一轮：处理未跨商品券
-  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 => {
+  applicableVouchers.forEach((voucher) => {
     applyVoucher(voucher);
   });
-
-  // recommendedVouchers 已经包含了基于应用时计算的 _available_max_amount 和 _unified_available_status
-
-  // ========== 第三步：构建 all 数组，以 recommended 为基础 ==========
-  // 创建 recommended 券的 Map，以 id 为 key
-  const recommendedMap = new Map();
-  recommendedVouchers.forEach(v => {
+  const recommendedMap = /* @__PURE__ */ new Map();
+  recommendedVouchers.forEach((v) => {
     recommendedMap.set(v.id, v);
   });
-
-  // 遍历所有券，如果在 recommended 中则使用增强数据，否则使用基础数据
-  const allWithEnhancedData = allVouchersWithStatus.map(voucher => {
+  const allWithEnhancedData = allVouchersWithStatus.map((voucher) => {
     if (recommendedMap.has(voucher.id)) {
-      // 使用 recommended 中的增强数据
       return recommendedMap.get(voucher.id);
     } else {
-      // 不在 recommended 中的券，补充基础字段
       return {
         ...voucher,
         actualDeduction: 0,
@@ -584,98 +449,70 @@ 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 _decimal.default(orderTotalAmount);
+  let remainingOrderAmount = new import_decimal.default(orderTotalAmount);
   const selectedWithDetails = [];
-
-  // 追踪每个 Wallet Pass 商品对每个订单商品行的已使用卡券次数（按行唯一键）
-  const itemPassUsageMap = new Map();
+  const itemPassUsageMap = /* @__PURE__ */ new Map();
   const getItemPassUsageRecalc = (walletPassProductId, lineKey) => {
-    return itemPassUsageMap.get(walletPassProductId)?.get(lineKey) || 0;
+    var _a;
+    return ((_a = itemPassUsageMap.get(walletPassProductId)) == null ? void 0 : _a.get(lineKey)) || 0;
   };
-  const filterByMaxPassesPerItemRecalc = (products, walletPassProductId, maxPassesPerItem) => {
-    if (maxPassesPerItem <= 0) return products;
-    return products.filter(p => {
+  const filterByMaxPassesPerItemRecalc = (products2, walletPassProductId, maxPassesPerItem) => {
+    if (maxPassesPerItem <= 0)
+      return products2;
+    return products2.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 {
-      config,
-      id
-    } = selectedVoucher;
-    const {
-      maxDeductionAmount,
-      allowCrossProduct,
-      applicableProductLimit,
-      deductTaxAndFee = true,
-      maxPassesPerItem = 0
-    } = config;
-
-    // 根据券的配置选择使用哪个单价字段和金额字段
-    const unitPriceField = deductTaxAndFee ? 'unitPriceWithTax' : 'unitPricePure';
-    const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
-
-    // 获取适用商品（只筛选有剩余金额的商品）
-    let applicableProducts = getApplicableProducts(selectedVoucher, productsForCalc).filter(p => p[amountField].greaterThan(0));
-
-    // 按 maxPassesPerItem 过滤：排除已达到该行券次上限的展开行
+  selectedVouchers.forEach((selectedVoucher) => {
+    const { config, id } = selectedVoucher;
+    const { maxDeductionAmount, allowCrossProduct, applicableProductLimit, deductTaxAndFee = true, maxPassesPerItem = 0 } = config;
+    const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
+    const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
+    let applicableProducts = getApplicableProducts(
+      selectedVoucher,
+      productsForCalc
+    ).filter((p) => p[amountField].greaterThan(0));
     applicableProducts = filterByMaxPassesPerItemRecalc(applicableProducts, selectedVoucher.product_id, maxPassesPerItem);
     if (applicableProducts.length === 0) {
-      // 无适用商品，跳过
       selectedWithDetails.push({
         ...selectedVoucher,
         actualDeduction: 0,
         deductionDetails: [],
         _available_max_amount: 0,
         _unified_available_status: 0,
-        reasonCode: 'not_meet_the_required_conditions'
+        reasonCode: "not_meet_the_required_conditions"
       });
       return;
     }
-
-    // 计算本次抵扣金额：
-    // - 用户手动编辑时以编辑金额为准；
-    // - 自动推荐/重算时沿用上一轮基于剩余待付金额算出的 _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);
+    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
+    );
     let deductionLeft = maxDeduction;
     const deductionDetails = [];
     if (allowCrossProduct) {
-      // 跨商品券：按剩余金额从高到低抵扣，受 applicableProductLimit 限制
-      const sortedProducts = [...applicableProducts].sort((a, b) => a[amountField].comparedTo(b[amountField]) > 0 ? -1 : 1);
+      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;
-
-        // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
+        if (deductionLeft.lessThanOrEqualTo(0) || remainingLimit <= 0)
+          break;
         const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
         const availableQty = Math.min(currentAvailableQty, remainingLimit);
-
-        // 计算本商品最大可抵扣金额 = min(数量 * 单价, 剩余金额)
-        const maxDeductForProduct = _decimal.default.min(product[unitPriceField].times(availableQty), product[amountField]);
-        const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
-
-        // 计算实际抵扣的数量（用于记录和配额计算）
+        const maxDeductForProduct = import_decimal.default.min(
+          product[unitPriceField].times(availableQty),
+          product[amountField]
+        );
+        const actualDeductAmount = import_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;
@@ -687,24 +524,23 @@ 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);
-
-      // maxPassesPerItem 限制每张券最多抵扣的单位数
+      const targetProduct = applicableProducts.reduce(
+        (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
+      );
       let maxDeductForProduct = targetProduct[amountField];
       if (maxPassesPerItem > 0) {
-        maxDeductForProduct = _decimal.default.min(targetProduct[unitPriceField].times(maxPassesPerItem), targetProduct[amountField]);
+        maxDeductForProduct = import_decimal.default.min(
+          targetProduct[unitPriceField].times(maxPassesPerItem),
+          targetProduct[amountField]
+        );
       }
-      const actualDeductAmount = _decimal.default.min(deductionLeft, maxDeductForProduct);
-
-      // 计算实际抵扣的数量
+      const actualDeductAmount = import_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({
@@ -718,8 +554,6 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       });
     }
     const totalDeducted = maxDeduction.minus(deductionLeft);
-
-    // 更新订单剩余金额
     remainingOrderAmount = remainingOrderAmount.minus(totalDeducted);
     applyMaxPassUsageIncrements(itemPassUsageMap, selectedVoucher.product_id, maxPassesPerItem, deductionDetails);
     selectedWithDetails.push({
@@ -732,105 +566,97 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       _unified_available_status: totalDeducted.greaterThan(0) ? 1 : 0
     });
   });
-
-  // 第二步：为所有券重新计算 _available_max_amount 和 _unified_available_status
-  const selectedIds = new Set(selectedVouchers.map(v => v.id));
-  const usedVoucherCounts = new Map();
-  selectedVouchers.forEach(v => {
+  const selectedIds = new Set(selectedVouchers.map((v) => v.id));
+  const usedVoucherCounts = /* @__PURE__ */ new Map();
+  selectedVouchers.forEach((v) => {
     usedVoucherCounts.set(v.product_id, (usedVoucherCounts.get(v.product_id) || 0) + 1);
   });
-  const allWithUpdatedStatus = allVouchers.map(voucher => {
-    // 如果是已选中的券，使用详细计算结果
+  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 {
-      config,
-      id,
-      product_id
-    } = voucher;
-    const {
-      maxDeductionAmount,
-      allowCrossProduct,
-      applicableProductLimit,
-      deductTaxAndFee = true,
-      maxPassesPerItem = 0
-    } = config;
-
-    // 根据券的配置选择使用哪个单价字段和金额字段
-    const unitPriceField = deductTaxAndFee ? 'unitPriceWithTax' : 'unitPricePure';
-    const amountField = deductTaxAndFee ? 'remainingAmountWithTax' : 'remainingAmountPure';
-
-    // 根据 deductTaxAndFee 配置获取推荐金额
+    const { config, id, product_id } = voucher;
+    const { maxDeductionAmount, allowCrossProduct, applicableProductLimit, deductTaxAndFee = true, maxPassesPerItem = 0 } = config;
+    const unitPriceField = deductTaxAndFee ? "unitPriceWithTax" : "unitPricePure";
+    const amountField = deductTaxAndFee ? "remainingAmountWithTax" : "remainingAmountPure";
     const recommendedAmount = getRecommendedAmount(voucher);
-
-    // 检查基本可用性
     let isAvailable = true;
-    let calculatedMaxAmount = new _decimal.default(0);
+    let calculatedMaxAmount = new import_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));
-
-        // 按 maxPassesPerItem 过滤：排除已达到单商品可用卡券上限的商品
+        let applicableProducts = getApplicableProducts(
+          voucher,
+          productsForCalc
+        ).filter((p) => p[amountField].greaterThan(0));
         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 {
-          // 计算 _available_max_amount
-          const baseAmount = _decimal.default.min(new _decimal.default(recommendedAmount), new _decimal.default(maxDeductionAmount));
+          const baseAmount = import_decimal.default.min(
+            new import_decimal.default(recommendedAmount),
+            new import_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;
-                // 动态计算当前可抵扣数量 = ceil(剩余金额 / 单价)
+                if (remainingLimit <= 0)
+                  break;
                 const currentAvailableQty = Math.ceil(product[amountField].dividedBy(product[unitPriceField]).toNumber());
                 const deductQty = Math.min(currentAvailableQty, remainingLimit);
-                // 实际可抵扣金额 = min(数量 * 单价, 剩余金额)
-                const deductAmount = _decimal.default.min(product[unitPriceField].times(deductQty), product[amountField]);
+                const deductAmount = import_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 _decimal.default(0));
+              calculatedMaxAmount = applicableProducts.reduce(
+                (sum, p) => sum.plus(p[amountField]),
+                new import_decimal.default(0)
+              );
             }
           } else {
-            // 非跨商品券：选择单价最高的商品（优先抵扣高价商品）
-            const maxProduct = applicableProducts.reduce((max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max);
-            // maxPassesPerItem 限制每张券最多抵扣的单位数
+            const maxProduct = applicableProducts.reduce(
+              (max, p) => p[unitPriceField].greaterThan(max[unitPriceField]) ? p : max
+            );
             if (maxPassesPerItem > 0) {
-              calculatedMaxAmount = _decimal.default.min(maxProduct[unitPriceField].times(maxPassesPerItem), maxProduct[amountField]);
+              calculatedMaxAmount = import_decimal.default.min(
+                maxProduct[unitPriceField].times(maxPassesPerItem),
+                maxProduct[amountField]
+              );
             } else {
               calculatedMaxAmount = maxProduct[amountField];
             }
           }
-          calculatedMaxAmount = _decimal.default.min(baseAmount, calculatedMaxAmount, remainingOrderAmount);
+          calculatedMaxAmount = import_decimal.default.min(
+            baseAmount,
+            calculatedMaxAmount,
+            remainingOrderAmount
+          );
           if (calculatedMaxAmount.lessThanOrEqualTo(0)) {
             isAvailable = false;
-            reasonCode = 'exceeds_the_maximum_deduction_limit';
+            reasonCode = "exceeds_the_maximum_deduction_limit";
           }
         }
       }
@@ -840,9 +666,7 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
       _available_max_amount: calculatedMaxAmount.toNumber(),
       // 转换为数字
       _unified_available_status: isAvailable ? 1 : 0,
-      ...(reasonCode && {
-        reasonCode
-      })
+      ...reasonCode && { reasonCode }
     };
   });
   return {
@@ -850,158 +674,47 @@ function recalculateVouchers(allVouchers, selectedVouchers, orderTotalAmount, pr
     selectedWithDetails
   };
 }
-
-/**
- * 获取税费和附加费的舍入余数
- * @param product 商品
- * @param isDeductTaxAndFee 是否抵扣税费与附加费
- * @returns 舍入余数（税费 + 附加费的舍入余数）
- */
-const getTaxAndFeeRoundingRemainder = (product, isDeductTaxAndFee) => {
-  if (!isDeductTaxAndFee) {
-    return 0;
-  }
-
-  // 税费舍入余数（如果价格包含税则为0）
-  let taxFeeRoundingRemainder = new _decimal.default(0);
-  if (product.is_price_include_tax !== 1) {
-    taxFeeRoundingRemainder = new _decimal.default(product?.metadata?.tax_fee_rounding_remainder || 0);
-  }
-
-  // 附加费舍入余数
-  const surchargeFeeRoundingRemainder = new _decimal.default(product?.metadata?.surcharge_rounding_remainder || 0);
-  return taxFeeRoundingRemainder.add(surchargeFeeRoundingRemainder).toNumber();
-};
-
-/**
- * 获取主商品的商品差额
- * @param product 商品
- * @returns 商品差额（与数量无关，计算总价时需要减去）
- */
-exports.getTaxAndFeeRoundingRemainder = getTaxAndFeeRoundingRemainder;
-const getProductDiscountDifference = product => {
-  return new _decimal.default(product?.metadata?.product_discount_difference || 0).toNumber();
-};
-
-/**
- * 获取主商品价格（单价，不含舍入余数）
- * @param product 商品
- * @param isDeductTaxAndFee 是否抵扣税费与附加费
- * @returns 商品单价
- */
-exports.getProductDiscountDifference = getProductDiscountDifference;
-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 || []) {
-    // 子商品是加价或减价才需要计算
+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) || []) {
     if (getBundleItemIsMarkupOrDiscountPrice(bundleItem)) {
-      // 子商品价格
-      const bundleItemPrice = new _decimal.default(bundleItem.bundle_selling_price ?? 0);
+      const bundleItemPrice = new import_decimal.default(bundleItem.bundle_selling_price ?? 0);
       mainProductPrice = mainProductPrice.add(bundleItemPrice.times(bundleItem.num));
     }
   }
-  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);
+  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);
   if (product.is_price_include_tax === 1) {
-    taxFee = new _decimal.default(0);
+    taxFee = new import_decimal.default(0);
   }
-
-  // 税费
-  // 附加费
-  const surchargeFee = new _decimal.default(product?.metadata?.main_product_attached_bundle_surcharge_fee || 0).add(product?.metadata?.surcharge_rounding_remainder || 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 taxAndFeeTotal = taxFee.add(surchargeFee);
-
-  // 如果需要抵扣税费与附加费，则加上税费附加费总额
   if (isDeductTaxAndFee) {
     mainProductPrice = mainProductPrice.add(taxAndFeeTotal);
   }
   return mainProductPrice.toNumber();
 };
-
-/**
- * 获取套餐子商品税费和附加费的舍入余数
- * @param bundleItem 套餐子商品
- * @param isDeductTaxAndFee 是否抵扣税费与附加费
- * @returns 舍入余数（税费 + 附加费的舍入余数）
- */
-exports.getMainProductPrice = getMainProductPrice;
-const getBundleItemTaxAndFeeRoundingRemainder = (bundleItem, isDeductTaxAndFee) => {
-  if (!isDeductTaxAndFee) {
-    return 0;
-  }
-
-  // 税费舍入余数（如果价格包含税则为0）
-  let taxFeeRoundingRemainder = new _decimal.default(0);
-  if (bundleItem.is_price_include_tax !== 1) {
-    taxFeeRoundingRemainder = new _decimal.default(bundleItem.metadata?.tax_fee_rounding_remainder || 0);
-  }
-
-  // 附加费舍入余数
-  const surchargeFeeRoundingRemainder = new _decimal.default(bundleItem.metadata?.surcharge_rounding_remainder || 0);
-  return taxFeeRoundingRemainder.add(surchargeFeeRoundingRemainder).toNumber();
-};
-
-/**
- * 获取套餐子商品的商品差额
- * @param bundleItem 套餐子商品
- * @returns 商品差额（与数量无关，计算总价时需要减去）
- */
-exports.getBundleItemTaxAndFeeRoundingRemainder = getBundleItemTaxAndFeeRoundingRemainder;
-const getBundleItemDiscountDifference = bundleItem => {
-  return new _decimal.default(bundleItem.metadata?.product_discount_difference || 0).toNumber();
-};
-
-/**
- * 获取套餐子商品价格（不含舍入余数）
- * @param bundleItem 套餐子商品
- * @param parentQuantity 父商品数量
- * @param isDeductTaxAndFee 是否抵扣税费与附加费
- * @returns 子商品总价格（不含舍入余数）
- */
-exports.getBundleItemDiscountDifference = getBundleItemDiscountDifference;
-const getBundleItemPrice = (bundleItem, parentQuantity, isDeductTaxAndFee) => {
-  // 子商品基础价格 = bundle_selling_price * num * 主商品数量
+var getBundleItemPrice = (bundleItem, parentQuantity, isDeductTaxAndFee) => {
+  var _a;
   const totalQuantity = bundleItem.num * parentQuantity;
-  let bundleItemPrice = new _decimal.default(bundleItem.bundle_selling_price ?? 0).times(totalQuantity);
-
-  // 根据 deductTaxAndFee 配置决定是否加上税费和附加费
+  let bundleItemPrice = new import_decimal.default(bundleItem.bundle_selling_price ?? 0).times(totalQuantity);
   if (isDeductTaxAndFee) {
-    // 税费
-    let taxFee = new _decimal.default(bundleItem.tax_fee ?? 0).times(totalQuantity);
+    let taxFee = new import_decimal.default(bundleItem.tax_fee ?? 0).times(totalQuantity);
     if (bundleItem.is_price_include_tax === 1) {
-      taxFee = new _decimal.default(0);
+      taxFee = new import_decimal.default(0);
     }
-    // 附加费
-    const surchargeFee = new _decimal.default(bundleItem.metadata?.surcharge_fee ?? 0).times(totalQuantity);
+    const surchargeFee = new import_decimal.default(((_a = bundleItem.metadata) == null ? void 0 : _a.surcharge_fee) ?? 0).times(totalQuantity);
     bundleItemPrice = bundleItemPrice.add(taxFee).add(surchargeFee);
   }
   return bundleItemPrice.toNumber();
 };
-
-/**
- * 将商品数据拆分，包含主商品和原价子商品
- * @param products 原始商品列表
- * @param deductTaxAndFee 是否抵扣税费与附加费（已废弃，保留参数以兼容旧代码）
- * @returns 拆分后的商品数据（包含主商品和子商品，同时维护含税和不含税两个金额池，以及单价和剩余数量）
- */
-exports.getBundleItemPrice = getBundleItemPrice;
-const expandProductsWithBundleItems = (products, deductTaxAndFee) => {
+var 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);
-
-    // 获取舍入余数（与数量无关，只加一次）
-    const roundingRemainderWithTax = getTaxAndFeeRoundingRemainder(product, true);
-    // 获取商品差额（与数量无关，计算总价时需要减去）
-    const discountDifference = getProductDiscountDifference(product);
-
-    // 1. 添加主商品（同时计算含税和不含税两个金额，以及单价和剩余数量）
     expandedProducts.push({
       ...product,
       is_bundle_item: false,
@@ -1009,32 +722,22 @@ const expandProductsWithBundleItems = (products, deductTaxAndFee) => {
       _walletPassLineKey: parentLineKey,
       _orderLineQuantity: productQuantity,
       // 单价（用于按 quantity 计算抵扣）
-      unitPriceWithTax: new _decimal.default(unitPriceWithTax),
-      unitPricePure: new _decimal.default(unitPricePure),
+      unitPriceWithTax: new import_decimal.default(unitPriceWithTax),
+      unitPricePure: new import_decimal.default(unitPricePure),
       // 剩余可抵扣数量
       remainingQuantity: productQuantity,
-      // 含税费的剩余金额（单价 * 数量 + 舍入余数 - 商品差额）
-      remainingAmountWithTax: new _decimal.default(unitPriceWithTax).times(productQuantity).add(roundingRemainderWithTax).sub(discountDifference),
-      // 纯商品金额（不含税费，也需要减去商品差额）
-      remainingAmountPure: new _decimal.default(unitPricePure).times(productQuantity).sub(discountDifference)
+      // 含税费的剩余金额
+      remainingAmountWithTax: new import_decimal.default(unitPriceWithTax).times(productQuantity),
+      // 纯商品金额（不含税费）
+      remainingAmountPure: new import_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}`;
-          // 计算子商品单价（注意：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);
-
-          // 获取子商品舍入余数（与数量无关，只加一次）
-          const bundleRoundingRemainder = getBundleItemTaxAndFeeRoundingRemainder(bundleItem, true);
-          // 获取子商品差额（与数量无关，计算总价时需要减去）
-          const bundleDiscountDifference = getBundleItemDiscountDifference(bundleItem);
-
-          // 原价子商品作为独立商品
+          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);
           expandedProducts.push({
             ...bundleItem,
             product_id: bundleItem.bundle_product_id,
@@ -1050,10 +753,10 @@ const expandProductsWithBundleItems = (products, deductTaxAndFee) => {
             unitPricePure: bundleUnitPricePure,
             // 剩余可抵扣数量
             remainingQuantity: bundleQuantity,
-            // 含税费的剩余金额（总价 + 舍入余数 - 商品差额）
-            remainingAmountWithTax: new _decimal.default(getBundleItemPrice(bundleItem, productQuantity, true)).add(bundleRoundingRemainder).sub(bundleDiscountDifference),
-            // 纯商品金额（不含税费，也需要减去商品差额）
-            remainingAmountPure: new _decimal.default(getBundleItemPrice(bundleItem, productQuantity, false)).sub(bundleDiscountDifference)
+            // 含税费的剩余金额
+            remainingAmountWithTax: new import_decimal.default(getBundleItemPrice(bundleItem, productQuantity, true)),
+            // 纯商品金额（不含税费）
+            remainingAmountPure: new import_decimal.default(getBundleItemPrice(bundleItem, productQuantity, false))
           });
         }
       });
@@ -1061,27 +764,29 @@ const expandProductsWithBundleItems = (products, deductTaxAndFee) => {
   });
   return expandedProducts;
 };
-
-// bundle商品是否是原价
-const getBundleItemIsOriginalPrice = item => {
-  return item?.price_type === 'markup' && item?.price_type_ext === 'product_price';
+var getBundleItemIsOriginalPrice = (item) => {
+  return (item == null ? void 0 : item.price_type) === "markup" && (item == null ? void 0 : item.price_type_ext) === "product_price";
 };
-
-// bundle商品是否是加价
-exports.getBundleItemIsOriginalPrice = getBundleItemIsOriginalPrice;
-const getBundleItemIsMarkupPrice = item => {
-  return item?.price_type === 'markup' && (item?.price_type_ext === '' || !item?.price_type_ext);
+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.getBundleItemIsMarkupPrice = getBundleItemIsMarkupPrice;
-const getBundleItemIsDiscountPrice = item => {
-  return item?.price_type === 'markdown' && (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.getBundleItemIsDiscountPrice = getBundleItemIsDiscountPrice;
-const getBundleItemIsMarkupOrDiscountPrice = item => {
+var getBundleItemIsMarkupOrDiscountPrice = (item) => {
   return getBundleItemIsMarkupPrice(item) || getBundleItemIsDiscountPrice(item);
 };
-exports.getBundleItemIsMarkupOrDiscountPrice = getBundleItemIsMarkupOrDiscountPrice;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getApplicableProductIds,
+  getBundleItemIsDiscountPrice,
+  getBundleItemIsMarkupOrDiscountPrice,
+  getBundleItemIsMarkupPrice,
+  getBundleItemIsOriginalPrice,
+  getBundleItemPrice,
+  getMainProductPrice,
+  getProductQuantity,
+  processVouchers,
+  recalculateVouchers,
+  resolveWalletPassLineKey
+});