@pisell/pisellos 0.0.567 → 0.0.569

package/lib/modules/Rules/index.js

@@ -1,58 +1,32 @@
-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/modules/Rules/index.ts
-var Rules_exports = {};
-__export(Rules_exports, {
-  RulesModule: () => RulesModule
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(Rules_exports);
-var import_BaseModule = require("../BaseModule");
-var import_types = require("./types");
-var import_utils = require("../../solution/ShopDiscount/utils");
-var import_utils2 = require("../Cart/utils");
-var import_decimal = __toESM(require("decimal.js"));
-var import_lodash_es = require("lodash-es");
-var import_dayjs = __toESM(require("dayjs"));
-var import_utils3 = require("../../solution/ShopDiscount/utils");
-var import_utils4 = require("../../solution/ShopDiscount/utils");
-var RulesModule = class extends import_BaseModule.BaseModule {
+exports.RulesModule = void 0;
+var _BaseModule = require("../BaseModule");
+var _types = require("./types");
+var _utils = require("../../solution/ShopDiscount/utils");
+var _utils2 = require("../Cart/utils");
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _lodashEs = require("lodash-es");
+var _dayjs = _interopRequireDefault(require("dayjs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class RulesModule extends _BaseModule.BaseModule {
+  defaultName = 'rules';
+  defaultVersion = '1.0.0';
+  store;
+  window; // WindowPlugin 实例
+  hooks;
   constructor(name, version) {
     super(name, version);
-    this.defaultName = "rules";
-    this.defaultVersion = "1.0.0";
     this.hooks = {};
   }
   async initialize(core, options) {
     this.core = core;
-    this.hooks = options == null ? void 0 : options.hooks;
-    this.store = options == null ? void 0 : options.store;
-    this.window = core.getPlugin("window");
+    this.hooks = options?.hooks;
+    this.store = options?.store;
+    this.window = core.getPlugin('window');
   }
   async setRulesList(rulesList) {
     this.store.rulesList = rulesList;
@@ -62,22 +36,25 @@ var RulesModule = class extends import_BaseModule.BaseModule {
     return this.store.rulesList;
   }
   getWalletPassEvaluator() {
-    var _a, _b;
-    return (_b = (_a = this.window).getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
+    return this.window.getWalletPassEvaluator?.();
   }
+
   // 商品不需要holder,则不需要判断，直接返回true，商品需要holder但是还没填写，那么暂时不使用带有holder的券，直到填写才去匹配
   checkHolderMatch(discount, product, holders) {
-    var _a;
-    if (((_a = discount.holder) == null ? void 0 : _a.holder_type) !== "form")
-      return true;
-    const orderHolderId = Array.isArray(holders) && holders.length > 0 ? holders[0].form_record_id : void 0;
+    // 非表单类型 holder 视为匹配
+    if (discount.holder?.holder_type !== 'form') return true;
+    // 主预约holder, 目前（20251124）默认只考虑单个holder的情况
+    // 旧版 holders[0].form_record_id 新版 holders[0]
+    const orderHolderId = Array.isArray(holders) && holders.length > 0 ? holders[0].form_record_id || holders[0] : undefined;
     const productHolderId = Array.isArray(product.holder_id) ? product.holder_id[0] : product.holder_id;
-    if (!product.isNeedHolder)
-      return true;
-    if (!orderHolderId && !productHolderId)
-      return false;
+    // 商品不需要选holder，则不对比holder，直接返回true，
+    if (!product.isNeedHolder) return true;
+    // 商品需要holder，但父预约及商品都无holder，返回false
+    if (!orderHolderId && !productHolderId) return false;
+    // 最终直接匹配 holder 是否相同
     return (productHolderId || orderHolderId) === discount.holder.holder_id;
   }
+
   // 判断discountList 是否可以对当前productList生效
   isDiscountListAvailable({
     oldDiscountList,
@@ -87,6 +64,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
     holders,
     isFormSubject
   }) {
+    // 首先检查是否有新的优惠券可应用
     if (!newDiscountList || newDiscountList.length === 0) {
       return {
         isAvailable: false,
@@ -94,54 +72,58 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         productList
       };
     }
-    if (productList.every((item) => {
-      var _a;
+
+    // 编辑商品已有商品券
+    if (productList.every(item => {
       const product = this.hooks.getProduct(item);
-      return product.booking_id && (((_a = product.discount_list) == null ? void 0 : _a.length) || product.total == 0);
+      return product.booking_id && (product.discount_list?.length || product.total == 0);
     })) {
       return {
         isAvailable: false,
         discountList: oldDiscountList,
         productList,
-        unavailableReason: import_types.UnavailableReason.AlreadyUsed
+        unavailableReason: _types.UnavailableReason.AlreadyUsed
       };
     }
-    const filteredOldDiscountList = oldDiscountList.filter(
-      (discount) => !discount.isEditMode && (discount.tag !== "good_pass" || discount.isScan)
-    );
-    const mergedDiscountList = (0, import_utils.uniqueById)([
-      ...filteredOldDiscountList,
-      ...newDiscountList
-    ]);
+
+    // 合并新旧折扣列表，并计算折扣结果,注意，如果旧折扣里有 isEditMode 为 true 的优惠券，则不合并
+    // 保留之前扫码得到的商品券（isScan: true）
+    const filteredOldDiscountList = oldDiscountList.filter(discount => !discount.isEditMode && (discount.tag !== 'good_pass' || discount.isScan));
+    const mergedDiscountList = (0, _utils.uniqueById)([...filteredOldDiscountList, ...newDiscountList]);
     const result = this.calcDiscount({
       discountList: mergedDiscountList,
       productList: [...productList],
-      holders,
       orderTotalAmount,
+      holders,
       isFormSubject
     }, {
       scan: true
     });
+
+    // 检查是否有产品使用了新折扣
     let hasApplicableDiscount = false;
-    const newDiscountIds = newDiscountList.map((discount) => discount.id);
-    result.productList.forEach((product) => {
-      const { discount_list, bundle } = this.hooks.getProduct(product);
-      const allDiscountList = [...discount_list || []];
-      (bundle || []).forEach((item) => {
-        allDiscountList.push(...(item == null ? void 0 : item.discount_list) || []);
+    const newDiscountIds = newDiscountList.map(discount => discount.id);
+
+    // 遍历处理后的产品列表，检查是否有产品使用了新折扣
+    result.productList.forEach(product => {
+      const {
+        discount_list,
+        bundle
+      } = this.hooks.getProduct(product);
+      const allDiscountList = [...(discount_list || [])];
+      (bundle || []).forEach(item => {
+        allDiscountList.push(...(item?.discount_list || []));
       });
       if (allDiscountList && allDiscountList.length > 0) {
-        const usedNewDiscount = allDiscountList.some(
-          (discount) => {
-            var _a;
-            return newDiscountIds.includes((_a = discount == null ? void 0 : discount.discount) == null ? void 0 : _a.resource_id);
-          }
-        );
+        // 检查是否有使用新折扣的情况
+        const usedNewDiscount = allDiscountList.some(discount => newDiscountIds.includes(discount?.discount?.resource_id));
         if (usedNewDiscount) {
           hasApplicableDiscount = true;
         }
       }
     });
+
+    // 如果券不可用，判断不可用原因
     let unavailableReason;
     if (!hasApplicableDiscount) {
       unavailableReason = this.getUnavailableReason(newDiscountList, productList);
@@ -154,39 +136,51 @@ var RulesModule = class extends import_BaseModule.BaseModule {
     };
   }
   filterDiscountListByType(discountList, type) {
-    return (discountList || []).filter((item) => item.type === type || item.tag === type);
+    return (discountList || []).filter(item => item.type === type || item.tag === type);
+  }
+
+  /** 剔除指定 type/tag 的折扣项，保留手动改价(type=product) / 券等 */
+  excludeDiscountListByType(discountList, type) {
+    return (discountList || []).filter(item => item.type !== type && item.tag !== type);
+  }
+
+  /** 手动改价场景：去掉 promotion，保留 type=product 等行内折扣 */
+  resolveDiscountListForManualOverride(discountList) {
+    return this.excludeDiscountListByType(discountList, 'promotion');
   }
   // 获取券不可用的原因
   getUnavailableReason(discountList, productList) {
-    var _a;
+    // 检查时间限制
     for (const discount of discountList) {
       for (const item of productList) {
         const product = this.hooks.getProduct(item);
-        const bookingTime = ((product == null ? void 0 : product.startDate) || (0, import_dayjs.default)()).format("YYYY-MM-DD HH:mm:ss");
-        const filteredList = (0, import_utils.filterDiscountListByBookingTime)([discount], bookingTime);
+        const bookingTime = (product?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss');
+        const filteredList = (0, _utils.filterDiscountListByBookingTime)([discount], bookingTime);
         if (filteredList.length === 0) {
-          return import_types.UnavailableReason.TimeLimit;
+          return _types.UnavailableReason.TimeLimit;
         }
       }
     }
+
+    // 检查商品适用性
     for (const discount of discountList) {
       const limitedData = discount.limited_relation_product_data;
       let hasApplicableProduct = false;
       for (const item of productList) {
         const product = this.hooks.getProduct(item);
-        if (limitedData.type === "product_all") {
+        if (limitedData.type === 'product_all') {
           hasApplicableProduct = true;
           break;
-        } else if ((_a = limitedData.product_ids) == null ? void 0 : _a.includes(product.id)) {
+        } else if (limitedData.product_ids?.includes(product.id)) {
           hasApplicableProduct = true;
           break;
         }
       }
       if (!hasApplicableProduct) {
-        return import_types.UnavailableReason.ProductNotApplicable;
+        return _types.UnavailableReason.ProductNotApplicable;
       }
     }
-    return import_types.UnavailableReason.Unknown;
+    return _types.UnavailableReason.Unknown;
   }
   calcDiscount({
     discountList,
@@ -195,38 +189,84 @@ var RulesModule = class extends import_BaseModule.BaseModule {
     isFormSubject,
     orderTotalAmount
   }, options) {
+    const resolveIsFormSubject = product => typeof isFormSubject === 'function' ? Boolean(isFormSubject(product)) : Boolean(isFormSubject);
+
+    // 识别出来是不是在编辑的界面里又新增了商品
+    // 这种情况下，如果有可用的优惠券，也会自动勾选上
+    const isEditModeAddNewProduct = productList.find(n => n.booking_id) && productList.find(n => !n.booking_id);
+    const reapplyBookingDiscountProductUids = new Set((options?.reapplyBookingDiscountProductUids || []).filter(uid => uid !== undefined && uid !== null && uid !== '').map(String));
+    const getOriginProductUid = originProduct => {
+      const uid = originProduct?.metadata?.unique_identification_number ?? originProduct?.unique_identification_number;
+      if (uid === undefined || uid === null || uid === '') return undefined;
+      return String(uid);
+    };
+    const shouldReapplyBookingDiscount = (originProduct, selectedDiscount) => {
+      if (!selectedDiscount) return false;
+      const uid = getOriginProductUid(originProduct);
+      if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
+      const discountType = selectedDiscount.tag || selectedDiscount.type;
+      return selectedDiscount.isEditMode === true && selectedDiscount.isSelected === true && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+    };
+    const resolveReapplyEditModeDiscountPercent = (originProduct, selectedDiscount) => {
+      if (!shouldReapplyBookingDiscount(originProduct, selectedDiscount)) return undefined;
+      const discountType = selectedDiscount?.tag || selectedDiscount?.type;
+      if (discountType !== 'discount_card' && discountType !== 'product_discount_card') {
+        return undefined;
+      }
+      const percent = Number(selectedDiscount.discount?.percent);
+      return Number.isFinite(percent) ? percent : undefined;
+    };
     const editModeDiscount = [];
     const addModeDiscount = [];
-    discountList.forEach((discount) => {
+    discountList.forEach(discount => {
       if (discount.isEditMode) {
         editModeDiscount.push(discount);
       } else {
         addModeDiscount.push(discount);
       }
     });
-    const editModeOrderLevelProductIds = /* @__PURE__ */ new Set();
-    editModeDiscount.forEach((discount) => {
-      var _a, _b;
-      if (((_a = discount.discount) == null ? void 0 : _a.discount_calculation_mode) === "order_level") {
-        editModeOrderLevelProductIds.add((_b = discount == null ? void 0 : discount.discount) == null ? void 0 : _b.discount_product_id);
+
+    // 🔥 检查 editModeDiscount 中是否有订单级别的折扣，如果有则禁用 addModeDiscount 中相同 product_id 的折扣卡
+    const editModeOrderLevelProductIds = new Set();
+    editModeDiscount.forEach(discount => {
+      if (discount.discount?.discount_calculation_mode === 'order_level') {
+        editModeOrderLevelProductIds.add(discount?.discount?.discount_product_id);
       }
     });
+
+    // 如果存在订单级别的编辑模式折扣，禁用 addModeDiscount 中相同 product_id 的折扣卡
     if (editModeOrderLevelProductIds.size > 0) {
-      addModeDiscount.forEach((discount) => {
+      addModeDiscount.forEach(discount => {
         if (editModeOrderLevelProductIds.has(discount.product_id)) {
           discount.isDisabled = true;
         }
       });
     }
-    const filteredDiscountList = addModeDiscount.filter((discount) => {
-      return !discount.isManualSelect;
-    });
-    const flattenProductsWithBundle = (productList2) => {
+    const hasDiscountInput = editModeDiscount.length > 0 || addModeDiscount.length > 0 || Boolean(options?.discountId) || Boolean(options?.selectedList?.length) || Boolean(options?.scan);
+    if (!hasDiscountInput) {
+      return {
+        discountList,
+        productList
+      };
+    }
+    const canUseEditModeDiscountForReapply = discount => {
+      const discountType = discount.tag || discount.type;
+      return reapplyBookingDiscountProductUids.size > 0 && discount.isEditMode === true && discount.isSelected === true && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType);
+    };
+
+    // 过滤掉手动取消false的优惠券，但仅用于应用优惠逻辑。
+    // Change time 重报价需要把已选编辑态折扣卡重新放入候选，再由目标 uid 限定作用范围。
+    const filteredDiscountList = [...addModeDiscount.filter(discount => !discount.isManualSelect), ...editModeDiscount.filter(canUseEditModeDiscountForReapply)];
+
+    // 🔥 扁平化商品列表：将 bundle 子商品展开为虚拟商品
+    const flattenProductsWithBundle = productList => {
       const flattened = [];
-      productList2.forEach((originProduct) => {
+      productList.forEach(originProduct => {
         const product = this.hooks.getProduct(originProduct);
+
+        // 1. 添加主商品
         flattened.push({
-          type: "main",
+          type: 'main',
           originProduct,
           product,
           price: Number(product.price || 0),
@@ -237,10 +277,12 @@ var RulesModule = class extends import_BaseModule.BaseModule {
           num: product.num,
           booking_id: product.booking_id
         });
+
+        // 2. 展开 bundle 子商品
         if (product.bundle && Array.isArray(product.bundle) && product.bundle.length > 0) {
           product.bundle.forEach((bundleItem, bundleIndex) => {
             flattened.push({
-              type: "bundle",
+              type: 'bundle',
               originProduct,
               parentProduct: product,
               bundleItem,
@@ -253,8 +295,8 @@ var RulesModule = class extends import_BaseModule.BaseModule {
               parentId: product._id,
               num: bundleItem.num || 1,
               quantity: bundleItem.num || 1,
-              total: new import_decimal.default(bundleItem.price || 0).mul(bundleItem.num || 1).toNumber(),
-              origin_total: new import_decimal.default(bundleItem.price || 0).mul(bundleItem.num || 1).toNumber(),
+              total: new _decimal.default(bundleItem.price || 0).mul(bundleItem.num || 1).toNumber(),
+              origin_total: new _decimal.default(bundleItem.price || 0).mul(bundleItem.num || 1).toNumber(),
               original_price: bundleItem.original_price,
               // 继承主商品属性
               booking_id: bundleItem.booking_id,
@@ -265,121 +307,157 @@ var RulesModule = class extends import_BaseModule.BaseModule {
       });
       return flattened;
     };
+
+    // 优惠力度排序，传进来的数据里可能有商品券，也可能有优惠券
+    // 新的优先级排序规则（从高到低）：
+    // 1. 带有Holder的商品券（metadata?.holder?.type === 'custom' && tag === 'good_pass'）
+    // 2. 带有Holder的商品级折扣卡（metadata?.holder?.type === 'custom' && tag === 'product_discount_card' && discount_calculation_mode !== 'order_level'）
+    // 3. 带有Holder的订单级折扣卡（metadata?.holder?.type === 'custom' && tag === 'product_discount_card' && discount_calculation_mode === 'order_level'）
+    // 4. Customer商品券（metadata?.holder?.type !== 'custom' && tag === 'good_pass'）
+    // 5. Customer商品级折扣卡（metadata?.holder?.type !== 'custom' && tag === 'product_discount_card' && discount_calculation_mode !== 'order_level'）
+    // 6. Customer订单级固定金额折扣（metadata?.holder?.type !== 'custom' && tag === 'product_discount_card' && discount_calculation_mode === 'order_level'）
+    // 同一优先级内部：固定金额优先于百分比，金额/折扣力度越大越优先，最后按过期时间排序
     const sortedDiscountList = [...filteredDiscountList].sort((a, b) => {
-      const isHolderDiscount = (discount) => {
-        var _a, _b;
-        return ((_b = (_a = discount.metadata) == null ? void 0 : _a.holder) == null ? void 0 : _b.type) === "custom";
-      };
-      const isGoodPass = (discount) => discount.tag === "good_pass";
-      const isOrderLevelDiscount = (discount) => {
-        var _a;
-        return discount.tag === "product_discount_card" && ((_a = discount.metadata) == null ? void 0 : _a.discount_calculation_mode) === "order_level";
-      };
-      const isItemLevelDiscount = (discount) => {
-        var _a;
-        return discount.tag === "product_discount_card" && ((_a = discount.metadata) == null ? void 0 : _a.discount_calculation_mode) !== "order_level";
-      };
-      const getPriority = (discount) => {
+      // 辅助函数：判断是否是带有Holder的优惠券
+      const isHolderDiscount = discount => discount.metadata?.holder?.type === 'custom';
+
+      // 辅助函数：判断是否是商品券
+      const isGoodPass = discount => discount.tag === 'good_pass';
+
+      // 辅助函数：判断是否是订单级折扣卡
+      const isOrderLevelDiscount = discount => discount.tag === 'product_discount_card' && discount.metadata?.discount_calculation_mode === 'order_level';
+
+      // 辅助函数：判断是否是商品级折扣卡
+      const isItemLevelDiscount = discount => discount.tag === 'product_discount_card' && discount.metadata?.discount_calculation_mode !== 'order_level';
+
+      // 辅助函数：获取优先级（数字越小优先级越高）
+      const getPriority = discount => {
         const isHolder = isHolderDiscount(discount);
         if (isHolder) {
-          if (isGoodPass(discount))
-            return 1;
-          if (isItemLevelDiscount(discount))
-            return 2;
-          if (isOrderLevelDiscount(discount))
-            return 3;
+          if (isGoodPass(discount)) return 1; // 带有Holder的商品券
+          if (isItemLevelDiscount(discount)) return 2; // 带有Holder的商品级折扣卡
+          if (isOrderLevelDiscount(discount)) return 3; // 带有Holder的订单级折扣卡
         } else {
-          if (isGoodPass(discount))
-            return 4;
-          if (isItemLevelDiscount(discount))
-            return 5;
-          if (isOrderLevelDiscount(discount))
-            return 6;
+          if (isGoodPass(discount)) return 4; // Customer商品券
+          if (isItemLevelDiscount(discount)) return 5; // Customer商品级折扣卡
+          if (isOrderLevelDiscount(discount)) return 6; // Customer订单级固定金额折扣
         }
-        return 7;
+        return 7; // 其他情况
       };
+
+      // 辅助函数：按过期时间比较
       function compareByExpireTime(itemA, itemB) {
         if (itemA.expire_time && itemB.expire_time) {
           const timeA = new Date(itemA.expire_time).getTime();
           const timeB = new Date(itemB.expire_time).getTime();
           return timeA - timeB;
         }
+        // 有过期时间的优先级高于永久的
         return itemA.expire_time ? -1 : itemB.expire_time ? 1 : 0;
       }
+
+      // 辅助函数：同类型折扣卡内部排序（固定金额优先于百分比，金额/折扣力度排序）
       function compareDiscountCardValue(itemA, itemB) {
-        var _a, _b;
-        const typeA = ((_a = itemA.metadata) == null ? void 0 : _a.discount_card_type) || "percent";
-        const typeB = ((_b = itemB.metadata) == null ? void 0 : _b.discount_card_type) || "percent";
-        if (typeA === "fixed_amount" && typeB === "percent")
-          return -1;
-        if (typeA === "percent" && typeB === "fixed_amount")
-          return 1;
-        if (typeA === "fixed_amount" && typeB === "fixed_amount") {
+        const typeA = itemA.metadata?.discount_card_type || 'percent';
+        const typeB = itemB.metadata?.discount_card_type || 'percent';
+
+        // 1. 固定金额优先于百分比
+        if (typeA === 'fixed_amount' && typeB === 'percent') return -1;
+        if (typeA === 'percent' && typeB === 'fixed_amount') return 1;
+
+        // 2. 都是固定金额时，金额越大越优先
+        if (typeA === 'fixed_amount' && typeB === 'fixed_amount') {
           if (itemA.par_value !== itemB.par_value) {
-            const valueA = new import_decimal.default(itemA.par_value || 0);
-            const valueB = new import_decimal.default(itemB.par_value || 0);
-            return valueB.minus(valueA).toNumber();
+            const valueA = new _decimal.default(itemA.par_value || 0);
+            const valueB = new _decimal.default(itemB.par_value || 0);
+            return valueB.minus(valueA).toNumber(); // 金额大的在前
           }
         }
-        if (typeA === "percent" && typeB === "percent") {
+
+        // 3. 都是百分比时，折扣越大越优先（par_value越大越优先）
+        if (typeA === 'percent' && typeB === 'percent') {
           if (itemA.par_value !== itemB.par_value) {
-            const valueA = new import_decimal.default(100).minus(itemA.par_value || 0);
-            const valueB = new import_decimal.default(100).minus(itemB.par_value || 0);
-            return valueA.minus(valueB).toNumber();
+            const valueA = new _decimal.default(100).minus(itemA.par_value || 0);
+            const valueB = new _decimal.default(100).minus(itemB.par_value || 0);
+            return valueA.minus(valueB).toNumber(); // 折扣大的在前
           }
         }
         return 0;
       }
+
+      // 1. 先按优先级排序
       const priorityA = getPriority(a);
       const priorityB = getPriority(b);
       if (priorityA !== priorityB) {
         return priorityA - priorityB;
       }
+
+      // 2. 同一优先级内部排序
+      // 如果是商品券（优先级1或4），按过期时间排序
       if (isGoodPass(a) && isGoodPass(b)) {
         return compareByExpireTime(a, b);
       }
-      if (a.tag === "product_discount_card" && b.tag === "product_discount_card") {
+
+      // 如果是折扣卡（优先级2、3、5、6），按折扣力度排序，然后按过期时间
+      if (a.tag === 'product_discount_card' && b.tag === 'product_discount_card') {
         const valueCompare = compareDiscountCardValue(a, b);
-        if (valueCompare !== 0)
-          return valueCompare;
+        if (valueCompare !== 0) return valueCompare;
         return compareByExpireTime(a, b);
       }
+
+      // 3. 其他情况按照过期时间排序
       return compareByExpireTime(a, b);
     });
+
+    // const newProductList = [];
+    //
+    // productList.forEach(item => {
+    //   const product = this.hooks.getProduct(item);
+    //   if (product.quantity > 1) {
+    //     for (let i = 1; i < product.quantity; i++) {
+    //       newProductList.push(product)
+    //     }
+    //   } else {
+    //     newProductList.push(item)
+    //   }
+    // })
+
+    // 🔥 扁平化商品列表（包含主商品和bundle子商品）
     const flattenedList = flattenProductsWithBundle(productList);
-    const isEditModeAddNewProduct = flattenedList.find((n) => n.booking_id) && flattenedList.find((n) => !n.booking_id);
+
+    // 对扁平化后的列表按价格降序排序（用于应用优惠券时优先选择高价商品）
     const sortedFlattenedList = flattenedList.sort((a, b) => {
-      var _a, _b;
-      const priceA = new import_decimal.default(
-        a.type === "bundle" ? a.original_price ?? a.price ?? "0" : a.price || "0"
-      );
-      const priceB = new import_decimal.default(
-        b.type === "bundle" ? b.original_price ?? b.price ?? "0" : b.price || "0"
-      );
+      // 子商品优先使用 original_price，主商品使用 price
+      const priceA = new _decimal.default(a.type === 'bundle' ? a.original_price ?? a.price ?? '0' : a.price || '0');
+      const priceB = new _decimal.default(b.type === 'bundle' ? b.original_price ?? b.price ?? '0' : b.price || '0');
       if (priceA.equals(priceB)) {
+        // 价格相同时，主商品优先
         if (a.type !== b.type) {
-          return a.type === "main" ? -1 : 1;
+          return a.type === 'main' ? -1 : 1;
         }
-        if (a.type === "main" && b.type === "main") {
+        // 都是主商品时，按原有逻辑排序
+        if (a.type === 'main' && b.type === 'main') {
           if (a.product.quantity === b.product.quantity) {
-            return (((_a = b.product.discount_list) == null ? void 0 : _a.length) || 0) - (((_b = a.product.discount_list) == null ? void 0 : _b.length) || 0);
+            return (b.product.discount_list?.length || 0) - (a.product.discount_list?.length || 0);
           }
           return a.product.quantity - b.product.quantity;
         }
-        if (a.type === "bundle" && b.type === "bundle") {
+        // 都是bundle时，按数量排序
+        if (a.type === 'bundle' && b.type === 'bundle') {
           return (a.num || 1) - (b.num || 1);
         }
       }
       return priceB.minus(priceA).toNumber();
     });
+
+    // 🔥 为每个折扣卡/商品券执行策略检查并附加config
     const evaluator = this.getWalletPassEvaluator();
     if (evaluator) {
-      addModeDiscount.forEach((discount) => {
-        var _a, _b;
+      addModeDiscount.forEach(discount => {
         const discountType = discount.tag || discount.type;
-        if (["good_pass", "discount_card", "product_discount_card"].includes(
-          discountType
-        )) {
+        // 只对 good_pass 和 discount_card 类型执行策略检查
+        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType)) {
+          // 转换 discount 为 Voucher 格式
           const voucher = {
             id: discount.id,
             amount: Number(discount.par_value || 0),
@@ -387,24 +465,27 @@ var RulesModule = class extends import_BaseModule.BaseModule {
             type: discountType,
             product_id: discount.product_id,
             unified_available_status: 1,
-            available_product_type: (_a = discount.limited_relation_product_data) == null ? void 0 : _a.type,
-            available_product_ids: (_b = discount.limited_relation_product_data) == null ? void 0 : _b.product_ids
+            available_product_type: discount.limited_relation_product_data?.type,
+            available_product_ids: discount.limited_relation_product_data?.product_ids
           };
-          const productsForEvaluate = sortedFlattenedList.map((item) => {
-            var _a2;
-            return {
-              product_id: item.id,
-              price: item.price || 0,
-              quantity: item.quantity || item.num || 1,
-              selling_price: item.price || 0,
-              product_options: item.type === "main" ? (_a2 = item.product) == null ? void 0 : _a2.options : void 0
-            };
-          });
+
+          // 转换 sortedFlattenedList 为 Product 格式
+          const productsForEvaluate = sortedFlattenedList.map(item => ({
+            product_id: item.id,
+            price: item.price || 0,
+            quantity: item.quantity || item.num || 1,
+            selling_price: item.price || 0,
+            product_options: item.type === 'main' ? item.product?.options : undefined
+          }));
+
+          // 调用策略检查
           const result = evaluator.checkVoucherAvailability({
-            orderTotalAmount,
+            orderTotalAmount: orderTotalAmount,
             products: productsForEvaluate,
             vouchers: [voucher]
           });
+
+          // 将 config 附加到 discount 对象
           if (result.isAvailable) {
             discount.config = {
               ...result.config,
@@ -418,35 +499,74 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         }
       });
     }
+    // 检查商品是否被排除（全品类）
     const isProductIncludedByLimitedData = (limitedData, productId) => {
-      const excludedIds = (limitedData == null ? void 0 : limitedData.exclude_product_ids) || [];
-      const isExcluded = (limitedData == null ? void 0 : limitedData.filter) === 1 && excludedIds.some((id) => String(id) === String(productId));
+      const excludedIds = limitedData?.exclude_product_ids || [];
+      const isExcluded = limitedData?.filter === 1 && excludedIds.some(id => String(id) === String(productId));
       return !isExcluded;
     };
-    const usedDiscounts = /* @__PURE__ */ new Map();
-    const usedProductIdCounts = /* @__PURE__ */ new Map();
-    const usedDiscountCardLimitCounts = /* @__PURE__ */ new Map();
-    editModeDiscount.forEach((discount) => {
-      var _a;
+
+    /**
+    // 对productList按价格降序排序（用于应用优惠券时优先选择高价商品） 价格相同时使用quantity 排序
+    const sortedProductList = [...productList].sort((a, b) => {
+      const aProduct = this.hooks.getProduct(a);
+      const bProduct = this.hooks.getProduct(b);
+      const priceA = new Decimal((aProduct.price as string) || '0');
+      const priceB = new Decimal((bProduct.price as string) || '0');
+      if (priceA.toNumber() === priceB.toNumber()) {
+        if (aProduct.quantity === bProduct.quantity) {
+          return bProduct.discount_list?.length - aProduct.discount_list?.length;
+        }
+        return aProduct.quantity - bProduct.quantity;
+      }
+      return priceB.toNumber() - priceA.toNumber();
+    });
+     */
+
+    // 标记已使用的优惠券
+    const usedDiscounts = new Map();
+
+    // 🔥 统计每个 product_id（商品券商品id）已使用的数量，用于 maxUsagePerOrder 限制
+    const usedProductIdCounts = new Map();
+
+    // 🔥 统计每张折扣卡的 applicableProductLimit 已使用次数（跨商品全局计数）
+    const usedDiscountCardLimitCounts = new Map();
+
+    // 🔥 预先将 editModeDiscount 中的折扣卡计入 applicableProductLimit 已使用次数
+    editModeDiscount.forEach(discount => {
       const discountType = discount.tag || discount.type;
-      if (["discount_card", "product_discount_card"].includes(discountType)) {
+      if (['discount_card', 'product_discount_card'].includes(discountType)) {
         const currentCount = usedDiscountCardLimitCounts.get(discount.id) || 0;
-        usedDiscountCardLimitCounts.set(discount.id, currentCount + (((_a = discount.metadata) == null ? void 0 : _a.num) || 1));
+        usedDiscountCardLimitCounts.set(discount.id, currentCount + (discount.metadata?.num || 1));
       }
     });
-    const discountApplicability = /* @__PURE__ */ new Map();
-    const discountApplicableProducts = /* @__PURE__ */ new Map();
-    addModeDiscount.forEach((discount) => {
+
+    // 记录每个优惠券适用的商品ID
+    const discountApplicability = new Map();
+
+    // 记录每个优惠券适用的商品详细信息
+    const discountApplicableProducts = new Map();
+
+    // 初始化每个优惠券的适用性和可抵扣商品
+    addModeDiscount.forEach(discount => {
       discountApplicability.set(discount.id, []);
       discountApplicableProducts.set(discount.id, []);
     });
-    const orderLevelDiscountAllocations = /* @__PURE__ */ new Map();
-    const orderLevelDiscountApplicableItems = /* @__PURE__ */ new Map();
-    const itemApplicableDiscounts = /* @__PURE__ */ new Map();
+
+    // 预处理 order_level 固定金额折扣卡的分摊信息
+    // Map<discountId, Map<productId, { discountAmount, difference }>>
+    const orderLevelDiscountAllocations = new Map();
+
+    // 第一步：收集所有被勾选的 order_level 折扣卡及其适用商品
+    // Map<discountId, Set<flatItemId>> - 记录每个折扣卡适用的商品
+    const orderLevelDiscountApplicableItems = new Map();
+    // Map<flatItemId, Set<discountId>> - 记录每个商品可以被哪些折扣卡使用
+    const itemApplicableDiscounts = new Map();
+
+    // 辅助函数：检查商品是否对某个折扣卡可用
     const checkItemApplicableForDiscount = (flatItem, discount) => {
-      var _a, _b, _c, _d, _e, _f, _g, _h;
       let product;
-      if (flatItem.type === "main") {
+      if (flatItem.type === 'main') {
         product = flatItem.product;
       } else {
         product = {
@@ -457,27 +577,38 @@ var RulesModule = class extends import_BaseModule.BaseModule {
           num: flatItem.num,
           booking_id: flatItem.booking_id,
           discount_list: flatItem.discount_list || [],
-          startDate: (_a = flatItem.parentProduct) == null ? void 0 : _a.startDate
+          startDate: flatItem.parentProduct?.startDate
         };
       }
-      const isAvailableProduct = flatItem.type === "main" ? !((product == null ? void 0 : product.booking_id) && ((_b = product == null ? void 0 : product.discount_list) == null ? void 0 : _b.length) && ((_c = product == null ? void 0 : product.discount_list) == null ? void 0 : _c.every((d) => d.id && ["good_pass", "discount_card", "product_discount_card"].includes(d.tag || d.type)))) : !((flatItem == null ? void 0 : flatItem.booking_id) && !!((_e = (_d = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _d.discount_list) == null ? void 0 : _e.length) && ((_g = (_f = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _f.discount_list) == null ? void 0 : _g.every((d) => d.id)));
+
+      // 编辑的商品使用了优惠券不可用
+      const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(d => d.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(d.tag || d.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(d => d.id));
       if (!isAvailableProduct) {
         return false;
       }
-      if ((0, import_lodash_es.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
+
+      // vouchersApplicable 为 false 的商品不参与订单级别折扣均摊
+      if ((0, _lodashEs.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
         return false;
       }
+
+      // 商品价格为0时不可用
       if (Number(product.price) <= 0 || !product.price) {
         return false;
       }
       const limitedData = discount.limited_relation_product_data;
-      const timeLimit = !!(0, import_utils.filterDiscountListByBookingTime)([discount], ((product == null ? void 0 : product.startDate) || (0, import_dayjs.default)()).format("YYYY-MM-DD HH:mm:ss")).length;
+
+      // 时间限制检查
+      const timeLimit = !!(0, _utils.filterDiscountListByBookingTime)([discount], (product?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss')).length;
       if (!timeLimit) {
         return false;
       }
+
+      // 判断商品是否适用
       let isLimitedProduct = false;
-      if (limitedData.type === "product_all") {
-        if (limitedData.filter === 1 && ((_h = limitedData.exclude_product_ids) == null ? void 0 : _h.includes(product.id))) {
+      if (limitedData.type === 'product_all') {
+        // 全品类，但需要检查是否被排除
+        if (limitedData.filter === 1 && limitedData.exclude_product_ids?.includes(product.id)) {
           isLimitedProduct = false;
         } else {
           isLimitedProduct = true;
@@ -485,33 +616,51 @@ var RulesModule = class extends import_BaseModule.BaseModule {
       } else if (limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
         isLimitedProduct = true;
       }
+
+      // 套餐规则检查
       const isBundleAvailable = this.checkPackageSubItemUsageRules(discount, flatItem);
       return isLimitedProduct && isBundleAvailable;
     };
-    const selectedOrderLevelDiscounts = sortedDiscountList.filter((discount) => {
-      return (0, import_utils3.isOrderLevelFixedAmountDiscount)(discount) && discount.isSelected !== false;
+
+    // 收集所有被勾选的 order_level 折扣卡及其适用商品
+    const selectedOrderLevelDiscounts = sortedDiscountList.filter(discount => {
+      return (0, _utils.isOrderLevelFixedAmountDiscount)(discount) && discount.isSelected !== false;
     });
-    selectedOrderLevelDiscounts.forEach((discount) => {
-      const applicableItemIds = /* @__PURE__ */ new Set();
-      sortedFlattenedList.forEach((flatItem) => {
+
+    // 遍历所有被勾选的 order_level 折扣卡，建立双向映射
+    selectedOrderLevelDiscounts.forEach(discount => {
+      const applicableItemIds = new Set();
+      sortedFlattenedList.forEach(flatItem => {
         if (checkItemApplicableForDiscount(flatItem, discount)) {
           applicableItemIds.add(flatItem._id);
+
+          // 记录商品可以被哪些折扣卡使用
           if (!itemApplicableDiscounts.has(flatItem._id)) {
-            itemApplicableDiscounts.set(flatItem._id, /* @__PURE__ */ new Set());
+            itemApplicableDiscounts.set(flatItem._id, new Set());
           }
           itemApplicableDiscounts.get(flatItem._id).add(discount.id);
         }
       });
       orderLevelDiscountApplicableItems.set(discount.id, applicableItemIds);
     });
-    const occupiedItems = /* @__PURE__ */ new Map();
-    selectedOrderLevelDiscounts.forEach((discount) => {
+
+    // 专属折扣卡定义：限定了特定商品（product_ids），而不是全品类（product_all）的折扣卡
+    // 如果专属折扣卡被勾选，它适用的商品会被占用，其他折扣卡均摊时应排除这些商品
+    // Map<flatItemId, discountId> - 记录被占用的商品及其对应的折扣卡
+    const occupiedItems = new Map();
+
+    // 按排序顺序遍历折扣卡，判断哪些是专属折扣卡
+    selectedOrderLevelDiscounts.forEach(discount => {
       const limitedData = discount.limited_relation_product_data;
-      const isExclusiveDiscount = limitedData.type !== "product_all";
+
+      // 判断是否是专属折扣卡（只能用于特定商品，而不是全品类）
+      const isExclusiveDiscount = limitedData.type !== 'product_all';
       if (isExclusiveDiscount) {
+        // 专属折扣卡：它适用的所有商品都会被它占用
         const applicableItems = orderLevelDiscountApplicableItems.get(discount.id);
         if (applicableItems) {
-          applicableItems.forEach((itemId) => {
+          applicableItems.forEach(itemId => {
+            // 如果商品还没被占用，则标记为被当前折扣卡占用
             if (!occupiedItems.has(itemId)) {
               occupiedItems.set(itemId, discount.id);
             }
@@ -519,23 +668,27 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         }
       }
     });
-    console.log("occupiedItems", occupiedItems, "orderLevelDiscountApplicableItems", orderLevelDiscountApplicableItems);
-    sortedDiscountList.forEach((discount) => {
-      if (!(0, import_utils3.isOrderLevelFixedAmountDiscount)(discount)) {
+
+    // 🔥 第三步：识别 order_level 折扣卡并预计算分摊（排除被其他专属折扣卡占用的商品）
+    sortedDiscountList.forEach(discount => {
+      if (!(0, _utils.isOrderLevelFixedAmountDiscount)(discount)) {
         return;
       }
+
+      // 收集该折扣卡适用的商品（排除被其他专属折扣卡占用的商品）
       const applicableProducts = [];
-      sortedFlattenedList.forEach((flatItem) => {
-        var _a, _b, _c;
+      sortedFlattenedList.forEach(flatItem => {
+        // 🔥 检查该商品是否被其他专属折扣卡占用
         const occupyingDiscountId = occupiedItems.get(flatItem._id);
-        if (occupyingDiscountId !== void 0 && occupyingDiscountId !== discount.id) {
+        if (occupyingDiscountId !== undefined && occupyingDiscountId !== discount.id) {
+          // 该商品被其他专属折扣卡占用，跳过
           return;
         }
         if (!checkItemApplicableForDiscount(flatItem, discount)) {
           return;
         }
         let product;
-        if (flatItem.type === "main") {
+        if (flatItem.type === 'main') {
           product = flatItem.product;
         } else {
           product = {
@@ -546,34 +699,53 @@ var RulesModule = class extends import_BaseModule.BaseModule {
             num: flatItem.num
           };
         }
-        const quantity = flatItem.type === "main" ? product.num || product.quantity || 1 : (product.num || product.quantity || 1) * (((_a = flatItem.parentProduct) == null ? void 0 : _a.num) || ((_b = flatItem.parentProduct) == null ? void 0 : _b.quantity) || 1);
-        const originalAmount = flatItem.type === "main" ? Number(product.price ?? 0) : Number(flatItem.original_price ?? flatItem.price ?? 0);
+
+        // 对于 bundle 子商品，quantity 需要乘以主商品的购买数量
+        const quantity = flatItem.type === 'main' ? product.num || product.quantity || 1 : (product.num || product.quantity || 1) * (flatItem.parentProduct?.num || flatItem.parentProduct?.quantity || 1);
+
+        // 对于主商品：使用 price
+        // 对于子商品：优先使用 flatItem.original_price，否则使用 flatItem.price
+        const originalAmount = flatItem.type === 'main' ? Number(product.price ?? 0) : Number(flatItem.original_price ?? flatItem.price ?? 0);
+
+        // 传递 parentQuantity 用于差值处理时判断是否是真正的"数量为1"
         const productData = {
           productId: flatItem._id,
           amount: originalAmount,
-          quantity
+          quantity: quantity
         };
-        if (flatItem.type === "bundle") {
-          productData.parentQuantity = ((_c = flatItem.parentProduct) == null ? void 0 : _c.quantity) || 1;
+
+        // 子商品需要传递主商品数量
+        if (flatItem.type === 'bundle') {
+          productData.parentQuantity = flatItem.parentProduct?.quantity || 1;
         }
         applicableProducts.push(productData);
       });
+
+      // 计算分摊
       if (applicableProducts.length > 0) {
-        const allocation = (0, import_utils4.calculateOrderLevelDiscountAllocation)(discount, applicableProducts);
+        const allocation = (0, _utils.calculateOrderLevelDiscountAllocation)(discount, applicableProducts);
         orderLevelDiscountAllocations.set(discount.id, allocation);
       }
     });
-    const processedProductsMap = /* @__PURE__ */ new Map();
-    const appliedDiscountProducts = /* @__PURE__ */ new Map();
-    sortedFlattenedList.forEach((flatItem) => {
-      var _a;
+
+    // 处理后的商品列表（按排序后的顺序处理，记录优惠信息）
+    const processedProductsMap = new Map();
+
+    // 记录已应用优惠券的商品信息
+    const appliedDiscountProducts = new Map();
+
+    // 首先遍历所有商品和所有优惠券，确定每个优惠券的适用范围，包括isSelected为false的优惠券
+    // 🔥 使用扁平化后的列表，包含主商品和bundle子商品
+    sortedFlattenedList.forEach(flatItem => {
+      // 获取商品数据
       let product, originProduct;
-      if (flatItem.type === "main") {
+      if (flatItem.type === 'main') {
         product = flatItem.product;
         originProduct = flatItem.originProduct;
       } else {
+        // bundle子商品：构造虚拟商品对象
         product = {
-          startDate: (_a = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _a.startDate,
+          startDate: flatItem?.parentProduct?.startDate,
           _id: flatItem._id,
           id: flatItem.id,
           price: flatItem.price,
@@ -586,53 +758,55 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         };
         originProduct = flatItem.originProduct;
       }
-      addModeDiscount.forEach((discount) => {
-        var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-        const limitedData = discount == null ? void 0 : discount.limited_relation_product_data;
-        const _tempVar = (flatItem == null ? void 0 : flatItem.type) === "bundle" ? flatItem == null ? void 0 : flatItem.parentProduct : flatItem == null ? void 0 : flatItem.product;
-        const isHolderMatch = this.checkHolderMatch(
-          discount,
-          {
-            isNeedHolder: isFormSubject && !(_tempVar == null ? void 0 : _tempVar.isNormalProduct),
-            holder_id: (_tempVar == null ? void 0 : _tempVar.holder_id) || product.holder_id
-          },
-          holders
-        );
+      addModeDiscount.forEach(discount => {
+        const limitedData = discount?.limited_relation_product_data;
+        // 拿到discount配置的holder信息 product信息 product.holder 加在 isLimitedProduct
+        const _tempVar = flatItem?.type === 'bundle' ? flatItem?.parentProduct : flatItem?.product;
+        const isHolderMatch = this.checkHolderMatch(discount, {
+          isNeedHolder: resolveIsFormSubject(_tempVar) && !_tempVar?.isNormalProduct,
+          holder_id: _tempVar?.holder_id || product.holder_id
+        }, holders);
         let timeLimit = true;
-        timeLimit = !!(0, import_utils.filterDiscountListByBookingTime)([discount], ((product == null ? void 0 : product.startDate) || (0, import_dayjs.default)()).format("YYYY-MM-DD HH:mm:ss")).length;
-        const isLimitedProduct = (limitedData.type === "product_all" && limitedData.filter !== 1 || limitedData.type === "product_all" && limitedData.filter === 1 && !limitedData.exclude_product_ids.includes(product.id) || limitedData.product_ids && limitedData.product_ids.includes(product.id)) && isHolderMatch;
-        const isAvailableProduct = flatItem.type === "main" ? !((product == null ? void 0 : product.booking_id) && ((_a2 = product == null ? void 0 : product.discount_list) == null ? void 0 : _a2.length) && ((_b = product == null ? void 0 : product.discount_list) == null ? void 0 : _b.every(
-          (discount2) => discount2.id && [
-            "good_pass",
-            "discount_card",
-            "product_discount_card"
-          ].includes(discount2.tag || discount2.type)
-        ))) : !((flatItem == null ? void 0 : flatItem.booking_id) && !!((_d = (_c = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _c.discount_list) == null ? void 0 : _d.length) && ((_f = (_e = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _e.discount_list) == null ? void 0 : _f.every((discount2) => discount2.id)));
+        timeLimit = !!(0, _utils.filterDiscountListByBookingTime)([discount], (product?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss')).length;
+        // 是符合折扣的商品
+        const isLimitedProduct = (limitedData.type === 'product_all' && limitedData.filter !== 1 || limitedData.type === 'product_all' && limitedData.filter === 1 && !limitedData.exclude_product_ids.includes(product.id) || limitedData.product_ids && limitedData.product_ids.includes(product.id)) && isHolderMatch;
+
+        // 编辑的商品 使用了优惠券不可用
+        const isAvailableProduct = flatItem.type === 'main' ? !(product?.booking_id && product?.discount_list?.length && product?.discount_list?.every(discount => discount.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type))) : !(flatItem?.booking_id && !!flatItem?.bundleItem?.discount_list?.length && flatItem?.bundleItem?.discount_list?.every(discount => discount.id));
+
+        // 套餐是否可用判断
         const isBundleAvailable = this.checkPackageSubItemUsageRules(discount, flatItem);
-        if (isAvailableProduct && isLimitedProduct && timeLimit && isBundleAvailable && ((_g = discount.config) == null ? void 0 : _g.isAvailable)) {
-          (_h = discountApplicability.get(discount.id)) == null ? void 0 : _h.push(product.id);
+
+        // 判断优惠券是否适用于该商品
+        if (isAvailableProduct && isLimitedProduct && timeLimit && isBundleAvailable && discount.config?.isAvailable) {
+          // 记录此优惠券适用的商品
+          discountApplicability.get(discount.id)?.push(product.id);
+
+          // 记录可抵扣的商品详情
           const applicableProducts = discountApplicableProducts.get(discount.id) || [];
           const discountType = discount.tag || discount.type;
-          const isGoodPass = discountType === "good_pass";
-          const num = isGoodPass || (flatItem == null ? void 0 : flatItem.type) === "main" ? 1 : product.num;
+          const isGoodPass = discountType === 'good_pass';
+
+          // 使用数量
+          const num = isGoodPass || flatItem?.type === 'main' ? 1 : product.num;
           const productData = {
             amount: product.price * num,
             type: discountType,
             tag: discountType,
             discount: {
-              discount_card_type: (_i = discount == null ? void 0 : discount.metadata) == null ? void 0 : _i.discount_card_type,
+              discount_card_type: discount?.metadata?.discount_card_type,
               fixed_amount: product.price,
-              discount_calculation_mode: (_j = discount == null ? void 0 : discount.metadata) == null ? void 0 : _j.discount_calculation_mode,
+              discount_calculation_mode: discount?.metadata?.discount_calculation_mode,
               resource_id: discount.id,
               title: discount.format_title,
               original_amount: product.price || product.origin_total,
               pre_value: discount.par_value,
-              product_id: originProduct.id,
+              product_id: originProduct.id || originProduct.product_id,
               discount_product_id: discount.product_id
             },
             metadata: {
-              num,
-              discount_rule_uncheck_flag: discount == null ? void 0 : discount.discount_rule_uncheck_flag
+              num: num,
+              discount_rule_uncheck_flag: discount?.discount_rule_uncheck_flag
             }
           };
           applicableProducts.push(productData);
@@ -640,112 +814,145 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         }
       });
     });
-    const processedFlatItemsMap = /* @__PURE__ */ new Map();
-    const applyDiscountToOptions = (options2, discount) => {
-      if (!(options2 == null ? void 0 : options2.length))
-        return { discountedOptions: options2, optionDiscountAmount: 0 };
+
+    // 🔥 用于存储扁平化商品处理结果的Map
+    const processedFlatItemsMap = new Map();
+
+    // 🔥 Option 折扣辅助函数
+    const applyDiscountToOptions = (options, discount) => {
+      if (!options?.length) return {
+        discountedOptions: options,
+        optionDiscountAmount: 0
+      };
       let optionDiscountAmount = 0;
-      const discountedOptions = options2.map((option) => {
+      const discountedOptions = options.map(option => {
+        // 折前单价：优先 price，缺失再 add_price；已写回折后价时用 _original_price（或旧字段 _original_add_price）
         const rawUnit = option._original_price ?? option._original_add_price ?? option.price ?? option.add_price;
         const baseUnitNum = Number(rawUnit ?? 0);
-        if (baseUnitNum <= 0)
-          return option;
-        const discountedPrice = (0, import_utils.getDiscountAmount)(discount, baseUnitNum, baseUnitNum);
+        if (baseUnitNum <= 0) return option;
+        const discountedPrice = (0, _utils.getDiscountAmount)(discount, baseUnitNum, baseUnitNum);
         const optQty = Number(option.num ?? option.quantity ?? 1);
-        optionDiscountAmount = new import_decimal.default(optionDiscountAmount).plus(new import_decimal.default(baseUnitNum).minus(discountedPrice).mul(optQty)).toNumber();
-        const { _original_add_price, ...rest } = option;
+        optionDiscountAmount = new _decimal.default(optionDiscountAmount).plus(new _decimal.default(baseUnitNum).minus(discountedPrice).mul(optQty)).toNumber();
+        const {
+          _original_add_price,
+          ...rest
+        } = option;
         const tmpl = rest.price ?? rest.add_price;
-        const nextPrice = typeof tmpl === "string" ? String(discountedPrice) : discountedPrice;
+        const nextPrice = typeof tmpl === 'string' ? String(discountedPrice) : discountedPrice;
         return {
           ...rest,
-          _original_price: option._original_price ?? (_original_add_price !== void 0 ? _original_add_price : rawUnit),
+          _original_price: option._original_price ?? (_original_add_price !== undefined ? _original_add_price : rawUnit),
           price: nextPrice
         };
       });
-      return { discountedOptions, optionDiscountAmount };
+      return {
+        discountedOptions,
+        optionDiscountAmount
+      };
     };
-    const restoreOptionPrices = (options2) => {
-      if (!(options2 == null ? void 0 : options2.length))
-        return options2;
-      return options2.map((option) => {
-        const orig = option._original_price !== void 0 ? option._original_price : option._original_add_price;
-        if (orig !== void 0) {
-          const { _original_price, _original_add_price, ...rest } = option;
-          return { ...rest, price: orig };
+    const restoreOptionPrices = options => {
+      if (!options?.length) return options;
+      return options.map(option => {
+        const orig = option._original_price !== undefined ? option._original_price : option._original_add_price;
+        if (orig !== undefined) {
+          const {
+            _original_price,
+            _original_add_price,
+            ...rest
+          } = option;
+          return {
+            ...rest,
+            price: orig
+          };
         }
         return option;
       });
     };
-    const getOptionTotal = (options2) => {
-      if (!(options2 == null ? void 0 : options2.length))
-        return 0;
-      return options2.reduce((sum, opt) => {
+    const getOptionTotal = options => {
+      if (!options?.length) return 0;
+      return options.reduce((sum, opt) => {
         const unit = Number(opt.price ?? opt.add_price ?? 0);
         const n = Number(opt.num ?? opt.quantity ?? 1);
-        return new import_decimal.default(sum).plus(new import_decimal.default(unit).mul(n)).toNumber();
+        return new _decimal.default(sum).plus(new _decimal.default(unit).mul(n)).toNumber();
       }, 0);
     };
+
+    // 然后再处理应用哪些优惠券，此时只考虑filteredDiscountList中的优惠券
+    // 🔥 使用扁平化后的列表进行处理
     sortedFlattenedList.forEach((flatItem, index) => {
-      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M;
+      // 获取商品数据
       let product, originProduct;
-      if (flatItem.type === "main") {
+      if (flatItem.type === 'main') {
         product = flatItem.product;
         originProduct = flatItem.originProduct;
       } else {
+        // bundle子商品
         product = {
-          startDate: (_a = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _a.startDate,
+          startDate: flatItem?.parentProduct?.startDate,
           _id: flatItem._id,
           id: flatItem.id,
           price: flatItem.price,
           quantity: flatItem.quantity,
           num: flatItem.num,
           total: flatItem.total,
-          original_price: (_b = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _b.original_price,
-          origin_total: (_c = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _c.original_price,
+          original_price: flatItem?.bundleItem?.original_price,
+          origin_total: flatItem?.bundleItem?.original_price,
           booking_id: flatItem.booking_id,
-          discount_list: ((_d = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _d.discount_list) || []
+          discount_list: flatItem?.bundleItem?.discount_list || []
         };
         originProduct = flatItem.originProduct;
       }
-      if ((product == null ? void 0 : product.booking_id) && ((_e = product.discount_list) == null ? void 0 : _e.length) && ((_f = product == null ? void 0 : product.discount_list) == null ? void 0 : _f.every(
-        (discount) => discount.id && ["good_pass", "discount_card", "product_discount_card"].includes(
-          discount.tag || discount.type
-        )
-      ))) {
-        if (flatItem.type === "main") {
+      const isPersistedProduct = product?.booking_id || originProduct?.order_detail_id || originProduct?.orderDetailId || originProduct?.booking_id;
+      const hasExistingWalletDiscount = product.discount_list?.length && product?.discount_list?.every(discount => {
+        const discountIdentity = discount.id ?? discount.discount?.resource_id;
+        const discountType = discount.tag || discount.type;
+        return Boolean(discountIdentity && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType));
+      });
+
+      // 已持久化且已有钱包券/折扣卡的商品行跳过，保留后端历史折扣结果。
+      if (isPersistedProduct && hasExistingWalletDiscount) {
+        if (flatItem.type === 'main') {
           processedProductsMap.set(product._id, [originProduct]);
         } else {
-          processedFlatItemsMap.set(flatItem._id, [
-            {
-              ...flatItem,
-              processed: true
-            }
-          ]);
+          processedFlatItemsMap.set(flatItem._id, [{
+            ...flatItem,
+            processed: true
+          }]);
         }
         return;
       }
-      const applicableDiscounts = sortedDiscountList.filter((discount) => {
-        var _a2, _b2, _c2, _d2, _e2;
-        const discountType2 = discount.tag || discount.type;
-        if (["good_pass", "discount_card", "product_discount_card"].includes(
-          discountType2
-        )) {
-          if (discount.config === void 0 || !((_a2 = discount == null ? void 0 : discount.config) == null ? void 0 : _a2.isAvailable)) {
+
+      // 找到适用于此商品的所有优惠券，仅考虑isSelected不为false的优惠券
+      const applicableDiscounts = sortedDiscountList.filter(discount => {
+        // 🔥 检查策略可用性（针对 good_pass 和折扣卡）
+        const discountType = discount.tag || discount.type;
+        const currentOriginUid = getOriginProductUid(originProduct);
+        const isReapplyEditModeDiscountForProduct = discount.isEditMode && reapplyBookingDiscountProductUids.size > 0 && currentOriginUid && reapplyBookingDiscountProductUids.has(String(currentOriginUid)) && discount.isSelected === true;
+        if (discount.isEditMode && reapplyBookingDiscountProductUids.size > 0) {
+          const uid = currentOriginUid;
+          if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
+          if (!discount.isSelected) return false;
+        }
+        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType) && !isReapplyEditModeDiscountForProduct) {
+          // 如果策略检查后没有config，说明不可用
+          if (discount.config === undefined || !discount?.config?.isAvailable) {
             return false;
           }
         }
-        if ((Number(product.price) <= 0 || !product.price) && !((_b2 = product.discount_list) == null ? void 0 : _b2.length) && (discount.tag || discount.type) === "good_pass")
-          return false;
-        if ((Number(product.price) <= 0 || !product.price) && !((_c2 = product.discount_list) == null ? void 0 : _c2.find((n) => {
-          var _a3;
-          return ((_a3 = n.discount) == null ? void 0 : _a3.resource_id) === discount.id;
-        })) && (discount.tag || discount.type) !== "good_pass")
-          return false;
+
+        // 如果商品价格为 0，其实不需要使用任何优惠券，直接 return true
+        // 商品券时主商品价格为0不可用
+        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.length && (discount.tag || discount.type) === 'good_pass') return false;
+
+        // 折扣卡商品价格为0时不可用
+        if ((Number(product.price) <= 0 || !product.price) && !product.discount_list?.find(n => n.discount?.resource_id === discount.id) && (discount.tag || discount.type) !== 'good_pass') return false;
+        // 如果优惠券已被使用，则跳过
         const targetUsedDiscounts = usedDiscounts.get(discount.id);
-        if (targetUsedDiscounts && (discount.tag || discount.type) === "good_pass")
-          return false;
-        if ((discount.tag || discount.type) === "good_pass") {
-          const maxUsagePerOrder = (_d2 = discount.config) == null ? void 0 : _d2.maxUsagePerOrder;
+        if (targetUsedDiscounts && (discount.tag || discount.type) === 'good_pass') return false;
+
+        // 🔥 检查 maxUsagePerOrder 限制：同一 product_id 的商品券使用数量不能超过配置值
+        if ((discount.tag || discount.type) === 'good_pass') {
+          const maxUsagePerOrder = discount.config?.maxUsagePerOrder;
           if (maxUsagePerOrder && maxUsagePerOrder > 0) {
             const currentUsedCount = usedProductIdCounts.get(discount.product_id) || 0;
             if (currentUsedCount >= maxUsagePerOrder) {
@@ -753,9 +960,11 @@ var RulesModule = class extends import_BaseModule.BaseModule {
             }
           }
         }
+
+        // 🔥 检查折扣卡的 applicableProductLimit 限制：折扣卡可使用的最大次数（跨商品全局）
         const discountTypeForLimit = discount.tag || discount.type;
-        if (["discount_card", "product_discount_card"].includes(discountTypeForLimit)) {
-          const applicableProductLimitConfig = ((_e2 = discount.config) == null ? void 0 : _e2.applicableProductLimit) || 0;
+        if (['discount_card', 'product_discount_card'].includes(discountTypeForLimit)) {
+          const applicableProductLimitConfig = discount.config?.applicableProductLimit || 0;
           if (applicableProductLimitConfig > 0) {
             const currentUsedLimitCount = usedDiscountCardLimitCounts.get(discount.id) || 0;
             if (currentUsedLimitCount >= applicableProductLimitConfig) {
@@ -764,31 +973,34 @@ var RulesModule = class extends import_BaseModule.BaseModule {
           }
         }
         const limitedData = discount.limited_relation_product_data;
-        const _tempVar = (flatItem == null ? void 0 : flatItem.type) === "bundle" ? flatItem == null ? void 0 : flatItem.parentProduct : flatItem == null ? void 0 : flatItem.product;
-        const isHolderMatch = this.checkHolderMatch(
-          discount,
-          {
-            isNeedHolder: isFormSubject && !(_tempVar == null ? void 0 : _tempVar.isNormalProduct),
-            holder_id: (_tempVar == null ? void 0 : _tempVar.holder_id) || product.holder_id
-          },
-          holders
-        );
-        if (!isHolderMatch)
-          return false;
+
+        // 拿到discount配置的holder信息 product信息 product.holder 不可用return false
+        const _tempVar = flatItem?.type === 'bundle' ? flatItem?.parentProduct : flatItem?.product;
+        const isHolderMatch = this.checkHolderMatch(discount, {
+          isNeedHolder: resolveIsFormSubject(_tempVar) && !_tempVar?.isNormalProduct,
+          holder_id: _tempVar?.holder_id || product.holder_id
+        }, holders);
+        // 如果 holder 不匹配，则不适用
+        if (!isHolderMatch) return false;
         let timeLimit = true;
-        timeLimit = !!(0, import_utils.filterDiscountListByBookingTime)([discount], (product.startDate || (0, import_dayjs.default)()).format("YYYY-MM-DD HH:mm:ss")).length;
+        timeLimit = !!(0, _utils.filterDiscountListByBookingTime)([discount], (product.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss')).length;
         if (!timeLimit) {
           return false;
         }
-        if (limitedData.type === "product_all") {
+
+        // 判断优惠券是否适用于该商品
+        if (limitedData.type === 'product_all') {
           if (!isProductIncludedByLimitedData(limitedData, product.id)) {
             return false;
           }
+
+          // 检查 package_sub_item_usage_rules
           if (!this.checkPackageSubItemUsageRules(discount, flatItem)) {
             return false;
           }
           return true;
         } else if (limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
+          // 检查 package_sub_item_usage_rules
           if (!this.checkPackageSubItemUsageRules(discount, flatItem)) {
             return false;
           }
@@ -796,379 +1008,372 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         }
         return false;
       });
-      const selectedDiscountCard = applicableDiscounts.find(
-        (n) => n.isScan && n.isSelected && (n.tag || n.type) !== "good_pass"
-      );
+
+      // 选择第一个适用的优惠券（已经按过期时间排序）
+      // 如果有 isScan 且 isSelected 的折扣卡，则优先选中，否则再选择第一个
+      // 用于处理：先手动扫描了一张折扣卡，扫描完以后带入客户信息，但是之前那张折扣卡不是最优惠的情况
+      const selectedDiscountCard = applicableDiscounts.find(n => n.isScan && n.isSelected && (n.tag || n.type) !== 'good_pass');
       const selectedDiscount = selectedDiscountCard || applicableDiscounts[0];
+
+      // 如果是手动折扣，则不适用优惠券
       let isManualDiscount = false;
-      if (flatItem.type === "main") {
-        isManualDiscount = typeof product.isManualDiscount === "boolean" ? product.isManualDiscount : product.total != product.origin_total && (product.bundle || []).every(
-          (item) => {
-            var _a2;
-            return !((_a2 = item.discount_list || []) == null ? void 0 : _a2.length);
-          }
-        ) && (!((_g = product.discount_list) == null ? void 0 : _g.length) || ((_i = (_h = product == null ? void 0 : product.discount_list) == null ? void 0 : _h.every) == null ? void 0 : _i.call(
-          _h,
-          (item) => item.type === "product"
-        )));
+      if (flatItem.type === 'main') {
+        // 主商品：判断自身是否手动折扣
+        isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.discount_list?.some(item => item.type === 'product') || product.total != product.origin_total && (product.bundle || []).every(item => !(item.discount_list || [])?.length) && (!product.discount_list?.length || product?.discount_list?.every?.(item => item.type === 'product'));
         if (product.inPromotion) {
           isManualDiscount = false;
         }
       } else {
+        // bundle子商品：判断父主商品是否手动折扣
         const parentProduct = flatItem.parentProduct;
         if (parentProduct) {
-          isManualDiscount = typeof parentProduct.isManualDiscount === "boolean" ? parentProduct.isManualDiscount : parentProduct.total != parentProduct.origin_total && (parentProduct.bundle || []).every(
-            (item) => {
-              var _a2;
-              return !((_a2 = item.discount_list || []) == null ? void 0 : _a2.length);
-            }
-          ) && (!((_j = parentProduct.discount_list) == null ? void 0 : _j.length) || ((_l = (_k = parentProduct == null ? void 0 : parentProduct.discount_list) == null ? void 0 : _k.every) == null ? void 0 : _l.call(
-            _k,
-            (item) => item.type === "product"
-          )));
+          isManualDiscount = typeof parentProduct.isManualDiscount === 'boolean' ? parentProduct.isManualDiscount : parentProduct.discount_list?.some(item => item.type === 'product') || parentProduct.total != parentProduct.origin_total && (parentProduct.bundle || []).every(item => !(item.discount_list || [])?.length) && (!parentProduct.discount_list?.length || parentProduct?.discount_list?.every?.(item => item.type === 'product'));
         }
       }
-      if (options == null ? void 0 : options.discountId) {
-        if (flatItem.type === "main" && ((_m = product.discount_list) == null ? void 0 : _m.some(
-          (item) => {
-            var _a2;
-            return ((_a2 = item.discount) == null ? void 0 : _a2.resource_id) === options.discountId;
-          }
-        ))) {
+
+      // 勾选时覆盖手动折扣
+      if (options?.discountId) {
+        // 主商品：检查自己的 discount_list
+        if (flatItem.type === 'main' && product.discount_list?.some(item => item.discount?.resource_id === options.discountId)) {
           isManualDiscount = false;
         }
-        if (flatItem.type === "bundle") {
-          if (((_n = product.discount_list) == null ? void 0 : _n.some(
-            (item) => {
-              var _a2;
-              return ((_a2 = item.discount) == null ? void 0 : _a2.resource_id) === options.discountId;
-            }
-          )) || ((_p = (_o = flatItem.parentProduct) == null ? void 0 : _o.discount_list) == null ? void 0 : _p.some(
-            (item) => {
-              var _a2;
-              return ((_a2 = item.discount) == null ? void 0 : _a2.resource_id) === options.discountId;
-            }
-          ))) {
+        // bundle子商品：检查自己的 discount_list 或父主商品的 discount_list
+        if (flatItem.type === 'bundle') {
+          if (product.discount_list?.some(item => item.discount?.resource_id === options.discountId) || flatItem.parentProduct?.discount_list?.some(item => item.discount?.resource_id === options.discountId)) {
             isManualDiscount = false;
           }
         }
       }
-      if (options == null ? void 0 : options.selectedList) {
-        if (flatItem.type === "main" && ((_q = product.discount_list) == null ? void 0 : _q.some(
-          (item) => {
-            var _a2;
-            return (_a2 = options == null ? void 0 : options.selectedList) == null ? void 0 : _a2.some(
-              (n) => {
-                var _a3;
-                return n.discountId === ((_a3 = item.discount) == null ? void 0 : _a3.resource_id);
-              }
-            );
-          }
-        ))) {
+      if (options?.selectedList) {
+        // 主商品：检查自己的 discount_list
+        if (flatItem.type === 'main' && product.discount_list?.some(item => options?.selectedList?.some(n => n.discountId === item.discount?.resource_id))) {
           isManualDiscount = false;
         }
-        if (flatItem.type === "bundle") {
-          if (((_r = product.discount_list) == null ? void 0 : _r.some(
-            (item) => {
-              var _a2;
-              return (_a2 = options == null ? void 0 : options.selectedList) == null ? void 0 : _a2.some(
-                (n) => {
-                  var _a3;
-                  return n.discountId === ((_a3 = item.discount) == null ? void 0 : _a3.resource_id);
-                }
-              );
-            }
-          )) || ((_t = (_s = flatItem.parentProduct) == null ? void 0 : _s.discount_list) == null ? void 0 : _t.some(
-            (item) => {
-              var _a2;
-              return (_a2 = options == null ? void 0 : options.selectedList) == null ? void 0 : _a2.some(
-                (n) => {
-                  var _a3;
-                  return n.discountId === ((_a3 = item.discount) == null ? void 0 : _a3.resource_id);
-                }
-              );
-            }
-          ))) {
+        // bundle子商品：检查自己的 discount_list 或父主商品的 discount_list
+        if (flatItem.type === 'bundle') {
+          if (product.discount_list?.some(item => options?.selectedList?.some(n => n.discountId === item.discount?.resource_id)) || flatItem.parentProduct?.discount_list?.some(item => options?.selectedList?.some(n => n.discountId === item.discount?.resource_id))) {
             isManualDiscount = false;
           }
         }
       }
-      if (applicableDiscounts.length === 0 || isManualDiscount || (0, import_lodash_es.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
-        if (flatItem.type === "main") {
+
+      // 如果没有适用的优惠券，或者手动折扣，则不适用优惠券
+      if (applicableDiscounts.length === 0 || isManualDiscount || (0, _lodashEs.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
+        if (flatItem.type === 'main') {
+          // 主商品：保持原有逻辑，还原 option 价格
           const restoredOptions = restoreOptionPrices(product.options);
           if (product.isClient) {
-            processedProductsMap.set(product._id, [
-              this.hooks.setProduct(originProduct, {
-                ...isManualDiscount ? {} : {
-                  origin_total: (0, import_utils2.getProductOriginTotalPrice)({
-                    product: {
-                      original_price: product.original_price
-                    },
-                    bundle: product.bundle,
-                    options: restoredOptions
-                  }),
-                  variant: originProduct._productInit.variant,
-                  original_price: originProduct._productInit.original_price,
-                  total: (0, import_utils2.getProductTotalPrice)({
-                    product: {
-                      price: product.price
-                    },
-                    bundle: product.bundle,
-                    options: restoredOptions
-                  }),
-                  price: product.price,
+            processedProductsMap.set(product._id, [this.hooks.setProduct(originProduct, {
+              ...(isManualDiscount ? {} : {
+                origin_total: (0, _utils2.getProductOriginTotalPrice)({
+                  product: {
+                    original_price: product.original_price
+                  },
+                  bundle: product.bundle,
                   options: restoredOptions
-                },
-                discount_list: this.filterDiscountListByType(product.discount_list, "promotion")
-              })
-            ]);
+                }),
+                variant: originProduct._productInit.variant,
+                original_price: originProduct._productInit.original_price,
+                total: (0, _utils2.getProductTotalPrice)({
+                  product: {
+                    price: product.price
+                  },
+                  bundle: product.bundle,
+                  options: restoredOptions
+                }),
+                price: product.price,
+                options: restoredOptions
+              }),
+              discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.discount_list) : this.filterDiscountListByType(product.discount_list, 'promotion')
+            })]);
           } else {
-            let total = product.inPromotion ? ((_u = product == null ? void 0 : product._promotion) == null ? void 0 : _u.finalPrice) ?? product.origin_total ?? product.total : product.origin_total ?? product.total;
+            let total = product.inPromotion ? product?._promotion?.finalPrice ?? product.origin_total ?? product.total : product.origin_total ?? product.total;
             let main_product_selling_price = product.price ?? product.main_product_selling_price;
-            if ((product.discount_list || []).some((item) => item.type === "promotion") || (0, import_lodash_es.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
+            if ((product.discount_list || []).some(item => item.type === 'promotion') || (0, _lodashEs.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
               total = product.total ?? product.origin_total;
               main_product_selling_price = product.main_product_selling_price ?? main_product_selling_price;
             }
-            processedProductsMap.set(product._id, [
-              this.hooks.setProduct(originProduct, {
-                ...isManualDiscount ? {
-                  price: product.price
-                } : {
-                  _id: product._id.split("___")[0] + "___" + index,
-                  total,
-                  original_price: product.original_price,
-                  price: product.price,
-                  main_product_selling_price,
-                  options: restoredOptions
-                },
-                discount_list: this.filterDiscountListByType(product.discount_list, "promotion")
-              })
-            ]);
+            processedProductsMap.set(product._id, [this.hooks.setProduct(originProduct, {
+              ...(isManualDiscount ? {
+                price: product.price
+              } : {
+                _id: product._id.split('___')[0] + '___' + index,
+                total,
+                price: product.price,
+                main_product_selling_price,
+                options: restoredOptions
+              }),
+              discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.discount_list) : this.filterDiscountListByType(product.discount_list, 'promotion')
+            })]);
           }
         } else {
+          // bundle子商品：保存到扁平化Map
           processedFlatItemsMap.set(flatItem._id, [{
             ...flatItem,
-            discount_list: this.filterDiscountListByType(((_v = flatItem.bundleItem) == null ? void 0 : _v.discount_list) || [], "promotion"),
+            discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(flatItem.bundleItem?.discount_list || []) : this.filterDiscountListByType(flatItem.bundleItem?.discount_list || [], 'promotion'),
             price: isManualDiscount ? flatItem.bundleItem.price : flatItem.bundleItem.original_price,
             processed: true
           }]);
         }
         return;
       }
-      if (applicableDiscounts.length && product.booking_id && typeof selectedDiscount.isManualSelect === "undefined" && !(options == null ? void 0 : options.scan) && !isEditModeAddNewProduct) {
+      const shouldReapplyBookingDiscountForProduct = shouldReapplyBookingDiscount(originProduct, selectedDiscount);
+      if (applicableDiscounts.length && product.booking_id && typeof selectedDiscount.isManualSelect === 'undefined' && !options?.scan && !isEditModeAddNewProduct && !shouldReapplyBookingDiscountForProduct) {
         return;
       }
+
+      // 是否需要拆分（商品券需要拆分，折扣卡在 applicableProductLimit > 0 时也需要拆分）
       const discountType = selectedDiscount.tag || selectedDiscount.type;
-      const isGoodPass = discountType === "good_pass";
-      const isDiscountCard = ["discount_card", "product_discount_card"].includes(discountType);
-      const applicableProductLimit = ((_w = selectedDiscount.config) == null ? void 0 : _w.applicableProductLimit) || 0;
+      const isGoodPass = discountType === 'good_pass';
+      const isDiscountCard = ['discount_card', 'product_discount_card'].includes(discountType);
+      const applicableProductLimit = selectedDiscount.config?.applicableProductLimit || 0;
+
+      // 商品券始终需要拆分，折扣卡在 applicableProductLimit > 0 时需要拆分
       const isNeedSplit = isGoodPass || isDiscountCard && applicableProductLimit > 0;
+
+      // 需要拆分出来的数量
       const totalQuantity = product.quantity || product.num || 1;
-      const availableGoodPassCount = applicableDiscounts.filter(
-        (item) => (item.tag || item.type) === "good_pass"
-      ).length;
+      const availableGoodPassCount = applicableDiscounts.filter(item => (item.tag || item.type) === 'good_pass').length;
+
+      // 🔥 计算最大使用次数限制
       let maxUsageLimit;
       if (isGoodPass) {
+        // 商品券：使用 maxUsagePerOrder 限制
         maxUsageLimit = availableGoodPassCount;
         if (selectedDiscount.config && selectedDiscount.config.maxUsagePerOrder) {
-          maxUsageLimit = Math.min(
-            availableGoodPassCount,
-            selectedDiscount.config.maxUsagePerOrder
-          );
+          maxUsageLimit = Math.min(availableGoodPassCount, selectedDiscount.config.maxUsagePerOrder);
         }
       } else if (isDiscountCard && applicableProductLimit > 0) {
+        // 折扣卡：使用 applicableProductLimit 限制（一个商品使用一次折扣卡算1次）
+        // 需要减去已使用次数（跨商品全局计数）
         const usedLimitCount = usedDiscountCardLimitCounts.get(selectedDiscount.id) || 0;
         maxUsageLimit = Math.max(0, applicableProductLimit - usedLimitCount);
       } else {
+        // 其他情况不拆分
         maxUsageLimit = 1;
       }
       const splitCount = isNeedSplit ? Math.min(product.quantity || product.num || 1, maxUsageLimit) : 1;
       const arr = [];
-      if (flatItem.type === "main") {
+
+      // 🔥 主商品和bundle子商品分别处理
+      if (flatItem.type === 'main') {
+        // 主商品：保持原有逻辑
         if (splitCount < totalQuantity && isNeedSplit) {
           let total = product.origin_total ?? product.total;
-          if ((product.discount_list || []).some((item) => item.type === "promotion")) {
+          if ((product.discount_list || []).some(item => item.type === 'promotion')) {
             total = product.total ?? product.origin_total;
           }
-          arr.push(
-            this.hooks.setProduct(originProduct, {
-              discount_list: this.filterDiscountListByType(product.discount_list, "promotion"),
-              quantity: totalQuantity - splitCount,
-              _id: product._id.split("___")[0],
-              total
-            })
-          );
+          arr.push(this.hooks.setProduct(originProduct, {
+            discount_list: this.filterDiscountListByType(product.discount_list, 'promotion'),
+            quantity: totalQuantity - splitCount,
+            _id: product._id.split('___')[0],
+            total
+          }));
         }
         for (let i = 0; i < splitCount; i++) {
+          // 商品券：每个拆分商品使用不同的商品券（从 applicableDiscounts 按索引取）
+          // 折扣卡：所有拆分商品使用同一张折扣卡（selectedDiscountCard 或 applicableDiscounts[0]）
           const currentSelectedDiscount = isGoodPass ? selectedDiscountCard || applicableDiscounts[i] : selectedDiscountCard || applicableDiscounts[0];
+          // 标记优惠券为已使用
           usedDiscounts.set(currentSelectedDiscount.id, true);
-          if ((currentSelectedDiscount.tag || currentSelectedDiscount.type) === "good_pass") {
+          // 🔥 更新 product_id 使用计数
+          if ((currentSelectedDiscount.tag || currentSelectedDiscount.type) === 'good_pass') {
             const currentCount = usedProductIdCounts.get(currentSelectedDiscount.product_id) || 0;
             usedProductIdCounts.set(currentSelectedDiscount.product_id, currentCount + 1);
           }
+          // 🔥 更新折扣卡 applicableProductLimit 使用计数（跨商品全局）
           const currentDiscountTypeForCount = currentSelectedDiscount.tag || currentSelectedDiscount.type;
-          if (["discount_card", "product_discount_card"].includes(currentDiscountTypeForCount)) {
+          if (['discount_card', 'product_discount_card'].includes(currentDiscountTypeForCount)) {
             const currentLimitCount = usedDiscountCardLimitCounts.get(currentSelectedDiscount.id) || 0;
             usedDiscountCardLimitCounts.set(currentSelectedDiscount.id, currentLimitCount + 1);
           }
+
+          // 记录实际应用了优惠券的商品信息
           const appliedProducts = appliedDiscountProducts.get(currentSelectedDiscount.id) || [];
+
+          // 优先从 origin_total拿，可能会拿不到（比如用户端预约在没有配置 original_price 的情况下）
           let productOriginTotal = product.origin_total || product.total || 0;
-          if (this.filterDiscountListByType(product.discount_list, "promotion").length && product.origin_total) {
+          // 如果当前 product 有 discount_list，则先从 origin_total 拿
+          if (this.filterDiscountListByType(product.discount_list, 'promotion').length && product.origin_total) {
             productOriginTotal = product.origin_total;
           }
-          if (Number(((_x = originProduct == null ? void 0 : originProduct._productInit) == null ? void 0 : _x.original_price) || 0) > 0 && product.origin_total && product.total && product.origin_total !== product.total) {
+          // 如果originProduct?._productInit?.original_price为 0，product.origin_total可能为空，此时取 product.total
+          if (Number(originProduct?._productInit?.original_price || 0) > 0 && product.origin_total && product.total && product.origin_total !== product.total) {
             productOriginTotal = product.total;
           }
-          const isOrderLevel = (0, import_utils3.isOrderLevelFixedAmountDiscount)(selectedDiscount);
+
+          // 计算使用折扣卡/商品券以后，单个商品的总 total
+          // 🔥 检查是否是 order_level 固定金额折扣卡
+          const isOrderLevel = (0, _utils.isOrderLevelFixedAmountDiscount)(selectedDiscount);
           const orderLevelAllocation = isOrderLevel ? orderLevelDiscountAllocations.get(selectedDiscount.id) : null;
-          const productAllocation = orderLevelAllocation == null ? void 0 : orderLevelAllocation.get(flatItem._id);
-          const isDeductOptionPrice = !!((_y = selectedDiscount.config) == null ? void 0 : _y.deductOptionPrice);
+          const productAllocation = orderLevelAllocation?.get(flatItem._id);
+          const isDeductOptionPrice = !!selectedDiscount.config?.deductOptionPrice;
+
+          // 主商品折后价（不含 option）；勿与 option 合计混在同一变量，否则 main_product_selling_price 错误
           let mainProductSellingPrice;
           let amount;
           let productDiscountDifference;
           let discountedOptions = product.options;
           let optionDiscountAmount = 0;
+          let reapplyDiscountPercent;
           if (isOrderLevel && productAllocation) {
+            // order_level：使用预计算的分摊金额
             amount = productAllocation.discountAmount;
             productDiscountDifference = productAllocation.difference;
-            mainProductSellingPrice = Math.max(new import_decimal.default(product.price).minus(amount).toNumber(), 0);
+            mainProductSellingPrice = Math.max(new _decimal.default(product.price).minus(amount).toNumber(), 0);
+          } else if (resolveReapplyEditModeDiscountPercent(originProduct, selectedDiscount) !== undefined) {
+            // Change time 重套编辑态折扣卡时，历史 par_value 不是运行时折扣口径，优先使用后端快照里的 percent。
+            const percent = resolveReapplyEditModeDiscountPercent(originProduct, selectedDiscount);
+            reapplyDiscountPercent = new _decimal.default(percent).toFixed(2);
+            mainProductSellingPrice = new _decimal.default(product.price || 0).mul(new _decimal.default(100).minus(percent)).div(100).toDecimalPlaces(2).toNumber();
+            amount = new _decimal.default(product.price).minus(mainProductSellingPrice).toNumber();
           } else {
-            mainProductSellingPrice = (0, import_utils.getDiscountAmount)(
-              currentSelectedDiscount,
-              product.price,
-              product.price
-            );
-            amount = new import_decimal.default(product.price).minus(new import_decimal.default(mainProductSellingPrice)).toNumber();
+            // item_level 或其他类型：使用原有逻辑
+            mainProductSellingPrice = (0, _utils.getDiscountAmount)(selectedDiscount, product.price, product.price);
+            amount = new _decimal.default(product.price).minus(new _decimal.default(mainProductSellingPrice)).toNumber();
           }
-          if (isDeductOptionPrice && ((_z = product.options) == null ? void 0 : _z.length)) {
-            const optionResult = applyDiscountToOptions(
-              product.options,
-              currentSelectedDiscount
-            );
+          if (isDeductOptionPrice && product.options?.length) {
+            const optionResult = applyDiscountToOptions(product.options, selectedDiscount);
             discountedOptions = optionResult.discountedOptions;
             optionDiscountAmount = optionResult.optionDiscountAmount;
           }
-          const optionsForLineTotal = isDeductOptionPrice && ((_A = product.options) == null ? void 0 : _A.length) ? discountedOptions : product.options;
+
+          // total = 主商品折后 + option 行合计；开启 option 抵扣时必须用 discountedOptions，不能用未折扣的 product.options 再算一遍
+          const optionsForLineTotal = isDeductOptionPrice && product.options?.length ? discountedOptions : product.options;
           const optionsLineTotal = getOptionTotal(optionsForLineTotal || []);
-          const total = new import_decimal.default(mainProductSellingPrice).plus(optionsLineTotal).toNumber();
+          const total = new _decimal.default(mainProductSellingPrice).plus(optionsLineTotal).toNumber();
+
+          // discount_list.amount / fixed_amount：行级总优惠 = 主商品优惠 + option 优惠（与 total 变化一致）
           const mainProductDiscountAmount = amount;
-          const lineDiscountAmount = new import_decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
-          const currentDiscountType = currentSelectedDiscount.tag === "product_discount_card" ? "discount_card" : currentSelectedDiscount.tag;
-          const discountType2 = selectedDiscount.tag || selectedDiscount.type;
-          const currentIsGoodPass = currentDiscountType === "good_pass";
+          const lineDiscountAmount = new _decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
+          const discountType = selectedDiscount.tag || selectedDiscount.type;
+          const currentIsGoodPass = discountType === 'good_pass';
           const discountDetail = {
             amount: lineDiscountAmount,
-            type: selectedDiscount.tag === "product_discount_card" ? "discount_card" : discountType2,
+            type: selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : discountType,
             discount: {
-              discount_card_type: (_B = selectedDiscount == null ? void 0 : selectedDiscount.metadata) == null ? void 0 : _B.discount_card_type,
+              discount_card_type: selectedDiscount?.metadata?.discount_card_type,
               fixed_amount: lineDiscountAmount,
-              discount_calculation_mode: (_C = selectedDiscount == null ? void 0 : selectedDiscount.metadata) == null ? void 0 : _C.discount_calculation_mode,
+              discount_calculation_mode: selectedDiscount?.metadata?.discount_calculation_mode,
               resource_id: selectedDiscount.id,
               title: selectedDiscount.format_title,
               original_amount: product.price,
-              product_id: originProduct.id,
-              percent: currentSelectedDiscount.par_value,
-              discount_product_id: currentSelectedDiscount.product_id
+              product_id: originProduct.id || originProduct.product_id,
+              percent: reapplyDiscountPercent ?? selectedDiscount.par_value,
+              discount_product_id: selectedDiscount.product_id
             },
             // 前端使用的num数量，为了计算优惠金额（拆分时为1）
             _num: isNeedSplit ? 1 : product.num,
-            config: currentSelectedDiscount == null ? void 0 : currentSelectedDiscount.config,
+            config: currentSelectedDiscount?.config,
             metadata: {
               num: 1,
-              discount_rule_uncheck_flag: selectedDiscount == null ? void 0 : selectedDiscount.discount_rule_uncheck_flag,
+              discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
               // 🔥 order_level 分摊差值
-              ...productDiscountDifference !== void 0 && { product_discount_difference: productDiscountDifference },
+              ...(productDiscountDifference !== undefined && {
+                product_discount_difference: productDiscountDifference
+              }),
               /** 仅主商品上的优惠金额（不含 option） */
               mainProductDiscountAmount,
               optionDiscountAmount
             }
           };
           appliedProducts.push(discountDetail);
-          appliedDiscountProducts.set(currentSelectedDiscount.id, appliedProducts);
+          appliedDiscountProducts.set(selectedDiscount.id, appliedProducts);
+
+          // 记录应用了优惠券的商品
+          // 后续更新价格改为 getProductTotalPrice getProductOriginTotalPrice逻辑
           if (product.isClient) {
-            arr.push(
-              this.hooks.setProduct(originProduct, {
-                discount_list: [discountDetail],
-                // good_pass：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
-                price: currentIsGoodPass ? mainProductSellingPrice : product.price,
-                quantity: isNeedSplit ? 1 : product.quantity,
-                origin_total: (0, import_utils2.getProductOriginTotalPrice)({
-                  product: {
-                    original_price: product.original_price
-                  },
-                  bundle: product.bundle,
-                  options: restoreOptionPrices(product.options)
-                }),
-                variant: originProduct._productInit.variant,
-                original_price: new import_decimal.default(product.price || 0).toNumber(),
-                total,
-                options: discountedOptions
-              })
-            );
+            arr.push(this.hooks.setProduct(originProduct, {
+              discount_list: [discountDetail],
+              // good_pass：主商品价以折后价为准；勿用 product.price - amount（amount 含 option 优惠时会算错）
+              price: isGoodPass ? mainProductSellingPrice : product.price,
+              quantity: isNeedSplit ? 1 : product.quantity,
+              origin_total: (0, _utils2.getProductOriginTotalPrice)({
+                product: {
+                  original_price: product.original_price
+                },
+                bundle: product.bundle,
+                options: restoreOptionPrices(product.options)
+              }),
+              variant: originProduct._productInit.variant,
+              original_price: new _decimal.default(product.price || 0).toNumber(),
+              total: total,
+              options: discountedOptions
+            }));
           } else {
-            arr.push(
-              this.hooks.setProduct(originProduct, {
-                discount_list: this.filterDiscountListByType(product.discount_list, "promotion").concat([discountDetail]),
-                _id: product._id.split("___")[0] + "___" + currentSelectedDiscount.id + "_" + i + "_" + index,
-                price: currentIsGoodPass ? 0 : product.price,
-                quantity: isNeedSplit ? 1 : product.quantity,
-                total,
-                origin_total: productOriginTotal,
-                main_product_selling_price: mainProductSellingPrice,
-                options: discountedOptions
-              })
-            );
+            arr.push(this.hooks.setProduct(originProduct, {
+              discount_list: this.filterDiscountListByType(product.discount_list, 'promotion').concat([discountDetail]),
+              _id: product._id.split('___')[0] + '___' + currentSelectedDiscount.id + '_' + i + '_' + index,
+              price: currentIsGoodPass ? 0 : product.price,
+              quantity: isNeedSplit ? 1 : product.quantity,
+              total: total,
+              origin_total: productOriginTotal,
+              main_product_selling_price: mainProductSellingPrice,
+              options: discountedOptions
+            }));
           }
         }
         processedProductsMap.set(product._id, arr);
       } else {
+        // 🔥 bundle子商品：支持拆分（商品券和折扣卡在 applicableProductLimit > 0 时都需要拆分）
         const processedItems = [];
         if (isNeedSplit) {
+          // 需要拆分数量（商品券或折扣卡有 applicableProductLimit 限制）
           const discountNum = splitCount;
           const normalNum = totalQuantity - discountNum;
+
+          // 生成有折扣的商品（每个拆分商品 num: 1）
           for (let i = 0; i < discountNum; i++) {
+            // 商品券：每个拆分商品使用不同的商品券
+            // 折扣卡：所有拆分商品使用同一张折扣卡
             const currentBundleDiscount = isGoodPass ? selectedDiscountCard || applicableDiscounts[i] : selectedDiscountCard || applicableDiscounts[0];
             usedDiscounts.set(currentBundleDiscount.id, true);
-            if ((currentBundleDiscount.tag || currentBundleDiscount.type) === "good_pass") {
+            // 🔥 更新 product_id 使用计数
+            if ((currentBundleDiscount.tag || currentBundleDiscount.type) === 'good_pass') {
               const currentCount = usedProductIdCounts.get(currentBundleDiscount.product_id) || 0;
               usedProductIdCounts.set(currentBundleDiscount.product_id, currentCount + 1);
             }
+            // 🔥 更新折扣卡 applicableProductLimit 使用计数（跨商品全局）
             const bundleDiscountTypeForCount = currentBundleDiscount.tag || currentBundleDiscount.type;
-            if (["discount_card", "product_discount_card"].includes(bundleDiscountTypeForCount)) {
+            if (['discount_card', 'product_discount_card'].includes(bundleDiscountTypeForCount)) {
               const currentBundleLimitCount = usedDiscountCardLimitCounts.get(currentBundleDiscount.id) || 0;
               usedDiscountCardLimitCounts.set(currentBundleDiscount.id, currentBundleLimitCount + 1);
             }
+
+            // 🔥 生成唯一的 _id
             const uniqueId = `${flatItem._id}_split_${i}`;
-            const discountedPrice = (0, import_utils.getDiscountAmount)(
-              currentBundleDiscount,
-              product.origin_total,
-              product.origin_total
-            );
-            const bundleDiscountAmount = new import_decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
-            const bundleDiscountType = currentBundleDiscount.tag === "product_discount_card" ? "discount_card" : currentBundleDiscount.tag;
+
+            // 计算折扣后的价格（使用 getDiscountAmount，内部已处理 maxDeductionAmount）
+            const discountedPrice = (0, _utils.getDiscountAmount)(currentBundleDiscount, product.origin_total, product.origin_total);
+            const bundleDiscountAmount = new _decimal.default(product.origin_total || 0).minus(discountedPrice).toNumber();
+            debugger;
+
+            // 确定折扣类型
+            const bundleDiscountType = currentBundleDiscount.tag === 'product_discount_card' ? 'discount_card' : currentBundleDiscount.tag;
             const discountDetail = {
               amount: bundleDiscountAmount,
               type: bundleDiscountType,
               discount: {
-                discount_card_type: (_D = currentBundleDiscount == null ? void 0 : currentBundleDiscount.metadata) == null ? void 0 : _D.discount_card_type,
-                discount_calculation_mode: (_E = currentBundleDiscount == null ? void 0 : currentBundleDiscount.metadata) == null ? void 0 : _E.discount_calculation_mode,
+                discount_card_type: currentBundleDiscount?.metadata?.discount_card_type,
+                discount_calculation_mode: currentBundleDiscount?.metadata?.discount_calculation_mode,
                 fixed_amount: bundleDiscountAmount,
                 resource_id: currentBundleDiscount.id,
                 title: currentBundleDiscount.format_title,
                 original_amount: product.origin_total,
-                product_id: product.id,
-                percent: currentBundleDiscount.par_value,
-                discount_product_id: currentBundleDiscount.product_id
+                product_id: product.id || product.product_id,
+                discount_product_id: selectedDiscount.product_id
               },
               metadata: {
                 // 🔥 使用拆分后的唯一 _id
                 custom_product_bundle_map_id: uniqueId,
-                discount_rule_uncheck_flag: selectedDiscount == null ? void 0 : selectedDiscount.discount_rule_uncheck_flag,
+                discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
                 num: 1
               },
               _num: 1,
-              config: currentBundleDiscount == null ? void 0 : currentBundleDiscount.config
+              config: currentBundleDiscount?.config
             };
+
+            // 记录实际应用的折扣
             const appliedProducts = appliedDiscountProducts.get(currentBundleDiscount.id) || [];
             appliedProducts.push(discountDetail);
             appliedDiscountProducts.set(currentBundleDiscount.id, appliedProducts);
@@ -1186,28 +1391,29 @@ var RulesModule = class extends import_BaseModule.BaseModule {
               _discountId: currentBundleDiscount.id
             });
           }
+
+          // 🔥 对拆分后的剩余商品继续匹配其他可用折扣（而不是等到下次执行才应用）
           let remainingNum = normalNum;
           let continueSplitIndex = discountNum;
           while (remainingNum > 0) {
-            const nextApplicableDiscounts = sortedDiscountList.filter((nextDiscount) => {
-              var _a2, _b2, _c2, _d2;
+            // 重新查找适用于剩余商品的可用折扣（已使用的会被自动过滤掉）
+            const nextApplicableDiscounts = sortedDiscountList.filter(nextDiscount => {
               const nextDiscountType = nextDiscount.tag || nextDiscount.type;
-              if (["good_pass", "discount_card", "product_discount_card"].includes(nextDiscountType)) {
-                if (nextDiscount.config === void 0 || !((_a2 = nextDiscount == null ? void 0 : nextDiscount.config) == null ? void 0 : _a2.isAvailable)) {
+              // 检查策略可用性
+              if (['good_pass', 'discount_card', 'product_discount_card'].includes(nextDiscountType)) {
+                if (nextDiscount.config === undefined || !nextDiscount?.config?.isAvailable) {
                   return false;
                 }
               }
-              if ((Number(product.total) <= 0 || !product.total) && !((_b2 = product.discount_list) == null ? void 0 : _b2.find(
-                (n) => {
-                  var _a3;
-                  return ((_a3 = n.discount) == null ? void 0 : _a3.resource_id) === nextDiscount.id;
-                }
-              )) && nextDiscountType !== "good_pass")
-                return false;
-              if (usedDiscounts.get(nextDiscount.id) && nextDiscountType === "good_pass")
-                return false;
-              if (nextDiscountType === "good_pass") {
-                const maxUsagePerOrder = (_c2 = nextDiscount.config) == null ? void 0 : _c2.maxUsagePerOrder;
+              // 折扣卡时总价为0时不可用
+              if ((Number(product.total) <= 0 || !product.total) && !product.discount_list?.find(n => n.discount?.resource_id === nextDiscount.id) && nextDiscountType !== 'good_pass') return false;
+
+              // 商品券已被使用则跳过
+              if (usedDiscounts.get(nextDiscount.id) && nextDiscountType === 'good_pass') return false;
+
+              // 检查 maxUsagePerOrder 限制
+              if (nextDiscountType === 'good_pass') {
+                const maxUsagePerOrder = nextDiscount.config?.maxUsagePerOrder;
                 if (maxUsagePerOrder && maxUsagePerOrder > 0) {
                   const currentUsedCount = usedProductIdCounts.get(nextDiscount.product_id) || 0;
                   if (currentUsedCount >= maxUsagePerOrder) {
@@ -1215,8 +1421,10 @@ var RulesModule = class extends import_BaseModule.BaseModule {
                   }
                 }
               }
-              if (["discount_card", "product_discount_card"].includes(nextDiscountType)) {
-                const limitConfig = ((_d2 = nextDiscount.config) == null ? void 0 : _d2.applicableProductLimit) || 0;
+
+              // 检查折扣卡的 applicableProductLimit 限制
+              if (['discount_card', 'product_discount_card'].includes(nextDiscountType)) {
+                const limitConfig = nextDiscount.config?.applicableProductLimit || 0;
                 if (limitConfig > 0) {
                   const currentUsedLimitCount = usedDiscountCardLimitCounts.get(nextDiscount.id) || 0;
                   if (currentUsedLimitCount >= limitConfig) {
@@ -1225,7 +1433,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
                 }
               }
               const limitedData = nextDiscount.limited_relation_product_data;
-              if (limitedData.type === "product_all") {
+              if (limitedData.type === 'product_all') {
                 if (limitedData.filter === 1 && limitedData.exclude_product_ids.includes(product.id)) {
                   return false;
                 }
@@ -1241,6 +1449,8 @@ var RulesModule = class extends import_BaseModule.BaseModule {
               }
               return false;
             });
+
+            // 没有更多可用折扣，剩余商品无折扣存储
             if (nextApplicableDiscounts.length === 0) {
               processedItems.push({
                 ...flatItem,
@@ -1252,37 +1462,40 @@ var RulesModule = class extends import_BaseModule.BaseModule {
               });
               break;
             }
-            const nextSelectedDiscountCard = nextApplicableDiscounts.find(
-              (n) => n.isScan && n.isSelected && (n.tag || n.type) !== "good_pass"
-            );
+
+            // 选择最优折扣
+            const nextSelectedDiscountCard = nextApplicableDiscounts.find(n => n.isScan && n.isSelected && (n.tag || n.type) !== 'good_pass');
             const nextSelectedDiscount = nextSelectedDiscountCard || nextApplicableDiscounts[0];
+
+            // 判断新折扣是否需要拆分
             const nextDiscType = nextSelectedDiscount.tag || nextSelectedDiscount.type;
-            const nextIsGoodPass = nextDiscType === "good_pass";
-            const nextIsDiscountCard = ["discount_card", "product_discount_card"].includes(nextDiscType);
-            const nextApplicableProductLimit = ((_F = nextSelectedDiscount.config) == null ? void 0 : _F.applicableProductLimit) || 0;
+            const nextIsGoodPass = nextDiscType === 'good_pass';
+            const nextIsDiscountCard = ['discount_card', 'product_discount_card'].includes(nextDiscType);
+            const nextApplicableProductLimit = nextSelectedDiscount.config?.applicableProductLimit || 0;
             const nextIsNeedSplit = nextIsGoodPass || nextIsDiscountCard && nextApplicableProductLimit > 0;
             if (!nextIsNeedSplit) {
+              // 🔥 不需要拆分：直接应用折扣到所有剩余商品
               const nextBundleDiscount = nextSelectedDiscountCard || nextApplicableDiscounts[0];
               usedDiscounts.set(nextBundleDiscount.id, true);
-              if ((nextBundleDiscount.tag || nextBundleDiscount.type) === "good_pass") {
+              if ((nextBundleDiscount.tag || nextBundleDiscount.type) === 'good_pass') {
                 const curCount = usedProductIdCounts.get(nextBundleDiscount.product_id) || 0;
                 usedProductIdCounts.set(nextBundleDiscount.product_id, curCount + 1);
               }
               const nextNoSplitType = nextBundleDiscount.tag || nextBundleDiscount.type;
-              if (["discount_card", "product_discount_card"].includes(nextNoSplitType)) {
+              if (['discount_card', 'product_discount_card'].includes(nextNoSplitType)) {
                 const curCount = usedDiscountCardLimitCounts.get(nextBundleDiscount.id) || 0;
                 usedDiscountCardLimitCounts.set(nextBundleDiscount.id, curCount + remainingNum);
               }
               const nextOriginTotal = product.original_price || product.price || 0;
-              const nextTargetTotal = (0, import_utils.getDiscountAmount)(nextBundleDiscount, nextOriginTotal, nextOriginTotal);
-              const nextDiscountAmount = new import_decimal.default(nextOriginTotal).minus(nextTargetTotal).toNumber();
+              const nextTargetTotal = (0, _utils.getDiscountAmount)(nextBundleDiscount, nextOriginTotal, nextOriginTotal);
+              const nextDiscountAmount = new _decimal.default(nextOriginTotal).minus(nextTargetTotal).toNumber();
               const nextUniqueId = `${flatItem._id}_split_${continueSplitIndex}`;
-              const nextBundleDiscType = nextBundleDiscount.tag === "product_discount_card" ? "discount_card" : nextBundleDiscount.tag;
+              const nextBundleDiscType = nextBundleDiscount.tag === 'product_discount_card' ? 'discount_card' : nextBundleDiscount.tag;
               const nextDiscountDetail = {
                 amount: nextDiscountAmount * remainingNum,
                 type: nextBundleDiscType,
                 discount: {
-                  discount_card_type: (_G = nextBundleDiscount == null ? void 0 : nextBundleDiscount.metadata) == null ? void 0 : _G.discount_card_type,
+                  discount_card_type: nextBundleDiscount?.metadata?.discount_card_type,
                   fixed_amount: nextDiscountAmount,
                   resource_id: nextBundleDiscount.id,
                   title: nextBundleDiscount.format_title,
@@ -1295,8 +1508,8 @@ var RulesModule = class extends import_BaseModule.BaseModule {
                   custom_product_bundle_map_id: nextUniqueId,
                   num: remainingNum
                 },
-                config: nextBundleDiscount == null ? void 0 : nextBundleDiscount.config,
-                _num: remainingNum * (((_H = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _H.num) || 1)
+                config: nextBundleDiscount?.config,
+                _num: remainingNum * (flatItem?.parentProduct?.num || 1)
               };
               const nextAppliedProducts = appliedDiscountProducts.get(nextBundleDiscount.id) || [];
               nextAppliedProducts.push(nextDiscountDetail);
@@ -1307,25 +1520,22 @@ var RulesModule = class extends import_BaseModule.BaseModule {
                 num: remainingNum,
                 quantity: remainingNum,
                 total: nextTargetTotal,
-                price: new import_decimal.default(nextOriginTotal || 0).minus(nextDiscountDetail.discount.fixed_amount).toNumber(),
+                price: new _decimal.default(nextOriginTotal || 0).minus(nextDiscountDetail.discount.fixed_amount).toNumber(),
                 discount_list: [nextDiscountDetail],
                 processed: true
               });
               remainingNum = 0;
               break;
             }
+
+            // 🔥 需要拆分：计算最大使用次数
             let nextMaxUsageLimit;
             if (nextIsGoodPass) {
-              const nextGoodPassCount = nextApplicableDiscounts.filter(
-                (item) => (item.tag || item.type) === "good_pass"
-              ).length;
+              const nextGoodPassCount = nextApplicableDiscounts.filter(item => (item.tag || item.type) === 'good_pass').length;
               nextMaxUsageLimit = nextGoodPassCount;
-              if ((_I = nextSelectedDiscount.config) == null ? void 0 : _I.maxUsagePerOrder) {
+              if (nextSelectedDiscount.config?.maxUsagePerOrder) {
                 const usedCount = usedProductIdCounts.get(nextSelectedDiscount.product_id) || 0;
-                nextMaxUsageLimit = Math.min(
-                  nextGoodPassCount,
-                  Math.max(0, nextSelectedDiscount.config.maxUsagePerOrder - usedCount)
-                );
+                nextMaxUsageLimit = Math.min(nextGoodPassCount, Math.max(0, nextSelectedDiscount.config.maxUsagePerOrder - usedCount));
               }
             } else if (nextIsDiscountCard && nextApplicableProductLimit > 0) {
               const usedLimitCount = usedDiscountCardLimitCounts.get(nextSelectedDiscount.id) || 0;
@@ -1335,6 +1545,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
             }
             const nextSplitCount = Math.min(remainingNum, nextMaxUsageLimit);
             if (nextSplitCount === 0) {
+              // 已达使用上限，剩余商品无折扣存储
               processedItems.push({
                 ...flatItem,
                 _id: `${flatItem._id}_split_rest`,
@@ -1345,31 +1556,29 @@ var RulesModule = class extends import_BaseModule.BaseModule {
               });
               break;
             }
+
+            // 生成有折扣的商品
             for (let j = 0; j < nextSplitCount; j++) {
               const nextBundleDiscount = nextIsGoodPass ? nextSelectedDiscountCard || nextApplicableDiscounts[j] : nextSelectedDiscountCard || nextApplicableDiscounts[0];
               usedDiscounts.set(nextBundleDiscount.id, true);
-              if ((nextBundleDiscount.tag || nextBundleDiscount.type) === "good_pass") {
+              if ((nextBundleDiscount.tag || nextBundleDiscount.type) === 'good_pass') {
                 const curCount = usedProductIdCounts.get(nextBundleDiscount.product_id) || 0;
                 usedProductIdCounts.set(nextBundleDiscount.product_id, curCount + 1);
               }
               const nextBundleDiscTypeForCount = nextBundleDiscount.tag || nextBundleDiscount.type;
-              if (["discount_card", "product_discount_card"].includes(nextBundleDiscTypeForCount)) {
+              if (['discount_card', 'product_discount_card'].includes(nextBundleDiscTypeForCount)) {
                 const curLimitCount = usedDiscountCardLimitCounts.get(nextBundleDiscount.id) || 0;
                 usedDiscountCardLimitCounts.set(nextBundleDiscount.id, curLimitCount + 1);
               }
               const nextUniqueId = `${flatItem._id}_split_${continueSplitIndex}`;
-              const nextDiscountedPrice = (0, import_utils.getDiscountAmount)(
-                nextBundleDiscount,
-                product.origin_total,
-                product.origin_total
-              );
-              const nextBundleDiscAmount = new import_decimal.default(product.origin_total || 0).minus(nextDiscountedPrice).toNumber();
-              const nextBundleDiscTypeStr = nextBundleDiscount.tag === "product_discount_card" ? "discount_card" : nextBundleDiscount.tag;
+              const nextDiscountedPrice = (0, _utils.getDiscountAmount)(nextBundleDiscount, product.origin_total, product.origin_total);
+              const nextBundleDiscAmount = new _decimal.default(product.origin_total || 0).minus(nextDiscountedPrice).toNumber();
+              const nextBundleDiscTypeStr = nextBundleDiscount.tag === 'product_discount_card' ? 'discount_card' : nextBundleDiscount.tag;
               const nextDiscountDetail = {
                 amount: nextBundleDiscAmount,
                 type: nextBundleDiscTypeStr,
                 discount: {
-                  discount_card_type: (_J = nextBundleDiscount == null ? void 0 : nextBundleDiscount.metadata) == null ? void 0 : _J.discount_card_type,
+                  discount_card_type: nextBundleDiscount?.metadata?.discount_card_type,
                   fixed_amount: nextBundleDiscAmount,
                   resource_id: nextBundleDiscount.id,
                   title: nextBundleDiscount.format_title,
@@ -1383,7 +1592,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
                   num: 1
                 },
                 _num: 1,
-                config: nextBundleDiscount == null ? void 0 : nextBundleDiscount.config
+                config: nextBundleDiscount?.config
               };
               const nextAppliedProducts = appliedDiscountProducts.get(nextBundleDiscount.id) || [];
               nextAppliedProducts.push(nextDiscountDetail);
@@ -1404,91 +1613,108 @@ var RulesModule = class extends import_BaseModule.BaseModule {
             remainingNum -= nextSplitCount;
           }
         } else {
+          // 不拆分：直接应用折扣
           const currentBundleDiscount = selectedDiscountCard || applicableDiscounts[0];
           usedDiscounts.set(currentBundleDiscount.id, true);
-          if ((currentBundleDiscount.tag || currentBundleDiscount.type) === "good_pass") {
+          // 🔥 更新 product_id 使用计数
+          if ((currentBundleDiscount.tag || currentBundleDiscount.type) === 'good_pass') {
             const currentCount = usedProductIdCounts.get(currentBundleDiscount.product_id) || 0;
             usedProductIdCounts.set(currentBundleDiscount.product_id, currentCount + 1);
           }
+          // 🔥 更新折扣卡 applicableProductLimit 使用计数（不拆分时按商品数量计数）
           const noSplitDiscountType = currentBundleDiscount.tag || currentBundleDiscount.type;
-          if (["discount_card", "product_discount_card"].includes(noSplitDiscountType)) {
+          if (['discount_card', 'product_discount_card'].includes(noSplitDiscountType)) {
             const bundleQuantity = product.num || 1;
             const currentNoSplitCount = usedDiscountCardLimitCounts.get(currentBundleDiscount.id) || 0;
             usedDiscountCardLimitCounts.set(currentBundleDiscount.id, currentNoSplitCount + bundleQuantity);
           }
           const productOriginTotal = product.original_price || product.price || 0;
-          const isOrderLevel = (0, import_utils3.isOrderLevelFixedAmountDiscount)(selectedDiscount);
+
+          // 🔥 检查是否是 order_level 固定金额折扣卡
+          const isOrderLevel = (0, _utils.isOrderLevelFixedAmountDiscount)(selectedDiscount);
           const orderLevelAllocation = isOrderLevel ? orderLevelDiscountAllocations.get(selectedDiscount.id) : null;
-          const productAllocation = orderLevelAllocation == null ? void 0 : orderLevelAllocation.get(flatItem._id);
+          const productAllocation = orderLevelAllocation?.get(flatItem._id);
           let targetProductTotal;
           let fixedAmountPerItem;
           let productDiscountDifference;
           if (isOrderLevel && productAllocation) {
+            // order_level：使用预计算的单价折扣金额（已经是单价，无需再除以数量）
             fixedAmountPerItem = productAllocation.discountAmount;
             productDiscountDifference = productAllocation.difference;
-            targetProductTotal = Math.max(new import_decimal.default(productOriginTotal).minus(fixedAmountPerItem).toNumber(), 0);
+            targetProductTotal = Math.max(new _decimal.default(productOriginTotal).minus(fixedAmountPerItem).toNumber(), 0);
           } else {
-            targetProductTotal = (0, import_utils.getDiscountAmount)(
-              currentBundleDiscount,
-              productOriginTotal,
-              productOriginTotal
-            );
-            fixedAmountPerItem = new import_decimal.default(productOriginTotal).minus(targetProductTotal).toNumber();
+            // item_level 或其他类型：使用原有逻辑
+            targetProductTotal = (0, _utils.getDiscountAmount)(currentBundleDiscount, productOriginTotal, productOriginTotal);
+            fixedAmountPerItem = new _decimal.default(productOriginTotal).minus(targetProductTotal).toNumber();
           }
-          const bundleActualDiscountAmount = new import_decimal.default(productOriginTotal).minus(targetProductTotal).toNumber();
+
+          // 计算实际折扣金额
+          const bundleActualDiscountAmount = new _decimal.default(productOriginTotal).minus(targetProductTotal).toNumber();
+
+          // 🔥 使用当前的 _id 作为唯一标识
           const uniqueId = flatItem._id;
+          debugger;
           const discountDetail = {
             amount: bundleActualDiscountAmount * (product.num || 1),
-            type: currentBundleDiscount.tag === "product_discount_card" ? "discount_card" : currentBundleDiscount.tag,
+            type: currentBundleDiscount.tag === 'product_discount_card' ? 'discount_card' : currentBundleDiscount.tag,
             discount: {
-              discount_card_type: (_K = currentBundleDiscount == null ? void 0 : currentBundleDiscount.metadata) == null ? void 0 : _K.discount_card_type,
+              discount_card_type: currentBundleDiscount?.metadata?.discount_card_type,
               fixed_amount: bundleActualDiscountAmount,
-              discount_calculation_mode: (_L = currentBundleDiscount == null ? void 0 : currentBundleDiscount.metadata) == null ? void 0 : _L.discount_calculation_mode,
+              discount_calculation_mode: currentBundleDiscount?.metadata?.discount_calculation_mode,
               resource_id: currentBundleDiscount.id,
               title: currentBundleDiscount.format_title,
               original_amount: product.original_price,
-              product_id: product.id,
-              percent: currentBundleDiscount.par_value,
-              discount_product_id: currentBundleDiscount.product_id
+              product_id: product.id || product.product_id,
+              percent: selectedDiscount.par_value,
+              discount_product_id: selectedDiscount.product_id
             },
             metadata: {
               // 🔥 使用唯一的 _id
               custom_product_bundle_map_id: uniqueId,
-              discount_rule_uncheck_flag: selectedDiscount == null ? void 0 : selectedDiscount.discount_rule_uncheck_flag,
+              discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
               num: product.num || 1,
               // 🔥 order_level 分摊差值
-              ...productDiscountDifference !== void 0 && { product_discount_difference: productDiscountDifference }
+              ...(productDiscountDifference !== undefined && {
+                product_discount_difference: productDiscountDifference
+              })
             },
-            config: currentBundleDiscount == null ? void 0 : currentBundleDiscount.config,
-            _num: (product.num || 1) * (((_M = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _M.num) || 1)
+            config: currentBundleDiscount?.config,
+            _num: (product.num || 1) * (flatItem?.parentProduct?.num || 1)
           };
+
+          // 记录实际应用的折扣
           const appliedProducts = appliedDiscountProducts.get(currentBundleDiscount.id) || [];
           appliedProducts.push(discountDetail);
           appliedDiscountProducts.set(currentBundleDiscount.id, appliedProducts);
           processedItems.push({
             ...flatItem,
             total: targetProductTotal,
-            price: new import_decimal.default(productOriginTotal || 0).minus(fixedAmountPerItem).toNumber(),
-            discount_list: this.filterDiscountListByType(flatItem.discount_list, "promotion").concat([discountDetail]),
+            price: new _decimal.default(productOriginTotal || 0).minus(fixedAmountPerItem).toNumber(),
+            discount_list: this.filterDiscountListByType(flatItem.discount_list, 'promotion').concat([discountDetail]),
             processed: true
           });
         }
         processedFlatItemsMap.set(flatItem._id, processedItems);
       }
     });
-    const reconstructProductsWithBundle = (processedProductsMap2, processedFlatItemsMap2, originalProductList) => {
+
+    // 🔥 重组：将处理后的bundle子商品重新组装回主商品
+    const reconstructProductsWithBundle = (processedProductsMap, processedFlatItemsMap, originalProductList) => {
       const result = [];
-      originalProductList.forEach((originProduct) => {
+      originalProductList.forEach(originProduct => {
         const product = this.hooks.getProduct(originProduct);
-        const mainProductArr = processedProductsMap2.get(product._id);
+
+        // 获取主商品处理结果
+        const mainProductArr = processedProductsMap.get(product._id);
         if (!mainProductArr || mainProductArr.length === 0) {
+          // 如果没有处理结果，返回默认商品（还原 option 价格）
           const getDefaultProduct = () => {
             const restoredOptions = restoreOptionPrices(product.options);
             if (product.isClient) {
               return this.hooks.setProduct(originProduct, {
-                discount_list: this.filterDiscountListByType(product.discount_list, "promotion"),
+                discount_list: this.filterDiscountListByType(product.discount_list, 'promotion'),
                 price: product.price,
-                origin_total: (0, import_utils2.getProductOriginTotalPrice)({
+                origin_total: (0, _utils2.getProductOriginTotalPrice)({
                   product: {
                     original_price: product.original_price
                   },
@@ -1497,7 +1723,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
                 }),
                 variant: originProduct._productInit.variant,
                 original_price: originProduct._productInit.original_price,
-                total: (0, import_utils2.getProductTotalPrice)({
+                total: (0, _utils2.getProductTotalPrice)({
                   product: {
                     price: product.price
                   },
@@ -1508,7 +1734,7 @@ var RulesModule = class extends import_BaseModule.BaseModule {
               });
             } else {
               return this.hooks.setProduct(originProduct, {
-                discount_list: this.filterDiscountListByType(product.discount_list, "promotion"),
+                discount_list: this.filterDiscountListByType(product.discount_list, 'promotion'),
                 total: product.total,
                 origin_total: product.origin_total,
                 price: product.price,
@@ -1519,332 +1745,359 @@ var RulesModule = class extends import_BaseModule.BaseModule {
           result.push(getDefaultProduct());
           return;
         }
+
+        // 检查是否有bundle子商品需要重组
         const hasBundle = product.bundle && Array.isArray(product.bundle) && product.bundle.length > 0;
         if (!hasBundle) {
+          // 没有bundle，直接使用主商品处理结果
           result.push(...mainProductArr);
         } else {
-          const bundleProcessingInfo = /* @__PURE__ */ new Map();
-          let hasGoodPassApplied = false;
+          // 🔥 有bundle，需要检查子商品是否应用了商品券
+          // 1. 先收集所有bundle子商品的处理结果
+          const bundleProcessingInfo = new Map();
+          let hasGoodPassApplied = false; // 标记是否有子商品应用了商品券
+
           if (product.bundle && Array.isArray(product.bundle)) {
             product.bundle.forEach((bundleItem, bundleIndex) => {
               const bundleItemId = `${product._id}_bundle_${bundleIndex}`;
-              const processedBundleItems = processedFlatItemsMap2.get(bundleItemId);
+              const processedBundleItems = processedFlatItemsMap.get(bundleItemId);
               if (!processedBundleItems || processedBundleItems.length === 0) {
+                // 未处理的bundle item，保持原样
                 bundleProcessingInfo.set(bundleIndex, [bundleItem]);
               } else {
+                // 处理过的bundle item
                 bundleProcessingInfo.set(bundleIndex, processedBundleItems);
-                const hasGoodPass = processedBundleItems.some(
-                  (item) => {
-                    var _a;
-                    return (_a = item.discount_list) == null ? void 0 : _a.some(
-                      (discount) => discount.type === "good_pass" || discount.tag === "good_pass"
-                    );
-                  }
-                );
+                // 🔥 检查是否应用了商品券（good_pass）
+                const hasGoodPass = processedBundleItems.some(item => item.discount_list?.some(discount => discount.type === 'good_pass' || discount.tag === 'good_pass'));
                 if (hasGoodPass) {
                   hasGoodPassApplied = true;
                 }
               }
             });
           }
+
+          // 🔥 2. 如果有子商品应用了商品券，且主商品数量大于1，需要拆分主商品
           const mainProductQuantity = mainProductArr[0] ? this.hooks.getProduct(mainProductArr[0]).quantity : 1;
           if (hasGoodPassApplied && mainProductArr.length === 1 && mainProductQuantity > 1) {
             const mainProduct = mainProductArr[0];
             const mainProductData = this.hooks.getProduct(mainProduct);
+
+            // 🔥 方案：拆分成2个主商品
+            // 1. 一个主商品(qty=1)包含拆分后的bundle
+            // 2. 一个主商品(qty=原quantity-1)包含原始未拆分的bundle
+
+            // 第一个：包含拆分后的bundle (qty=1)
             const newBundleWithDiscount = [];
-            (product.bundle || []).forEach(
-              (bundleItem, bundleIndex) => {
-                const processedItems = bundleProcessingInfo.get(
-                  bundleIndex
-                ) || [bundleItem];
-                if (processedItems.length > 1) {
-                  processedItems.forEach((item) => {
-                    const updatedDiscountList2 = (item.discount_list || []).map((discount) => {
-                      var _a;
-                      return {
-                        ...discount,
-                        metadata: {
-                          ...discount.metadata,
-                          num: item.num,
-                          custom_product_bundle_map_id: (_a = item.metadata) == null ? void 0 : _a.custom_product_bundle_map_id
-                        }
-                        // num: item.num, // 使用拆分后的 num
-                      };
-                    });
-                    newBundleWithDiscount.push({
-                      ...bundleItem,
-                      _id: item._id,
-                      product_id: bundleItem.product_id,
-                      price: item.price,
+            (product.bundle || []).forEach((bundleItem, bundleIndex) => {
+              const processedItems = bundleProcessingInfo.get(bundleIndex) || [bundleItem];
+              if (processedItems.length > 1) {
+                // 被拆分的子商品，添加所有拆分项
+                processedItems.forEach(item => {
+                  // 🔥 更新 discount_list 中的 num，使其与拆分后的 item.num 一致
+                  const updatedDiscountList = (item.discount_list || []).map(discount => ({
+                    ...discount,
+                    metadata: {
+                      ...discount.metadata,
                       num: item.num,
-                      quantity: item.num,
-                      discount_list: updatedDiscountList2
-                    });
+                      custom_product_bundle_map_id: item.metadata?.custom_product_bundle_map_id
+                    }
+                    // num: item.num, // 使用拆分后的 num
+                  }));
+                  newBundleWithDiscount.push({
+                    ...bundleItem,
+                    _id: item._id,
+                    product_id: bundleItem.product_id,
+                    price: item.price,
+                    num: item.num,
+                    quantity: item.num,
+                    discount_list: updatedDiscountList
                   });
-                } else {
-                  const item = processedItems[0];
-                  if (item.processed) {
-                    const updatedDiscountList2 = (item.discount_list || []).map((discount) => {
-                      var _a;
-                      return {
-                        ...discount,
-                        metadata: {
-                          ...discount.metadata,
-                          num: item.num,
-                          custom_product_bundle_map_id: (_a = item.metadata) == null ? void 0 : _a.custom_product_bundle_map_id
-                        }
-                        // num: item.num, // 使用当前的 num
-                      };
-                    });
-                    newBundleWithDiscount.push({
-                      ...bundleItem,
-                      _id: item._id,
-                      product_id: bundleItem.product_id,
-                      price: item.price,
+                });
+              } else {
+                // 未拆分的子商品，保持原样
+                const item = processedItems[0];
+                if (item.processed) {
+                  // 🔥 同样需要更新 discount_list 中的 num
+                  const updatedDiscountList = (item.discount_list || []).map(discount => ({
+                    ...discount,
+                    metadata: {
+                      ...discount.metadata,
                       num: item.num,
-                      quantity: item.num,
-                      discount_list: updatedDiscountList2
-                    });
-                  } else {
-                    newBundleWithDiscount.push(item);
-                  }
+                      custom_product_bundle_map_id: item.metadata?.custom_product_bundle_map_id
+                    }
+                    // num: item.num, // 使用当前的 num
+                  }));
+                  newBundleWithDiscount.push({
+                    ...bundleItem,
+                    _id: item._id,
+                    product_id: bundleItem.product_id,
+                    price: item.price,
+                    num: item.num,
+                    quantity: item.num,
+                    discount_list: updatedDiscountList
+                  });
+                } else {
+                  newBundleWithDiscount.push(item);
                 }
               }
-            );
+            });
+
+            // 计算第一个主商品的总价（包含拆分后的bundle）
             let newTotalWithDiscount = Number(mainProductData.price || 0);
-            let newOriginTotalWithDiscount = Number(
-              mainProductData.original_price || mainProductData.price || 0
-            );
-            const updatedMainDiscountList = mainProductData.discount_list.map((discount) => {
-              var _a, _b;
-              if ((_a = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a.custom_product_bundle_map_id) {
+            let newOriginTotalWithDiscount = Number(mainProductData.original_price || mainProductData.price || 0);
+
+            // 🔥 更新主商品自己的 discount_list 中的 num（quantity=1）
+            const updatedMainDiscountList = mainProductData.discount_list.map(discount => {
+              if (discount?.metadata?.custom_product_bundle_map_id) {
+                // bundle的discount_list保持不变
                 return discount;
               }
+              // 主商品自己的discount，更新num为1
               return {
                 ...discount,
                 // num: 1,
                 metadata: {
                   ...discount.metadata,
-                  custom_product_bundle_map_id: (_b = discount == null ? void 0 : discount.metadata) == null ? void 0 : _b.custom_product_bundle_map_id,
+                  custom_product_bundle_map_id: discount?.metadata?.custom_product_bundle_map_id,
                   num: 1
                 }
               };
             });
-            const mainDiscountList = updatedMainDiscountList.filter(
-              (item) => {
-                var _a;
-                return !((_a = item == null ? void 0 : item.metadata) == null ? void 0 : _a.custom_product_bundle_map_id);
-              }
-            );
+
+            // 🔥 使用更新后的列表计算折扣金额
+            const mainDiscountList = updatedMainDiscountList.filter(item => !item?.metadata?.custom_product_bundle_map_id);
             if (mainDiscountList && mainDiscountList.length > 0) {
-              const allDiscountAmount = (0, import_utils.getDiscountListAmountTotal)(mainDiscountList);
-              newTotalWithDiscount = new import_decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotalWithDiscount;
+              const allDiscountAmount = (0, _utils.getDiscountListAmountTotal)(mainDiscountList);
+              newTotalWithDiscount = new _decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotalWithDiscount;
               newOriginTotalWithDiscount = mainProductData.origin_total ?? newOriginTotalWithDiscount;
             }
+
+            // 累加bundle的价格（只累加一次）
             if (newBundleWithDiscount.length > 0) {
-              newBundleWithDiscount.forEach((item) => {
+              newBundleWithDiscount.forEach(item => {
                 newTotalWithDiscount += Number(item.price) * Number(item.num);
               });
-              newBundleWithDiscount.forEach((item) => {
-                var _a, _b, _c;
-                const originalPrice = ((_c = (_b = (_a = item.discount_list) == null ? void 0 : _a[0]) == null ? void 0 : _b.discount) == null ? void 0 : _c.original_amount) || item.price;
+              newBundleWithDiscount.forEach(item => {
+                const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
                 newOriginTotalWithDiscount += Number(originalPrice) * Number(item.num);
               });
             }
-            if (product == null ? void 0 : product.options) {
+
+            // 累加options的价格（options不参与折扣，在最终设置total时处理）
+            if (product?.options) {
               newTotalWithDiscount = product.options.reduce((accumulator, currentValue) => {
-                const currentPrice = new import_decimal.default(currentValue.price || 0);
-                const currentNum = new import_decimal.default(currentValue.num || 0);
+                const currentPrice = new _decimal.default(currentValue.price || 0);
+                const currentNum = new _decimal.default(currentValue.num || 0);
                 return accumulator.add(currentPrice.mul(currentNum));
-              }, new import_decimal.default(newTotalWithDiscount)).toNumber();
+              }, new _decimal.default(newTotalWithDiscount)).toNumber();
             }
-            result.push(
-              this.hooks.setProduct(mainProduct, {
-                ...mainProductData,
-                _id: `${mainProductData._id.split("___")[0]}___split_discount`,
-                quantity: 1,
-                discount_list: updatedMainDiscountList,
-                bundle: newBundleWithDiscount,
-                total: new import_decimal.default(newTotalWithDiscount).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber(),
-                origin_total: new import_decimal.default(newOriginTotalWithDiscount).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber()
-              })
-            );
+
+            // 添加第一个主商品：qty=1，包含拆分后的bundle
+            result.push(this.hooks.setProduct(mainProduct, {
+              ...mainProductData,
+              _id: `${mainProductData._id.split('___')[0]}___split_discount`,
+              quantity: 1,
+              discount_list: updatedMainDiscountList,
+              bundle: newBundleWithDiscount,
+              total: new _decimal.default(newTotalWithDiscount).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber(),
+              origin_total: new _decimal.default(newOriginTotalWithDiscount).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber()
+            }));
+
+            // 第二个：包含原始bundle (qty=原quantity-1)
             if (mainProductQuantity > 1) {
               const newBundleOriginal = [];
-              (product.bundle || []).forEach(
-                (bundleItem, bundleIndex) => {
-                  newBundleOriginal.push({
-                    ...bundleItem,
-                    discount_list: []
-                  });
-                }
-              );
+              (product.bundle || []).forEach((bundleItem, bundleIndex) => {
+                // 使用原始的bundle配置，不包含拆分
+                newBundleOriginal.push({
+                  ...bundleItem,
+                  discount_list: []
+                });
+              });
+
+              // 计算第二个主商品的总价
               let newTotalOriginal = Number(mainProductData.price || 0);
-              let newOriginTotalOriginal = Number(
-                mainProductData.original_price || mainProductData.price || 0
-              );
-              const updatedMainDiscountListOriginal = mainProductData.discount_list.map((discount) => {
-                var _a, _b;
-                if ((_a = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a.custom_product_bundle_map_id) {
+              let newOriginTotalOriginal = Number(mainProductData.original_price || mainProductData.price || 0);
+
+              // 🔥 更新主商品自己的 discount_list 中的 num（quantity=原quantity-1）
+              const updatedMainDiscountListOriginal = mainProductData.discount_list.map(discount => {
+                if (discount?.metadata?.custom_product_bundle_map_id) {
+                  // bundle的discount_list保持不变
                   return discount;
                 }
+                // 主商品自己的discount，更新num为 mainProductQuantity - 1
                 return {
                   ...discount,
                   metadata: {
                     ...discount.metadata,
                     num: mainProductQuantity - 1,
-                    custom_product_bundle_map_id: (_b = discount == null ? void 0 : discount.metadata) == null ? void 0 : _b.custom_product_bundle_map_id
+                    custom_product_bundle_map_id: discount?.metadata?.custom_product_bundle_map_id
                   }
                   // num: mainProductQuantity - 1,
                 };
               });
-              const mainDiscountListOriginal = updatedMainDiscountListOriginal.filter(
-                (item) => {
-                  var _a;
-                  return !((_a = item == null ? void 0 : item.metadata) == null ? void 0 : _a.custom_product_bundle_map_id);
-                }
-              );
+
+              // 🔥 使用更新后的列表计算折扣金额
+              const mainDiscountListOriginal = updatedMainDiscountListOriginal.filter(item => !item?.metadata?.custom_product_bundle_map_id);
               if (mainDiscountListOriginal && mainDiscountListOriginal.length > 0) {
-                const allDiscountAmount = (0, import_utils.getDiscountListAmount)(
-                  mainDiscountListOriginal
-                );
-                newTotalOriginal = new import_decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotalOriginal;
+                const allDiscountAmount = (0, _utils.getDiscountListAmount)(mainDiscountListOriginal);
+                newTotalOriginal = new _decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotalOriginal;
                 newOriginTotalOriginal = mainProductData.origin_total ?? newOriginTotalOriginal;
               }
+
+              // 累加bundle的价格（只累加一次）
               if (newBundleOriginal.length > 0) {
-                newBundleOriginal.forEach((item) => {
+                newBundleOriginal.forEach(item => {
                   newTotalOriginal += Number(item.price) * Number(item.num);
                   newOriginTotalOriginal += Number(item.price) * Number(item.num);
                 });
               }
-              if (product == null ? void 0 : product.options) {
+
+              // 累加options的价格（options不参与折扣，在最终设置total时处理）
+              if (product?.options) {
                 newTotalOriginal = product.options.reduce((accumulator, currentValue) => {
-                  const currentPrice = new import_decimal.default(currentValue.price || 0);
-                  const currentNum = new import_decimal.default(currentValue.num || 0);
+                  const currentPrice = new _decimal.default(currentValue.price || 0);
+                  const currentNum = new _decimal.default(currentValue.num || 0);
                   return accumulator.add(currentPrice.mul(currentNum));
-                }, new import_decimal.default(newTotalOriginal)).toNumber();
+                }, new _decimal.default(newTotalOriginal)).toNumber();
               }
-              newTotalOriginal = new import_decimal.default(newTotalOriginal).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
-              newOriginTotalOriginal = new import_decimal.default(newOriginTotalOriginal).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
-              result.push(
-                this.hooks.setProduct(mainProduct, {
-                  ...mainProductData,
-                  _id: `${mainProductData._id.split("___")[0]}___split_normal`,
-                  quantity: mainProductQuantity - 1,
-                  discount_list: updatedMainDiscountListOriginal,
-                  bundle: newBundleOriginal,
-                  total: newTotalOriginal,
-                  origin_total: newOriginTotalOriginal
-                })
-              );
+              newTotalOriginal = new _decimal.default(newTotalOriginal).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+              newOriginTotalOriginal = new _decimal.default(newOriginTotalOriginal).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+
+              // 添加第二个主商品：qty=原quantity-1，包含原始bundle
+              result.push(this.hooks.setProduct(mainProduct, {
+                ...mainProductData,
+                _id: `${mainProductData._id.split('___')[0]}___split_normal`,
+                quantity: mainProductQuantity - 1,
+                discount_list: updatedMainDiscountListOriginal,
+                bundle: newBundleOriginal,
+                total: newTotalOriginal,
+                origin_total: newOriginTotalOriginal
+              }));
             }
           } else {
-            mainProductArr.forEach((mainProduct) => {
-              var _a, _b, _c;
+            // 🔥 没有子商品被拆分，使用原有逻辑
+            mainProductArr.forEach(mainProduct => {
               const mainProductData = this.hooks.getProduct(mainProduct);
+
+              // 重组bundle
               const newBundle = [];
               if (product.bundle && Array.isArray(product.bundle)) {
                 product.bundle.forEach((bundleItem, bundleIndex) => {
                   const bundleItemId = `${product._id}_bundle_${bundleIndex}`;
-                  const processedBundleItems = processedFlatItemsMap2.get(bundleItemId);
+                  const processedBundleItems = processedFlatItemsMap.get(bundleItemId);
                   if (!processedBundleItems || processedBundleItems.length === 0) {
+                    // 未处理的bundle item，保持原样
                     newBundle.push(bundleItem);
                   } else {
-                    processedBundleItems.forEach((item) => {
-                      const updatedDiscountList2 = (item.discount_list || []).map((discount) => {
-                        var _a2;
-                        return {
-                          ...discount,
-                          metadata: {
-                            ...discount.metadata,
-                            num: item.num,
-                            custom_product_bundle_map_id: (_a2 = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a2.custom_product_bundle_map_id
-                          }
-                          // num: item.num, // 使用拆分后的 num
-                        };
-                      });
+                    // 🔥 关键：拆分后的bundle item
+                    processedBundleItems.forEach(item => {
+                      const nextBundlePrice = item.price ?? bundleItem.price;
+                      const nextBundleSellingPrice = item.bundle_selling_price ?? item.price ?? bundleItem.bundle_selling_price;
+                      // 🔥 更新 discount_list 中的 num，使其与拆分后的 item.num 一致
+                      const updatedDiscountList = (item.discount_list || []).map(discount => ({
+                        ...discount,
+                        metadata: {
+                          ...discount.metadata,
+                          num: item.num,
+                          custom_product_bundle_map_id: discount?.metadata?.custom_product_bundle_map_id
+                        }
+                        // num: item.num, // 使用拆分后的 num
+                      }));
                       newBundle.push({
                         ...bundleItem,
                         _id: item._id,
                         product_id: bundleItem.product_id,
-                        price: item.price,
+                        price: nextBundlePrice,
                         num: item.num,
-                        discount_list: updatedDiscountList2,
-                        bundle_selling_price: bundleItem.bundle_selling_price !== void 0 ? item.price : void 0
+                        discount_list: updatedDiscountList,
+                        bundle_selling_price: bundleItem.bundle_selling_price !== undefined ? nextBundleSellingPrice : undefined
                       });
                     });
                   }
                 });
               }
-              let newTotal = Number(mainProductData.price || 0);
+
+              // 主商品已经在前面的 setProduct 中应用过折扣；这里只替换 bundle，
+              // 避免把主商品 discount_list 再扣一次。
+              const mainSellingPrice = mainProductData.main_product_selling_price ?? mainProductData.price ?? 0;
+              let newTotal = Number(mainSellingPrice || 0);
               let newOriginTotal = Number(mainProductData.original_price || mainProductData.price || 0);
-              const isManualDiscount = typeof mainProductData.isManualDiscount === "boolean" ? mainProductData.isManualDiscount : mainProductData.total != mainProductData.origin_total && (!((_a = mainProductData.discount_list) == null ? void 0 : _a.length) || ((_c = (_b = mainProductData == null ? void 0 : mainProductData.discount_list) == null ? void 0 : _b.every) == null ? void 0 : _c.call(_b, (item) => item.type === "product")));
+
+              // 判断是否是手动折扣
+              const isManualDiscount = typeof mainProductData.isManualDiscount === 'boolean' ? mainProductData.isManualDiscount : mainProductData.total != mainProductData.origin_total && (!mainProductData.discount_list?.length || mainProductData?.discount_list?.every?.(item => item.type === 'product'));
+
+              // 如果是手动折扣，使用原有的total和origin_total，不重新计算
               if (isManualDiscount) {
                 newTotal = mainProductData.total ?? newTotal;
                 newOriginTotal = mainProductData.origin_total ?? newOriginTotal;
               } else {
-                const mainDiscountList = mainProductData.discount_list.filter(
-                  (item) => {
-                    var _a2;
-                    return !((_a2 = item == null ? void 0 : item.metadata) == null ? void 0 : _a2.custom_product_bundle_map_id);
-                  }
-                );
-                if (mainDiscountList && mainDiscountList.length > 0) {
-                  const allDiscountAmount = (0, import_utils.getDiscountListAmount)(mainDiscountList);
-                  newTotal = new import_decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotal;
-                  newOriginTotal = mainProductData.origin_total ?? newOriginTotal;
-                }
+                // 累加bundle的折后价格（只累加一次）
                 if (newBundle.length > 0) {
-                  newBundle.forEach((item) => {
-                    var _a2, _b2, _c2;
+                  newBundle.forEach(item => {
                     newTotal += Number(item.price) * Number(item.num);
-                    const originalPrice = ((_c2 = (_b2 = (_a2 = item.discount_list) == null ? void 0 : _a2[0]) == null ? void 0 : _b2.discount) == null ? void 0 : _c2.original_amount) || item.price;
+                    const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
+                    newOriginTotal += Number(originalPrice) * Number(item.num);
+                  });
+                  // 计算原始总价（不考虑折扣）
+                  newBundle.forEach(item => {
+                    const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
                     newOriginTotal += Number(originalPrice) * Number(item.num);
                   });
                 }
               }
-              if (product == null ? void 0 : product.options) {
+
+              // 累加options的价格（options不参与折扣，在最终设置total时处理）
+              if (product?.options) {
                 newTotal = product.options.reduce((accumulator, currentValue) => {
-                  const currentPrice = new import_decimal.default(currentValue.price || 0);
-                  const currentNum = new import_decimal.default(currentValue.num || 0);
+                  const currentPrice = new _decimal.default(currentValue.price || 0);
+                  const currentNum = new _decimal.default(currentValue.num || 0);
                   return accumulator.add(currentPrice.mul(currentNum));
-                }, new import_decimal.default(newTotal)).toNumber();
+                }, new _decimal.default(newTotal)).toNumber();
               }
-              newTotal = new import_decimal.default(newTotal).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
-              newOriginTotal = new import_decimal.default(newOriginTotal).toDecimalPlaces(2, import_decimal.default.ROUND_HALF_UP).toNumber();
-              result.push(
-                this.hooks.setProduct(mainProduct, {
-                  ...mainProductData,
-                  bundle: newBundle,
-                  total: newTotal,
-                  origin_total: newOriginTotal
-                })
-              );
+              newTotal = new _decimal.default(newTotal).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+              newOriginTotal = new _decimal.default(newOriginTotal).toDecimalPlaces(2, _decimal.default.ROUND_HALF_UP).toNumber();
+
+              // 生成最终的主商品
+              result.push(this.hooks.setProduct(mainProduct, {
+                ...mainProductData,
+                bundle: newBundle,
+                total: newTotal,
+                origin_total: newOriginTotal
+              }));
             });
           }
         }
       });
       return result;
     };
-    const processedProductList = reconstructProductsWithBundle(
-      processedProductsMap,
-      processedFlatItemsMap,
-      productList
-    );
-    const updatedDiscountList = addModeDiscount.map((discount) => {
+
+    // 按原始顺序构建处理后的商品列表
+    const processedProductList = reconstructProductsWithBundle(processedProductsMap, processedFlatItemsMap, productList);
+
+    // 按原始顺序更新优惠券列表，标记已使用和可用的优惠券
+    const updatedDiscountList = addModeDiscount.map(discount => {
+      // 获取此优惠券适用的商品列表
       const applicableProducts = discountApplicability.get(discount.id) || [];
+
+      // 获取此优惠券适用的商品详情
       const applicableProductDetails = discountApplicableProducts.get(discount.id) || [];
+
+      // 获取此优惠券实际应用的商品详情
       const appliedProductDetails = appliedDiscountProducts.get(discount.id) || [];
+
+      // 根据是否有适用商品决定isAvailable
       const isAvailable = applicableProducts.length > 0;
-      if (typeof discount.isSelected === "boolean" && discount.isSelected === false && discount.isManualSelect) {
+
+      // 如果此优惠券被明确设置为不选中，保持其状态，但正确设置isAvailable
+      if (typeof discount.isSelected === 'boolean' && discount.isSelected === false && discount.isManualSelect) {
         return {
           ...discount,
           isSelected: false,
-          isAvailable,
+          isAvailable: isAvailable,
           // 正确设置可用性
           applicableProductIds: applicableProducts,
           // 添加可抵扣的商品详情
-          applicableProductDetails,
+          applicableProductDetails: applicableProductDetails,
           // 添加实际抵扣的商品详情（对于未选中的优惠券，为空数组）
           appliedProductDetails: []
         };
@@ -1853,18 +2106,20 @@ var RulesModule = class extends import_BaseModule.BaseModule {
         return {
           ...discount,
           isSelected: true,
-          isManualSelect: (options == null ? void 0 : options.scan) ? false : discount.isManualSelect,
+          isManualSelect: options?.scan ? false : discount.isManualSelect,
           // 标记为可用，因为它已被应用
           isAvailable: true,
           // 记录适用的商品IDs
           applicableProductIds: applicableProducts,
           // 添加可抵扣的商品详情
-          applicableProductDetails,
+          applicableProductDetails: applicableProductDetails,
           // 添加实际抵扣的商品详情
-          appliedProductDetails
+          appliedProductDetails: appliedProductDetails
         };
       }
-      let isSelected = typeof discount.isSelected === "boolean" ? discount.isSelected : void 0;
+      let isSelected = typeof discount.isSelected === 'boolean' ? discount.isSelected : undefined;
+
+      // 如果是可用的 并且没有手动标记 则设置为选中
       if (isAvailable && appliedProductDetails.length && !discount.isManualSelect) {
         isSelected = true;
       } else if (!appliedProductDetails.length) {
@@ -1873,24 +2128,24 @@ var RulesModule = class extends import_BaseModule.BaseModule {
       return {
         ...discount,
         // 如果有适用的商品，标记为可用
-        isAvailable,
+        isAvailable: isAvailable,
         isSelected,
         // 如果是扫码进来的，要手动设置为手动选择：false
-        isManualSelect: (options == null ? void 0 : options.scan) ? false : discount.isManualSelect,
+        isManualSelect: options?.scan ? false : discount.isManualSelect,
         // 记录适用的商品IDs
         applicableProductIds: applicableProducts,
         // 添加可抵扣的商品详情
-        applicableProductDetails,
+        applicableProductDetails: applicableProductDetails,
         // 添加实际抵扣的商品详情（对于未使用的优惠券，为空数组）
         appliedProductDetails: []
       };
     });
-    console.log(processedProductList, "processedProductList");
     return {
       productList: processedProductList,
       discountList: [...editModeDiscount, ...updatedDiscountList]
     };
   }
+
   /**
    * 检查优惠是否符合 PackageSubItemUsageRules 配置
    * @param discount 优惠券
@@ -1898,92 +2153,229 @@ var RulesModule = class extends import_BaseModule.BaseModule {
    * @returns 是否可用
    */
   checkPackageSubItemUsageRules(discount, flatItem) {
-    var _a, _b, _c, _d, _e, _f, _g;
     const limitedData = discount.limited_relation_product_data;
-    const usageRules = limitedData == null ? void 0 : limitedData.package_sub_item_usage_rules;
-    const rules = ["original_price", ...(usageRules == null ? void 0 : usageRules.rules) || []];
+    const usageRules = limitedData?.package_sub_item_usage_rules;
+    const rules = ['original_price', ...(usageRules?.rules || [])];
+
+    // 如果没有配置 package_sub_item_usage_rules，则默认可用
     if (!usageRules) {
       return true;
     }
     const ruleType = usageRules.type;
-    const packageScope = usageRules == null ? void 0 : usageRules.package_scope;
-    const { type: scopeType, exclude_bundle_product_ids = [], include_bundle_product_ids = [], filter = 0 } = packageScope || {};
-    const isMainProduct = flatItem.type === "main";
-    const isBundleItem = flatItem.type === "bundle";
+    // 套餐适用范围配置
+    const packageScope = usageRules?.package_scope;
+    const {
+      type: scopeType,
+      exclude_bundle_product_ids = [],
+      include_bundle_product_ids = [],
+      filter = 0
+    } = packageScope || {};
+    const isMainProduct = flatItem.type === 'main'; // 单独购买
+    const isBundleItem = flatItem.type === 'bundle'; // 套餐中购买
+    const bundleMainProductId = flatItem.product?.product_id;
+
+    // 主商品直接可用
     if (isMainProduct) {
       return true;
     }
-    if (ruleType === "universal_discount") {
+
+    // universal_discount: 单独购买和套餐中（子商品为原价）均可使用
+    if (ruleType === 'universal_discount') {
       if (isMainProduct) {
-        return true;
+        return true; // 单独购买时可用
       }
       if (isBundleItem) {
-        const priceType = (_a = flatItem.bundleItem) == null ? void 0 : _a.price_type;
-        const priceTypeExt = (_b = flatItem.bundleItem) == null ? void 0 : _b.price_type_ext;
-        const mainProductId = ((_d = (_c = flatItem == null ? void 0 : flatItem.originProduct) == null ? void 0 : _c._productOrigin) == null ? void 0 : _d.id) || ((_e = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _e.id) || 0;
-        const isOriginalPrice = priceType === "markup" && priceTypeExt === "product_price";
-        const isMarkupPrice = priceType === "markup" && (priceTypeExt === "" || !priceTypeExt);
+        // 套餐中购买时，判断是否为原价
+        const priceType = flatItem.bundleItem?.price_type;
+        const priceTypeExt = flatItem.bundleItem?.price_type_ext;
+        // 主商品id
+        const mainProductId = flatItem?.originProduct?._productOrigin?.id || flatItem?.parentProduct?.id || 0;
+        // original_price 对应：
+        // 1. price_type: "markup" && price_type_ext: "product_price"
+        // markup_price 对应：
+        // price_type: "markup" && price_type_ext: ""
+        /** 原价 */
+        const isOriginalPrice = priceType === 'markup' && priceTypeExt === 'product_price';
+        /** 加价 */
+        const isMarkupPrice = priceType === 'markup' && (priceTypeExt === '' || !priceTypeExt);
+
+        // 检查 rules
         if (rules.length > 0) {
-          const _isOriginalPrice = isOriginalPrice && rules.includes("original_price");
-          const _isMarkupPrice = isMarkupPrice && rules.includes("markup_price");
+          const _isOriginalPrice = isOriginalPrice && rules.includes('original_price');
+          const _isMarkupPrice = isMarkupPrice && rules.includes('markup_price');
+          // 价格是否符合规则：原价或加价
           const isPriceValid = _isOriginalPrice || _isMarkupPrice;
+          // 套餐适用范围校验
           let isScopeValid = false;
-          if (scopeType === "all_packages" || scopeType === "product_all") {
+
+          // 排除套餐判断, product_all值兼容旧数据
+          if (scopeType === 'all_packages' || scopeType === 'product_all') {
+            // 所有套餐可用
             if (!filter) {
               isScopeValid = true;
             } else {
-              isScopeValid = !exclude_bundle_product_ids.includes(Number(mainProductId));
+              isScopeValid = !exclude_bundle_product_ids.includes(Number(bundleMainProductId));
             }
           }
-          if (scopeType === "specific_packages" || scopeType === "products") {
-            isScopeValid = include_bundle_product_ids.includes(Number(mainProductId));
+
+          // 包含套餐判断, products值兼容旧数据
+          if (scopeType === 'specific_packages' || scopeType === 'products') {
+            isScopeValid = include_bundle_product_ids.includes(Number(bundleMainProductId));
           }
+
+          // 价格和套餐适用范围都符合，则可用
           if (isPriceValid && isScopeValid) {
             return true;
           }
+
+          // 检查原价
+          // if (isOriginalPrice && rules.includes('original_price')) {
+          //   return true;
+          // }
+
+          // 检查加价
+          // if (isMarkupPrice && rules.includes('markup_price')) {
+          //   return true;
+          // }
+
+          // 如果都不匹配，则不可用
           return false;
         }
+
+        // 原价包括：price_type: "markup" && price_type_ext: "product_price"
         return isOriginalPrice;
       }
       return true;
     }
-    if (ruleType === "package_exclusive") {
+
+    // package_exclusive: 仅在套餐中（子商品为原价）时可使用
+    if (ruleType === 'package_exclusive') {
       if (isMainProduct) {
-        return false;
+        return false; // 单独购买时不可用
       }
       if (isBundleItem) {
-        const priceType = (_f = flatItem.bundleItem) == null ? void 0 : _f.price_type;
-        const priceTypeExt = (_g = flatItem.bundleItem) == null ? void 0 : _g.price_type_ext;
-        const isOriginalPrice = priceType === "markup" && priceTypeExt === "product_price";
-        const isMarkupPrice = priceType === "markup" && (priceTypeExt === "" || !priceTypeExt);
+        // 套餐中购买时，判断是否为原价
+        const priceType = flatItem.bundleItem?.price_type;
+        const priceTypeExt = flatItem.bundleItem?.price_type_ext;
+
+        // original_price 对应：
+        // 1. price_type: "markup" && price_type_ext: "product_price"
+        // markup_price 对应：
+        // price_type: "markup" && price_type_ext: ""
+        /** 原价 */
+        const isOriginalPrice = priceType === 'markup' && priceTypeExt === 'product_price';
+        /** 加价 */
+        const isMarkupPrice = priceType === 'markup' && (priceTypeExt === '' || !priceTypeExt);
+
+        // 检查 rules
         if (rules.length > 0) {
-          if (isOriginalPrice && rules.includes("original_price")) {
-            return true;
+          const _isOriginalPrice = isOriginalPrice && rules.includes('original_price');
+          const _isMarkupPrice = isMarkupPrice && rules.includes('markup_price');
+          // 价格是否符合规则：原价或加价
+          const isPriceValid = _isOriginalPrice || _isMarkupPrice;
+          // 套餐适用范围校验
+          let isScopeValid = false;
+
+          // 排除套餐判断, product_all值兼容旧数据
+          if (scopeType === 'all_packages' || scopeType === 'product_all') {
+            // 所有套餐可用
+            if (!filter) {
+              isScopeValid = true;
+            } else {
+              isScopeValid = !exclude_bundle_product_ids.includes(Number(bundleMainProductId));
+            }
           }
-          if (isMarkupPrice && rules.includes("markup_price")) {
+
+          // 包含套餐判断, products值兼容旧数据
+          if (scopeType === 'specific_packages' || scopeType === 'products') {
+            isScopeValid = include_bundle_product_ids.includes(Number(bundleMainProductId));
+          }
+
+          // 价格和套餐适用范围都符合，则可用
+          if (isPriceValid && isScopeValid) {
             return true;
           }
+
+          // 检查原价
+          // if (isOriginalPrice && rules.includes('original_price')) {
+          //   return true;
+          // }
+
+          // 检查加价
+          // if (isMarkupPrice && rules.includes('markup_price')) {
+          //   return true;
+          // }
+
+          // 如果都不匹配，则不可用
           return false;
         }
+
+        // 原价包括：price_type: "markup" && price_type_ext: "product_price"
         return isOriginalPrice;
       }
       return false;
     }
-    if (ruleType === "single_item_promo") {
-      return isMainProduct;
+
+    // single_item_promo: 仅在单独购买时可使用
+    if (ruleType === 'single_item_promo') {
+      return isMainProduct; // 只有单独购买时可用
+    }
+
+    /*
+    // custom_usage_rules: 根据自定义规则判断
+    if (ruleType === 'custom_usage_rules') {
+      const customRules = usageRules.custom_usage_rules;
+       if (!customRules) {
+        return true; // 如果没有自定义规则，默认可用
+      }
+       const { types, package_sub_item_rules } = customRules;
+       // 判断商品类型是否在允许的类型中
+      if (isMainProduct) {
+        // 主商品对应 standalone_product
+        if (!types.includes('standalone_product')) {
+          return false;
+        }
+        return true; // 主商品不需要判断 package_sub_item_rules
+      }
+       if (isBundleItem) {
+        // bundle子商品对应 package_sub_item
+        if (!types.includes('package_sub_item')) {
+          return false;
+        }
+         // 如果包含 package_sub_item，还需要判断 price_type
+        const priceType = flatItem.bundleItem?.price_type;
+        const priceTypeExt = flatItem.bundleItem?.price_type_ext;
+         // 检查 package_sub_item_rules
+        if (package_sub_item_rules && package_sub_item_rules.length > 0) {
+          // original_price 对应：
+          // 1. price_type: "markup" && price_type_ext: "product_price"
+          // markup_price 对应：
+          // price_type: "markup" && price_type_ext: ""
+           const isOriginalPrice = (priceType === 'markup' && priceTypeExt === 'product_price');
+          const isMarkupPrice = priceType === 'markup' && (priceTypeExt === '' || !priceTypeExt);
+           if (isOriginalPrice && package_sub_item_rules.includes('original_price')) {
+            return true;
+          }
+           if (isMarkupPrice && package_sub_item_rules.includes('markup_price')) {
+            return true;
+          }
+           // 如果都不匹配，则不可用
+          return false;
+        }
+         return true; // 如果没有 package_sub_item_rules 配置，默认可用
+      }
+       return true;
     }
+    * */
+
+    // 默认可用
     return true;
   }
   async destroy() {
     this.core.effects.offByModuleDestroy(this.name);
     await this.core.effects.emit(`${this.name}:onDestroy`, {});
-    console.log("[Rules] 已销毁");
+    super.destroy();
   }
-  async clear() {
-    console.log("[Rules] clear");
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  RulesModule
-});
+  async clear() {}
+}
+exports.RulesModule = RulesModule;