@pisell/pisellos 0.0.337 → 0.0.339

package/dist/modules/Rules/index.js

@@ -24,7 +24,7 @@ function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key i
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { BaseModule } from "../BaseModule";
-import { uniqueById, getDiscountAmount } from "../../solution/ShopDiscount/utils";
+import { uniqueById, getDiscountAmount, getDiscountListAmountTotal, getDiscountListAmount } from "../../solution/ShopDiscount/utils";
 import { getProductOriginTotalPrice, getProductTotalPrice } from "../Cart/utils";
 import Decimal from 'decimal.js';
 import { isBoolean } from 'lodash-es';
@@ -187,6 +187,55 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         return !discount.isManualSelect;
       });
 
+      // 🔥 扁平化商品列表：将 bundle 子商品展开为虚拟商品
+      var flattenProductsWithBundle = function flattenProductsWithBundle(productList) {
+        var flattened = [];
+        productList.forEach(function (originProduct) {
+          var product = _this3.hooks.getProduct(originProduct);
+
+          // 1. 添加主商品
+          flattened.push({
+            type: 'main',
+            originProduct: originProduct,
+            product: product,
+            price: Number(product.price || 0),
+            id: product.id,
+            _id: product._id,
+            parentId: product._id,
+            quantity: product.quantity,
+            num: product.num
+          });
+
+          // 2. 展开 bundle 子商品
+          if (product.bundle && Array.isArray(product.bundle) && product.bundle.length > 0) {
+            product.bundle.forEach(function (bundleItem, bundleIndex) {
+              flattened.push({
+                type: 'bundle',
+                originProduct: originProduct,
+                parentProduct: product,
+                bundleItem: bundleItem,
+                bundleIndex: bundleIndex,
+                // 虚拟商品属性
+                price: Number(bundleItem.price || 0),
+                id: bundleItem._bundle_product_id,
+                // 🔥 使用 _bundle_product_id
+                _id: "".concat(product._id, "_bundle_").concat(bundleIndex),
+                parentId: product._id,
+                num: bundleItem.num || 1,
+                quantity: bundleItem.num || 1,
+                total: new Decimal(bundleItem.price || 0).mul(bundleItem.num || 1).toNumber(),
+                origin_total: new Decimal(bundleItem.price || 0).mul(bundleItem.num || 1).toNumber(),
+                original_price: bundleItem.original_price,
+                // 继承主商品属性
+                booking_id: product.booking_id,
+                discount_list: []
+              });
+            });
+          }
+        });
+        return flattened;
+      };
+
       // 优惠力度排序，传进来的数据里可能有商品券，也可能有优惠券
       // 1. 商品券（n.tag=good_pass）视为最优惠（免费）
       // 2. 折扣券（n.tag=product_discount_card）按照新的优先级排序：
@@ -222,12 +271,12 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
             }
           }
 
-          // 3. 都是百分比时，折扣越大越优先（par_value越小越优先）
+          // 3. 都是百分比时，折扣越大越优先（par_value越大越优先）
           if (typeA === 'percent' && typeB === 'percent') {
             if (a.par_value !== b.par_value) {
               var _valueA = new Decimal(100).minus(a.par_value || 0);
               var _valueB = new Decimal(100).minus(b.par_value || 0);
-              return _valueB.minus(_valueA).toNumber(); // 折扣大的在前
+              return _valueA.minus(_valueB).toNumber(); // 折扣大的在前
             }
           }
 
@@ -261,21 +310,50 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
       //   }
       // })
 
+      // 🔥 扁平化商品列表（包含主商品和bundle子商品）
+      var flattenedList = flattenProductsWithBundle(productList);
+
+      // 对扁平化后的列表按价格降序排序（用于应用优惠券时优先选择高价商品）
+      var sortedFlattenedList = flattenedList.sort(function (a, b) {
+        var priceA = new Decimal(a.price || '0');
+        var priceB = new Decimal(b.price || '0');
+        if (priceA.equals(priceB)) {
+          // 价格相同时，主商品优先
+          if (a.type !== b.type) {
+            return a.type === 'main' ? -1 : 1;
+          }
+          // 都是主商品时，按原有逻辑排序
+          if (a.type === 'main' && b.type === 'main') {
+            if (a.product.quantity === b.product.quantity) {
+              var _b$product$discount_l, _a$product$discount_l;
+              return (((_b$product$discount_l = b.product.discount_list) === null || _b$product$discount_l === void 0 ? void 0 : _b$product$discount_l.length) || 0) - (((_a$product$discount_l = a.product.discount_list) === null || _a$product$discount_l === void 0 ? void 0 : _a$product$discount_l.length) || 0);
+            }
+            return a.product.quantity - b.product.quantity;
+          }
+          // 都是bundle时，按数量排序
+          if (a.type === 'bundle' && b.type === 'bundle') {
+            return (a.num || 1) - (b.num || 1);
+          }
+        }
+        return priceB.minus(priceA).toNumber();
+      });
+
+      /**
       // 对productList按价格降序排序（用于应用优惠券时优先选择高价商品） 价格相同时使用quantity 排序
-      var sortedProductList = _toConsumableArray(productList).sort(function (a, b) {
-        var aProduct = _this3.hooks.getProduct(a);
-        var bProduct = _this3.hooks.getProduct(b);
-        var priceA = new Decimal(aProduct.price || '0');
-        var priceB = new Decimal(bProduct.price || '0');
+      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) {
-            var _bProduct$discount_li, _aProduct$discount_li;
-            return ((_bProduct$discount_li = bProduct.discount_list) === null || _bProduct$discount_li === void 0 ? void 0 : _bProduct$discount_li.length) - ((_aProduct$discount_li = aProduct.discount_list) === null || _aProduct$discount_li === void 0 ? void 0 : _aProduct$discount_li.length);
+            return bProduct.discount_list?.length - aProduct.discount_list?.length;
           }
           return aProduct.quantity - bProduct.quantity;
         }
         return priceB.toNumber() - priceA.toNumber();
       });
+       */
 
       // 标记已使用的优惠券
       var usedDiscounts = new Map();
@@ -299,19 +377,39 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
       var appliedDiscountProducts = new Map();
 
       // 首先遍历所有商品和所有优惠券，确定每个优惠券的适用范围，包括isSelected为false的优惠券
-      sortedProductList.forEach(function (originProduct) {
-        var product = _this3.hooks.getProduct(originProduct);
+      // 🔥 使用扁平化后的列表，包含主商品和bundle子商品
+      sortedFlattenedList.forEach(function (flatItem) {
+        // 获取商品数据
+        var product, originProduct;
+        if (flatItem.type === 'main') {
+          product = flatItem.product;
+          originProduct = flatItem.originProduct;
+        } else {
+          // bundle子商品：构造虚拟商品对象
+          product = {
+            _id: flatItem._id,
+            id: flatItem.id,
+            price: flatItem.price,
+            quantity: flatItem.quantity,
+            num: flatItem.num,
+            total: flatItem.total,
+            origin_total: flatItem.origin_total,
+            booking_id: flatItem.booking_id,
+            discount_list: []
+          };
+          originProduct = flatItem.originProduct;
+        }
         addModeDiscount.forEach(function (discount) {
-          var _product$discount_lis2, _product$discount_lis3;
+          var _product, _product2, _product3, _flatItem$bundleItem;
           var limitedData = discount === null || discount === void 0 ? void 0 : discount.limited_relation_product_data;
 
           // 是符合折扣的商品
           var isLimitedProduct = limitedData.type === 'product_all' || limitedData.product_ids && limitedData.product_ids.includes(product.id);
 
           // 编辑的商品 使用了优惠券不可用
-          var isAvailableProduct = !(product !== null && product !== void 0 && product.booking_id && product !== null && product !== void 0 && (_product$discount_lis2 = product.discount_list) !== null && _product$discount_lis2 !== void 0 && _product$discount_lis2.length && product !== null && product !== void 0 && (_product$discount_lis3 = product.discount_list) !== null && _product$discount_lis3 !== void 0 && _product$discount_lis3.every(function (discount) {
+          var isAvailableProduct = flatItem.type === 'main' ? !((_product = product) !== null && _product !== void 0 && _product.booking_id && (_product2 = product) !== null && _product2 !== void 0 && (_product2 = _product2.discount_list) !== null && _product2 !== void 0 && _product2.length && (_product3 = product) !== null && _product3 !== void 0 && (_product3 = _product3.discount_list) !== null && _product3 !== void 0 && _product3.every(function (discount) {
             return discount.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type);
-          }));
+          })) : !(flatItem !== null && flatItem !== void 0 && flatItem.booking_id && flatItem !== null && flatItem !== void 0 && (_flatItem$bundleItem = flatItem.bundleItem) !== null && _flatItem$bundleItem !== void 0 && (_flatItem$bundleItem = _flatItem$bundleItem.metadata) !== null && _flatItem$bundleItem !== void 0 && _flatItem$bundleItem.custom_product_bundle_map_id);
 
           // 判断优惠券是否适用于该商品
           if (isAvailableProduct && isLimitedProduct) {
@@ -331,7 +429,7 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
                 fixed_amount: product.price,
                 resource_id: discount.id,
                 title: discount.format_title,
-                original_amount: product.origin_total,
+                original_amount: product.price || product.origin_total,
                 pre_value: discount.par_value,
                 product_id: originProduct.id
               }
@@ -346,27 +444,60 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           }
         });
       });
-      console.log(sortedProductList, 'sortedProductListsortedProductList');
+
+      // 🔥 用于存储扁平化商品处理结果的Map
+      var processedFlatItemsMap = new Map();
 
       // 然后再处理应用哪些优惠券，此时只考虑filteredDiscountList中的优惠券
-      sortedProductList.forEach(function (originProduct, index) {
-        var _product$discount_lis4, _product$discount_lis5, _product$discount_lis7, _product$discount_lis8, _product$discount_lis9, _product$discount_lis10, _product$discount_lis11;
-        var product = _this3.hooks.getProduct(originProduct);
-        if (product !== null && product !== void 0 && product.booking_id && (_product$discount_lis4 = product.discount_list) !== null && _product$discount_lis4 !== void 0 && _product$discount_lis4.length && product !== null && product !== void 0 && (_product$discount_lis5 = product.discount_list) !== null && _product$discount_lis5 !== void 0 && _product$discount_lis5.every(function (discount) {
+      // 🔥 使用扁平化后的列表进行处理
+      sortedFlattenedList.forEach(function (flatItem, index) {
+        var _product4, _product$discount_lis2, _product5, _product$discount_lis4, _product6, _product6$every, _product$discount_lis5, _product$discount_lis6;
+        // 获取商品数据
+        var product, originProduct;
+        if (flatItem.type === 'main') {
+          product = flatItem.product;
+          originProduct = flatItem.originProduct;
+        } else {
+          var _flatItem$bundleItem2, _flatItem$bundleItem3, _flatItem$bundleItem4;
+          // bundle子商品
+          product = {
+            _id: flatItem._id,
+            id: flatItem.id,
+            price: flatItem.price,
+            quantity: flatItem.quantity,
+            num: flatItem.num,
+            total: flatItem.total,
+            original_price: flatItem === null || flatItem === void 0 || (_flatItem$bundleItem2 = flatItem.bundleItem) === null || _flatItem$bundleItem2 === void 0 ? void 0 : _flatItem$bundleItem2.original_price,
+            origin_total: flatItem === null || flatItem === void 0 || (_flatItem$bundleItem3 = flatItem.bundleItem) === null || _flatItem$bundleItem3 === void 0 ? void 0 : _flatItem$bundleItem3.original_price,
+            booking_id: flatItem.booking_id,
+            discount_list: (flatItem === null || flatItem === void 0 || (_flatItem$bundleItem4 = flatItem.bundleItem) === null || _flatItem$bundleItem4 === void 0 ? void 0 : _flatItem$bundleItem4.discount_list) || []
+          };
+          originProduct = flatItem.originProduct;
+        }
+
+        // 已有优惠的商品跳过
+        if ((_product4 = product) !== null && _product4 !== void 0 && _product4.booking_id && (_product$discount_lis2 = product.discount_list) !== null && _product$discount_lis2 !== void 0 && _product$discount_lis2.length && (_product5 = product) !== null && _product5 !== void 0 && (_product5 = _product5.discount_list) !== null && _product5 !== void 0 && _product5.every(function (discount) {
           return discount.id && ['good_pass', 'discount_card', 'product_discount_card'].includes(discount.tag || discount.type);
         })) {
-          processedProductsMap.set(product._id, [originProduct]);
+          if (flatItem.type === 'main') {
+            processedProductsMap.set(product._id, [originProduct]);
+          } else {
+            processedFlatItemsMap.set(flatItem._id, [_objectSpread(_objectSpread({}, flatItem), {}, {
+              processed: true
+            })]);
+          }
           return;
         }
 
         // 找到适用于此商品的所有优惠券，仅考虑isSelected不为false的优惠券
         var applicableDiscounts = sortedDiscountList.filter(function (discount) {
-          var _product$discount_lis6;
+          var _product$discount_lis3;
           // 如果商品价格为 0，其实不需要使用任何优惠券，直接 return true
-          // 商品券时主商品价格小于等于0不可用
-          if ((Number(product.price) <= 0 || !product.price) && (discount.tag || discount.type) === 'good_pass') return false;
-          // 折扣卡时总价小于等于0时不可用
-          if ((Number(product.total) <= 0 || !product.total) && !((_product$discount_lis6 = product.discount_list) !== null && _product$discount_lis6 !== void 0 && _product$discount_lis6.find(function (n) {
+          // 商品券时主商品价格为0不可用
+          if ((Number(product.price) <= 0 || !product.price) && flatItem.type === 'main' && (discount.tag || discount.type) === 'good_pass') return false;
+
+          // 折扣卡时总价为0时不可用
+          if ((Number(product.total) <= 0 || !product.total) && !((_product$discount_lis3 = product.discount_list) !== null && _product$discount_lis3 !== void 0 && _product$discount_lis3.find(function (n) {
             var _n$discount;
             return ((_n$discount = n.discount) === null || _n$discount === void 0 ? void 0 : _n$discount.resource_id) === discount.id;
           })) && (discount.tag || discount.type) !== 'good_pass') return false;
@@ -377,8 +508,16 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
 
           // 判断优惠券是否适用于该商品
           if (limitedData.type === 'product_all') {
+            // 检查 package_sub_item_usage_rules
+            if (!_this3.checkPackageSubItemUsageRules(discount, flatItem)) {
+              return false;
+            }
             return true;
           } else if (limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
+            // 检查 package_sub_item_usage_rules
+            if (!_this3.checkPackageSubItemUsageRules(discount, flatItem)) {
+              return false;
+            }
             return true;
           }
           return false;
@@ -393,18 +532,21 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         var selectedDiscount = selectedDiscountCard || applicableDiscounts[0];
 
         // 如果是手动折扣，则不适用优惠券
-        var isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.total != product.origin_total && (!((_product$discount_lis7 = product.discount_list) !== null && _product$discount_lis7 !== void 0 && _product$discount_lis7.length) || (product === null || product === void 0 || (_product$discount_lis8 = product.discount_list) === null || _product$discount_lis8 === void 0 || (_product$discount_lis9 = _product$discount_lis8.every) === null || _product$discount_lis9 === void 0 ? void 0 : _product$discount_lis9.call(_product$discount_lis8, function (item) {
+        var isManualDiscount = typeof product.isManualDiscount === 'boolean' ? product.isManualDiscount : product.total != product.origin_total && flatItem.type === 'main' && (product.bundle || []).every(function (item) {
+          var _ref3;
+          return !((_ref3 = item.discount_list || []) !== null && _ref3 !== void 0 && _ref3.length);
+        }) && (!((_product$discount_lis4 = product.discount_list) !== null && _product$discount_lis4 !== void 0 && _product$discount_lis4.length) || ((_product6 = product) === null || _product6 === void 0 || (_product6 = _product6.discount_list) === null || _product6 === void 0 || (_product6$every = _product6.every) === null || _product6$every === void 0 ? void 0 : _product6$every.call(_product6, function (item) {
           return item.type === 'product';
         })));
 
         // 勾选时覆盖手动折扣
-        if (options !== null && options !== void 0 && options.discountId && (_product$discount_lis10 = product.discount_list) !== null && _product$discount_lis10 !== void 0 && _product$discount_lis10.some(function (item) {
+        if (options !== null && options !== void 0 && options.discountId && (_product$discount_lis5 = product.discount_list) !== null && _product$discount_lis5 !== void 0 && _product$discount_lis5.some(function (item) {
           var _item$discount;
           return ((_item$discount = item.discount) === null || _item$discount === void 0 ? void 0 : _item$discount.resource_id) === options.discountId;
         })) {
           isManualDiscount = false;
         }
-        if (options !== null && options !== void 0 && options.selectedList && (_product$discount_lis11 = product.discount_list) !== null && _product$discount_lis11 !== void 0 && _product$discount_lis11.some(function (item) {
+        if (options !== null && options !== void 0 && options.selectedList && (_product$discount_lis6 = product.discount_list) !== null && _product$discount_lis6 !== void 0 && _product$discount_lis6.some(function (item) {
           var _options$selectedList;
           return options === null || options === void 0 || (_options$selectedList = options.selectedList) === null || _options$selectedList === void 0 ? void 0 : _options$selectedList.some(function (n) {
             var _item$discount2;
@@ -415,38 +557,47 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         }
 
         // 如果没有适用的优惠券，或者手动折扣，则不适用优惠券
-        // 自定义商品：如果未开启适用折扣卡（product.vouchersApplicable），则不适用优惠券
         if (applicableDiscounts.length === 0 || isManualDiscount || isBoolean(product.vouchersApplicable) && !product.vouchersApplicable) {
-          if (product.isClient) {
-            processedProductsMap.set(product._id, [_this3.hooks.setProduct(originProduct, _objectSpread(_objectSpread({}, isManualDiscount ? {} : {
-              origin_total: getProductOriginTotalPrice({
-                product: {
-                  original_price: product.original_price
-                },
-                bundle: product.bundle,
-                options: product.options
-              }),
-              variant: originProduct._productInit.variant,
-              original_price: originProduct._productInit.original_price,
-              total: getProductTotalPrice({
-                product: {
-                  price: product.price
-                },
-                bundle: product.bundle,
-                options: product.options
-              }),
-              price: product.price
-            }), {}, {
-              discount_list: []
-            }))]);
+          if (flatItem.type === 'main') {
+            // 主商品：保持原有逻辑
+            if (product.isClient) {
+              processedProductsMap.set(product._id, [_this3.hooks.setProduct(originProduct, _objectSpread(_objectSpread({}, isManualDiscount ? {} : {
+                origin_total: getProductOriginTotalPrice({
+                  product: {
+                    original_price: product.original_price
+                  },
+                  bundle: product.bundle,
+                  options: product.options
+                }),
+                variant: originProduct._productInit.variant,
+                original_price: originProduct._productInit.original_price,
+                total: getProductTotalPrice({
+                  product: {
+                    price: product.price
+                  },
+                  bundle: product.bundle,
+                  options: product.options
+                }),
+                price: product.price
+              }), {}, {
+                discount_list: []
+              }))]);
+            } else {
+              processedProductsMap.set(product._id, [_this3.hooks.setProduct(originProduct, _objectSpread(_objectSpread({}, isManualDiscount ? {} : {
+                _id: product._id.split('___')[0] + '___' + index,
+                total: product.origin_total || product.total,
+                price: product.price
+              }), {}, {
+                discount_list: []
+              }))]);
+            }
           } else {
-            processedProductsMap.set(product._id, [_this3.hooks.setProduct(originProduct, _objectSpread(_objectSpread({}, isManualDiscount ? {} : {
-              _id: product._id.split('___')[0] + '___' + index,
-              total: product.origin_total || product.total,
-              price: product.price
-            }), {}, {
-              discount_list: []
-            }))]);
+            // bundle子商品：保存到扁平化Map
+            processedFlatItemsMap.set(flatItem._id, [_objectSpread(_objectSpread({}, flatItem), {}, {
+              discount_list: [],
+              price: flatItem.bundleItem.original_price,
+              processed: true
+            })]);
           }
           return;
         }
@@ -454,137 +605,547 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
           return;
         }
 
-        // 是否需要拆分
+        // 是否需要拆分（商品券需要拆分）
         var isNeedSplit = (selectedDiscount.tag || selectedDiscount.type) === 'good_pass';
 
         // 需要拆分出来的数量
-        var splitCount = isNeedSplit ? Math.min(product.quantity || product.num || 1, applicableDiscounts.filter(function (item) {
+        var totalQuantity = product.quantity || product.num || 1;
+        var availableGoodPassCount = applicableDiscounts.filter(function (item) {
           return (item.tag || item.type) === 'good_pass';
-        }).length) : 1;
+        }).length;
+        var splitCount = isNeedSplit ? Math.min(product.quantity || product.num || 1, availableGoodPassCount) : 1;
         var arr = [];
-        if (splitCount < product.quantity && isNeedSplit) {
-          arr.push(_this3.hooks.setProduct(originProduct, {
-            discount_list: [],
-            quantity: product.quantity - splitCount,
-            _id: product._id.split('___')[0]
-          }));
-        }
-        for (var i = 0; i < splitCount; i++) {
-          var _product$discount_lis12, _originProduct$_produ, _selectedDiscount$met;
-          // 如果用过折扣卡，也就不存在拆分的情况了，这里直接使用上面计算出来的折扣卡
-          var _selectedDiscount = selectedDiscountCard || applicableDiscounts[i];
-          // 标记优惠券为已使用
-          usedDiscounts.set(_selectedDiscount.id, true);
-
-          // 记录实际应用了优惠券的商品信息
-          var appliedProducts = appliedDiscountProducts.get(_selectedDiscount.id) || [];
-
-          // 优先从 origin_total拿，可能会拿不到（比如用户端预约在没有配置 original_price 的情况下）
-          var productOriginTotal = product.origin_total || product.total || 0;
-          // 如果当前 product 有 discount_list，则先从 origin_total 拿
-          if ((_product$discount_lis12 = product.discount_list) !== null && _product$discount_lis12 !== void 0 && _product$discount_lis12.length && product.origin_total) {
-            productOriginTotal = product.origin_total;
-          }
-          // 如果originProduct?._productInit?.original_price为 0，product.origin_total可能为空，此时取 product.total
-          if (Number((originProduct === null || originProduct === void 0 || (_originProduct$_produ = originProduct._productInit) === null || _originProduct$_produ === void 0 ? void 0 : _originProduct$_produ.original_price) || 0) > 0 && product.origin_total && product.total && product.origin_total !== product.total) {
-            productOriginTotal = product.total;
+
+        // 🔥 主商品和bundle子商品分别处理
+        if (flatItem.type === 'main') {
+          // 主商品：保持原有逻辑
+          if (splitCount < totalQuantity && isNeedSplit) {
+            arr.push(_this3.hooks.setProduct(originProduct, {
+              discount_list: [],
+              quantity: totalQuantity - splitCount,
+              _id: product._id.split('___')[0]
+            }));
           }
+          for (var i = 0; i < splitCount; i++) {
+            var _product$discount_lis7, _originProduct, _selectedDiscount$met;
+            // 如果用过折扣卡，也就不存在拆分的情况了，这里直接使用上面计算出来的折扣卡
+            var _selectedDiscount = selectedDiscountCard || applicableDiscounts[i];
+            // 标记优惠券为已使用
+            usedDiscounts.set(_selectedDiscount.id, true);
 
-          // 计算使用折扣卡/商品券以后，单个商品的总 total
-          var targetProductTotal = getDiscountAmount(_selectedDiscount, productOriginTotal, product.price);
-          var discountType = _selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : _selectedDiscount.tag;
-          var discountDetail = {
-            amount: new Decimal(productOriginTotal).minus(new Decimal(targetProductTotal)).toNumber(),
-            type: discountType,
-            discount: {
-              discount_card_type: _selectedDiscount === null || _selectedDiscount === void 0 || (_selectedDiscount$met = _selectedDiscount.metadata) === null || _selectedDiscount$met === void 0 ? void 0 : _selectedDiscount$met.discount_card_type,
-              fixed_amount: new Decimal(productOriginTotal).minus(new Decimal(targetProductTotal)).toNumber(),
-              resource_id: _selectedDiscount.id,
-              title: _selectedDiscount.format_title,
-              original_amount: productOriginTotal,
-              product_id: originProduct.id,
-              percent: _selectedDiscount.par_value
+            // 记录实际应用了优惠券的商品信息
+            var appliedProducts = appliedDiscountProducts.get(_selectedDiscount.id) || [];
+
+            // 优先从 origin_total拿，可能会拿不到（比如用户端预约在没有配置 original_price 的情况下）
+            var productOriginTotal = product.origin_total || product.total || 0;
+            // 如果当前 product 有 discount_list，则先从 origin_total 拿
+            if ((_product$discount_lis7 = product.discount_list) !== null && _product$discount_lis7 !== void 0 && _product$discount_lis7.length && product.origin_total) {
+              productOriginTotal = product.origin_total;
             }
-          };
+            // 如果originProduct?._productInit?.original_price为 0，product.origin_total可能为空，此时取 product.total
+            if (Number(((_originProduct = originProduct) === null || _originProduct === void 0 || (_originProduct = _originProduct._productInit) === null || _originProduct === void 0 ? void 0 : _originProduct.original_price) || 0) > 0 && product.origin_total && product.total && product.origin_total !== product.total) {
+              productOriginTotal = product.total;
+            }
+
+            // 计算使用折扣卡/商品券以后，单个商品的总 total
+            var targetProductTotal = getDiscountAmount(_selectedDiscount, product.price, product.price);
+            var discountType = _selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : _selectedDiscount.tag;
+            var discountDetail = {
+              amount: new Decimal(product.price).minus(new Decimal(targetProductTotal)).toNumber(),
+              type: discountType,
+              discount: {
+                discount_card_type: _selectedDiscount === null || _selectedDiscount === void 0 || (_selectedDiscount$met = _selectedDiscount.metadata) === null || _selectedDiscount$met === void 0 ? void 0 : _selectedDiscount$met.discount_card_type,
+                fixed_amount: new Decimal(product.price).minus(new Decimal(targetProductTotal)).toNumber(),
+                resource_id: _selectedDiscount.id,
+                title: _selectedDiscount.format_title,
+                original_amount: product.price,
+                product_id: originProduct.id,
+                percent: _selectedDiscount.par_value
+              }
+            };
 
-          // 如果 discount.tag 或者 discount.type 是 good_pass，则不需要添加 num 属性
-          if ((_selectedDiscount.tag || _selectedDiscount.type) !== 'good_pass') {
-            discountDetail.num = product.num || 1;
+            // 如果 discount.tag 或者 discount.type 是 good_pass，则不需要添加 num 属性
+            if ((_selectedDiscount.tag || _selectedDiscount.type) !== 'good_pass') {
+              discountDetail.num = product.num || 1;
+            }
+            appliedProducts.push(discountDetail);
+            appliedDiscountProducts.set(_selectedDiscount.id, appliedProducts);
+
+            // 记录应用了优惠券的商品
+            // 后续更新价格改为 getProductTotalPrice getProductOriginTotalPrice逻辑
+            if (product.isClient) {
+              arr.push(_this3.hooks.setProduct(originProduct, {
+                discount_list: [discountDetail],
+                price: _selectedDiscount.tag === 'good_pass' ? 0 : product.price,
+                quantity: isNeedSplit ? 1 : product.quantity,
+                origin_total: getProductOriginTotalPrice({
+                  product: {
+                    original_price: product.original_price
+                  },
+                  bundle: product.bundle,
+                  options: product.options
+                }),
+                variant: originProduct._productInit.variant,
+                original_price: new Decimal(product.price || 0).toNumber(),
+                total: targetProductTotal
+              }));
+            } else {
+              arr.push(_this3.hooks.setProduct(originProduct, {
+                discount_list: [discountDetail],
+                _id: product._id.split('___')[0] + "___" + _selectedDiscount.id + index,
+                price: _selectedDiscount.tag === 'good_pass' ? 0 : product.price,
+                quantity: isNeedSplit ? 1 : product.quantity,
+                total: targetProductTotal,
+                origin_total: productOriginTotal
+              }));
+            }
           }
-          appliedProducts.push(discountDetail);
-          appliedDiscountProducts.set(_selectedDiscount.id, appliedProducts);
+          processedProductsMap.set(product._id, arr);
+        } else {
+          // 🔥 bundle子商品：支持拆分
+          var processedItems = [];
+          if (isNeedSplit) {
+            // 商品券：需要拆分数量
+            var discountNum = splitCount;
+            var normalNum = totalQuantity - discountNum;
 
-          // 记录应用了优惠券的商品
-          // 后续更新价格改为 getProductTotalPrice getProductOriginTotalPrice逻辑
-          if (product.isClient) {
-            arr.push(_this3.hooks.setProduct(originProduct, {
-              discount_list: [discountDetail],
-              price: _selectedDiscount.tag === 'good_pass' ? 0 : product.price,
-              quantity: isNeedSplit ? 1 : product.quantity,
-              origin_total: getProductOriginTotalPrice({
-                product: {
-                  original_price: product.original_price
+            // 生成有折扣的商品（每张商品券对应 num: 1）
+            for (var _i = 0; _i < discountNum; _i++) {
+              var _selectedDiscount2 = applicableDiscounts[_i];
+              usedDiscounts.set(_selectedDiscount2.id, true);
+
+              // 🔥 生成唯一的 _id
+              var uniqueId = "".concat(flatItem._id, "_split_").concat(_i);
+              var _discountDetail = {
+                amount: product.origin_total,
+                type: 'good_pass',
+                discount: {
+                  resource_id: _selectedDiscount2.id,
+                  title: _selectedDiscount2.format_title,
+                  original_amount: product.origin_total,
+                  product_id: product.id
                 },
-                bundle: product.bundle,
-                options: product.options
-              }),
-              variant: originProduct._productInit.variant,
-              original_price: new Decimal(product.price || 0).toNumber(),
-              total: targetProductTotal
-            }));
+                metadata: {
+                  // 🔥 使用拆分后的唯一 _id
+                  custom_product_bundle_map_id: uniqueId,
+                  num: 1
+                },
+                num: 1
+              };
+
+              // 记录实际应用的折扣
+              var _appliedProducts = appliedDiscountProducts.get(_selectedDiscount2.id) || [];
+              _appliedProducts.push(_discountDetail);
+              appliedDiscountProducts.set(_selectedDiscount2.id, _appliedProducts);
+              processedItems.push(_objectSpread(_objectSpread({}, flatItem), {}, {
+                // 🔥 使用唯一的 _id
+                _id: uniqueId,
+                num: 1,
+                quantity: 1,
+                price: 0,
+                // 商品券价格为0
+                total: 0,
+                discount_list: [_discountDetail],
+                processed: true,
+                _discountId: _selectedDiscount2.id
+              }));
+            }
+
+            // 生成无折扣的商品（剩余数量）
+            if (normalNum > 0) {
+              processedItems.push(_objectSpread(_objectSpread({}, flatItem), {}, {
+                // 🔥 为剩余商品生成唯一的 _id
+                _id: "".concat(flatItem._id, "_split_rest"),
+                num: normalNum,
+                quantity: normalNum,
+                discount_list: [],
+                processed: true
+              }));
+            }
           } else {
-            arr.push(_this3.hooks.setProduct(originProduct, {
-              discount_list: [discountDetail],
-              _id: product._id.split('___')[0] + "___" + _selectedDiscount.id + "___" + index,
-              price: _selectedDiscount.tag === 'good_pass' ? 0 : product.price,
-              quantity: isNeedSplit ? 1 : product.quantity,
-              total: targetProductTotal,
-              origin_total: productOriginTotal
+            var _selectedDiscount3$me;
+            // 折扣卡：不拆分数量，直接应用
+            var _selectedDiscount3 = selectedDiscountCard || applicableDiscounts[0];
+            usedDiscounts.set(_selectedDiscount3.id, true);
+            var _productOriginTotal = product.original_price || product.price || 0;
+            var _targetProductTotal = getDiscountAmount(_selectedDiscount3, _productOriginTotal, _productOriginTotal);
+
+            // 🔥 使用当前的 _id 作为唯一标识
+            var _uniqueId = flatItem._id;
+            var _discountDetail2 = {
+              amount: new Decimal(_productOriginTotal).minus(_targetProductTotal).toNumber(),
+              type: _selectedDiscount3.tag === 'product_discount_card' ? 'discount_card' : _selectedDiscount3.tag,
+              discount: {
+                discount_card_type: _selectedDiscount3 === null || _selectedDiscount3 === void 0 || (_selectedDiscount3$me = _selectedDiscount3.metadata) === null || _selectedDiscount3$me === void 0 ? void 0 : _selectedDiscount3$me.discount_card_type,
+                fixed_amount: new Decimal(_productOriginTotal).minus(_targetProductTotal).toNumber(),
+                resource_id: _selectedDiscount3.id,
+                title: _selectedDiscount3.format_title,
+                original_amount: product.original_price,
+                product_id: product.id,
+                percent: _selectedDiscount3.par_value
+              },
+              metadata: {
+                // 🔥 使用唯一的 _id
+                custom_product_bundle_map_id: _uniqueId,
+                num: product.num || 1
+              },
+              num: product.num || 1
+            };
+
+            // 记录实际应用的折扣
+            var _appliedProducts2 = appliedDiscountProducts.get(_selectedDiscount3.id) || [];
+            _appliedProducts2.push(_discountDetail2);
+            appliedDiscountProducts.set(_selectedDiscount3.id, _appliedProducts2);
+            processedItems.push(_objectSpread(_objectSpread({}, flatItem), {}, {
+              total: _targetProductTotal,
+              price: new Decimal(_productOriginTotal || 0).minus(_discountDetail2.amount).toNumber(),
+              discount_list: [_discountDetail2],
+              processed: true
             }));
           }
+          processedFlatItemsMap.set(flatItem._id, processedItems);
         }
-        console.log(arr, 'arrarrarr');
-        processedProductsMap.set(product._id, arr);
       });
 
-      // 按原始顺序构建处理后的商品列表
-      var processedProductList = [];
-      productList.forEach(function (originProduct) {
-        var product = _this3.hooks.getProduct(originProduct);
-        var getDefaultProduct = function getDefaultProduct() {
-          if (product.isClient) {
-            return _this3.hooks.setProduct(originProduct, {
-              discount_list: [],
-              price: product.price,
-              origin_total: getProductOriginTotalPrice({
-                product: {
-                  original_price: product.original_price
-                },
-                bundle: product.bundle,
-                options: product.options
-              }),
-              variant: originProduct._productInit.variant,
-              original_price: originProduct._productInit.original_price,
-              total: getProductTotalPrice({
-                product: {
+      // 🔥 重组：将处理后的bundle子商品重新组装回主商品
+      var reconstructProductsWithBundle = function reconstructProductsWithBundle(processedProductsMap, processedFlatItemsMap, originalProductList) {
+        var result = [];
+        originalProductList.forEach(function (originProduct) {
+          var product = _this3.hooks.getProduct(originProduct);
+
+          // 获取主商品处理结果
+          var mainProductArr = processedProductsMap.get(product._id);
+          if (!mainProductArr || mainProductArr.length === 0) {
+            // 如果没有处理结果，返回默认商品
+            var getDefaultProduct = function getDefaultProduct() {
+              if (product.isClient) {
+                return _this3.hooks.setProduct(originProduct, {
+                  discount_list: [],
+                  price: product.price,
+                  origin_total: getProductOriginTotalPrice({
+                    product: {
+                      original_price: product.original_price
+                    },
+                    bundle: product.bundle,
+                    options: product.options
+                  }),
+                  variant: originProduct._productInit.variant,
+                  original_price: originProduct._productInit.original_price,
+                  total: getProductTotalPrice({
+                    product: {
+                      price: product.price
+                    },
+                    bundle: product.bundle,
+                    options: product.options
+                  })
+                });
+              } else {
+                return _this3.hooks.setProduct(originProduct, {
+                  discount_list: [],
+                  total: product.total,
+                  origin_total: product.origin_total,
                   price: product.price
-                },
-                bundle: product.bundle,
-                options: product.options
-              })
-            });
+                });
+              }
+            };
+            result.push(getDefaultProduct());
+            return;
+          }
+
+          // 检查是否有bundle子商品需要重组
+          var hasBundle = product.bundle && Array.isArray(product.bundle) && product.bundle.length > 0;
+          if (!hasBundle) {
+            // 没有bundle，直接使用主商品处理结果
+            result.push.apply(result, _toConsumableArray(mainProductArr));
           } else {
-            return _this3.hooks.setProduct(originProduct, {
-              discount_list: [],
-              total: product.total,
-              origin_total: product.origin_total,
-              price: product.price
-            });
+            // 🔥 有bundle，需要检查子商品是否应用了商品券
+            // 1. 先收集所有bundle子商品的处理结果
+            var bundleProcessingInfo = new Map();
+            var hasGoodPassApplied = false; // 标记是否有子商品应用了商品券
+
+            if (product.bundle && Array.isArray(product.bundle)) {
+              product.bundle.forEach(function (bundleItem, bundleIndex) {
+                var bundleItemId = "".concat(product._id, "_bundle_").concat(bundleIndex);
+                var processedBundleItems = processedFlatItemsMap.get(bundleItemId);
+                if (!processedBundleItems || processedBundleItems.length === 0) {
+                  // 未处理的bundle item，保持原样
+                  bundleProcessingInfo.set(bundleIndex, [bundleItem]);
+                } else {
+                  // 处理过的bundle item
+                  bundleProcessingInfo.set(bundleIndex, processedBundleItems);
+                  // 🔥 检查是否应用了商品券（good_pass）
+                  var hasGoodPass = processedBundleItems.some(function (item) {
+                    var _item$discount_list;
+                    return (_item$discount_list = item.discount_list) === null || _item$discount_list === void 0 ? void 0 : _item$discount_list.some(function (discount) {
+                      return discount.type === 'good_pass' || discount.tag === 'good_pass';
+                    });
+                  });
+                  if (hasGoodPass) {
+                    hasGoodPassApplied = true;
+                  }
+                }
+              });
+            }
+
+            // 🔥 2. 如果有子商品应用了商品券，且主商品数量大于1，需要拆分主商品
+            var mainProductQuantity = mainProductArr[0] ? _this3.hooks.getProduct(mainProductArr[0]).quantity : 1;
+            if (hasGoodPassApplied && mainProductArr.length === 1 && mainProductQuantity > 1) {
+              var mainProduct = mainProductArr[0];
+              var mainProductData = _this3.hooks.getProduct(mainProduct);
+
+              // 🔥 方案：拆分成2个主商品
+              // 1. 一个主商品(qty=1)包含拆分后的bundle
+              // 2. 一个主商品(qty=原quantity-1)包含原始未拆分的bundle
+
+              // 第一个：包含拆分后的bundle (qty=1)
+              var newBundleWithDiscount = [];
+              (product.bundle || []).forEach(function (bundleItem, bundleIndex) {
+                var processedItems = bundleProcessingInfo.get(bundleIndex) || [bundleItem];
+                if (processedItems.length > 1) {
+                  // 被拆分的子商品，添加所有拆分项
+                  processedItems.forEach(function (item) {
+                    // 🔥 更新 discount_list 中的 num，使其与拆分后的 item.num 一致
+                    var updatedDiscountList = (item.discount_list || []).map(function (discount) {
+                      return _objectSpread(_objectSpread({}, discount), {}, {
+                        num: item.num // 使用拆分后的 num
+                      });
+                    });
+                    newBundleWithDiscount.push(_objectSpread(_objectSpread({}, bundleItem), {}, {
+                      _id: item._id,
+                      product_id: bundleItem.product_id,
+                      price: item.price,
+                      num: item.num,
+                      discount_list: updatedDiscountList
+                    }));
+                  });
+                } else {
+                  // 未拆分的子商品，保持原样
+                  var item = processedItems[0];
+                  if (item.processed) {
+                    // 🔥 同样需要更新 discount_list 中的 num
+                    var _updatedDiscountList = (item.discount_list || []).map(function (discount) {
+                      return _objectSpread(_objectSpread({}, discount), {}, {
+                        num: item.num // 使用当前的 num
+                      });
+                    });
+                    newBundleWithDiscount.push(_objectSpread(_objectSpread({}, bundleItem), {}, {
+                      _id: item._id,
+                      product_id: bundleItem.product_id,
+                      price: item.price,
+                      num: item.num,
+                      discount_list: _updatedDiscountList
+                    }));
+                  } else {
+                    newBundleWithDiscount.push(item);
+                  }
+                }
+              });
+
+              // 计算第一个主商品的总价（包含拆分后的bundle）
+              var newTotalWithDiscount = Number(mainProductData.price || 0);
+              var newOriginTotalWithDiscount = Number(mainProductData.original_price || mainProductData.price || 0);
+              if (newBundleWithDiscount.length > 0) {
+                newBundleWithDiscount.forEach(function (item) {
+                  newTotalWithDiscount += Number(item.price) * Number(item.num);
+                });
+                newBundleWithDiscount.forEach(function (item) {
+                  var _item$discount_list2;
+                  var originalPrice = ((_item$discount_list2 = item.discount_list) === null || _item$discount_list2 === void 0 || (_item$discount_list2 = _item$discount_list2[0]) === null || _item$discount_list2 === void 0 || (_item$discount_list2 = _item$discount_list2.discount) === null || _item$discount_list2 === void 0 ? void 0 : _item$discount_list2.original_amount) || item.price;
+                  newOriginTotalWithDiscount += Number(originalPrice) * Number(item.num);
+                });
+              }
+
+              // 🔥 更新主商品自己的 discount_list 中的 num（quantity=1）
+              var updatedMainDiscountList = mainProductData.discount_list.map(function (discount) {
+                var _discount$metadata2;
+                if (discount !== null && discount !== void 0 && (_discount$metadata2 = discount.metadata) !== null && _discount$metadata2 !== void 0 && _discount$metadata2.custom_product_bundle_map_id) {
+                  // bundle的discount_list保持不变
+                  return discount;
+                }
+                // 主商品自己的discount，更新num为1
+                return _objectSpread(_objectSpread({}, discount), {}, {
+                  num: 1
+                });
+              });
+
+              // 🔥 使用更新后的列表计算折扣金额
+              var mainDiscountList = updatedMainDiscountList.filter(function (item) {
+                var _item$metadata;
+                return !(item !== null && item !== void 0 && (_item$metadata = item.metadata) !== null && _item$metadata !== void 0 && _item$metadata.custom_product_bundle_map_id);
+              });
+              if (mainDiscountList && mainDiscountList.length > 0) {
+                var allDiscountAmount = getDiscountListAmountTotal(mainDiscountList);
+                newTotalWithDiscount = new Decimal(mainProductData.price || 0).minus(allDiscountAmount).toNumber() || newTotalWithDiscount;
+                newOriginTotalWithDiscount = mainProductData.origin_total || newOriginTotalWithDiscount;
+                if (newBundleWithDiscount.length > 0) {
+                  newBundleWithDiscount.forEach(function (item) {
+                    var _item$discount_list3;
+                    newTotalWithDiscount += Number(item.price) * Number(item.num);
+                    var originalPrice = ((_item$discount_list3 = item.discount_list) === null || _item$discount_list3 === void 0 || (_item$discount_list3 = _item$discount_list3[0]) === null || _item$discount_list3 === void 0 || (_item$discount_list3 = _item$discount_list3.discount) === null || _item$discount_list3 === void 0 ? void 0 : _item$discount_list3.original_amount) || item.price;
+                    newOriginTotalWithDiscount += Number(originalPrice) * Number(item.num);
+                  });
+                }
+              }
+
+              // 添加第一个主商品：qty=1，包含拆分后的bundle
+              result.push(_this3.hooks.setProduct(mainProduct, _objectSpread(_objectSpread({}, mainProductData), {}, {
+                _id: "".concat(mainProductData._id.split('___')[0], "___split_discount"),
+                quantity: 1,
+                discount_list: updatedMainDiscountList,
+                bundle: newBundleWithDiscount,
+                total: newTotalWithDiscount,
+                origin_total: newOriginTotalWithDiscount
+              })));
+
+              // 第二个：包含原始bundle (qty=原quantity-1)
+              if (mainProductQuantity > 1) {
+                var newBundleOriginal = [];
+                (product.bundle || []).forEach(function (bundleItem, bundleIndex) {
+                  // 使用原始的bundle配置，不包含拆分
+                  newBundleOriginal.push(_objectSpread(_objectSpread({}, bundleItem), {}, {
+                    discount_list: []
+                  }));
+                });
+
+                // 计算第二个主商品的总价
+                var newTotalOriginal = Number(mainProductData.price || 0);
+                var newOriginTotalOriginal = Number(mainProductData.original_price || mainProductData.price || 0);
+                if (newBundleOriginal.length > 0) {
+                  newBundleOriginal.forEach(function (item) {
+                    newTotalOriginal += Number(item.price) * Number(item.num);
+                    newOriginTotalOriginal += Number(item.price) * Number(item.num);
+                  });
+                }
+
+                // 🔥 更新主商品自己的 discount_list 中的 num（quantity=原quantity-1）
+                var updatedMainDiscountListOriginal = mainProductData.discount_list.map(function (discount) {
+                  var _discount$metadata3;
+                  if (discount !== null && discount !== void 0 && (_discount$metadata3 = discount.metadata) !== null && _discount$metadata3 !== void 0 && _discount$metadata3.custom_product_bundle_map_id) {
+                    // bundle的discount_list保持不变
+                    return discount;
+                  }
+                  // 主商品自己的discount，更新num为 mainProductQuantity - 1
+                  return _objectSpread(_objectSpread({}, discount), {}, {
+                    num: mainProductQuantity - 1
+                  });
+                });
+
+                // 🔥 使用更新后的列表计算折扣金额
+                var mainDiscountListOriginal = updatedMainDiscountListOriginal.filter(function (item) {
+                  var _item$metadata2;
+                  return !(item !== null && item !== void 0 && (_item$metadata2 = item.metadata) !== null && _item$metadata2 !== void 0 && _item$metadata2.custom_product_bundle_map_id);
+                });
+                if (mainDiscountListOriginal && mainDiscountListOriginal.length > 0) {
+                  var _allDiscountAmount = getDiscountListAmount(mainDiscountListOriginal);
+                  newTotalOriginal = new Decimal(mainProductData.price || 0).minus(_allDiscountAmount).toNumber() || newTotalOriginal;
+                  newOriginTotalOriginal = mainProductData.origin_total || newOriginTotalOriginal;
+                  if (newBundleOriginal.length > 0) {
+                    newBundleOriginal.forEach(function (item) {
+                      newTotalOriginal += Number(item.price) * Number(item.num);
+                      newOriginTotalOriginal += Number(item.price) * Number(item.num);
+                    });
+                  }
+                }
+
+                // 添加第二个主商品：qty=原quantity-1，包含原始bundle
+                result.push(_this3.hooks.setProduct(mainProduct, _objectSpread(_objectSpread({}, mainProductData), {}, {
+                  _id: "".concat(mainProductData._id.split('___')[0], "___split_normal"),
+                  quantity: mainProductQuantity - 1,
+                  discount_list: updatedMainDiscountListOriginal,
+                  bundle: newBundleOriginal,
+                  total: newTotalOriginal,
+                  origin_total: newOriginTotalOriginal
+                })));
+              }
+            } else {
+              // 🔥 没有子商品被拆分，使用原有逻辑
+              mainProductArr.forEach(function (mainProduct) {
+                var mainProductData = _this3.hooks.getProduct(mainProduct);
+
+                // 重组bundle
+                var newBundle = [];
+                if (product.bundle && Array.isArray(product.bundle)) {
+                  product.bundle.forEach(function (bundleItem, bundleIndex) {
+                    var bundleItemId = "".concat(product._id, "_bundle_").concat(bundleIndex);
+                    var processedBundleItems = processedFlatItemsMap.get(bundleItemId);
+                    if (!processedBundleItems || processedBundleItems.length === 0) {
+                      // 未处理的bundle item，保持原样
+                      newBundle.push(bundleItem);
+                    } else {
+                      // 🔥 关键：拆分后的bundle item
+                      processedBundleItems.forEach(function (item) {
+                        // 🔥 更新 discount_list 中的 num，使其与拆分后的 item.num 一致
+                        var updatedDiscountList = (item.discount_list || []).map(function (discount) {
+                          return _objectSpread(_objectSpread({}, discount), {}, {
+                            num: item.num // 使用拆分后的 num
+                          });
+                        });
+                        newBundle.push(_objectSpread(_objectSpread({}, bundleItem), {}, {
+                          _id: item._id,
+                          product_id: bundleItem.product_id,
+                          price: item.price,
+                          num: item.num,
+                          discount_list: updatedDiscountList
+                        }));
+                      });
+                    }
+                  });
+                }
+
+                // 🔥 重新计算主商品的总价（包含bundle）
+                var newTotal = Number(mainProductData.price || 0);
+                var newOriginTotal = Number(mainProductData.original_price || mainProductData.price || 0);
+
+                // 累加bundle的价格
+                if (newBundle.length > 0) {
+                  newBundle.forEach(function (item) {
+                    newTotal += Number(item.price) * Number(item.num);
+                  });
+
+                  // 计算原始总价（不考虑折扣）
+                  newBundle.forEach(function (item) {
+                    var _item$discount_list4;
+                    var originalPrice = ((_item$discount_list4 = item.discount_list) === null || _item$discount_list4 === void 0 || (_item$discount_list4 = _item$discount_list4[0]) === null || _item$discount_list4 === void 0 || (_item$discount_list4 = _item$discount_list4.discount) === null || _item$discount_list4 === void 0 ? void 0 : _item$discount_list4.original_amount) || item.price;
+                    newOriginTotal += Number(originalPrice) * Number(item.num);
+                  });
+                }
+                var mainDiscountList = mainProductData.discount_list.filter(function (item) {
+                  var _item$metadata3;
+                  return !(item !== null && item !== void 0 && (_item$metadata3 = item.metadata) !== null && _item$metadata3 !== void 0 && _item$metadata3.custom_product_bundle_map_id);
+                });
+
+                // 如果主商品本身有折扣，需要重新计算
+                if (mainDiscountList && mainDiscountList.length > 0) {
+                  var _allDiscountAmount2 = getDiscountListAmount(mainDiscountList);
+                  newTotal = new Decimal(mainProductData.price || 0).minus(_allDiscountAmount2).toNumber() || newTotal;
+                  newOriginTotal = mainProductData.origin_total || newOriginTotal;
+
+                  // 累加bundle的价格
+                  if (newBundle.length > 0) {
+                    newBundle.forEach(function (item) {
+                      var _item$discount_list5;
+                      newTotal += Number(item.price) * Number(item.num);
+                      var originalPrice = ((_item$discount_list5 = item.discount_list) === null || _item$discount_list5 === void 0 || (_item$discount_list5 = _item$discount_list5[0]) === null || _item$discount_list5 === void 0 || (_item$discount_list5 = _item$discount_list5.discount) === null || _item$discount_list5 === void 0 ? void 0 : _item$discount_list5.original_amount) || item.price;
+                      newOriginTotal += Number(originalPrice) * Number(item.num);
+                    });
+                  }
+                }
+
+                // 生成最终的主商品
+                result.push(_this3.hooks.setProduct(mainProduct, _objectSpread(_objectSpread({}, mainProductData), {}, {
+                  bundle: newBundle,
+                  total: newTotal,
+                  origin_total: newOriginTotal
+                })));
+              });
+            }
           }
-        };
-        var arr = processedProductsMap.get(product._id);
-        arr !== null && arr !== void 0 && arr.length ? processedProductList.push.apply(processedProductList, _toConsumableArray(arr)) : processedProductList.push(getDefaultProduct());
-      });
+        });
+        return result;
+      };
+
+      // 按原始顺序构建处理后的商品列表
+      var processedProductList = reconstructProductsWithBundle(processedProductsMap, processedFlatItemsMap, productList);
 
       // 按原始顺序更新优惠券列表，标记已使用和可用的优惠券
       var updatedDiscountList = addModeDiscount.map(function (discount) {
@@ -655,6 +1216,119 @@ export var RulesModule = /*#__PURE__*/function (_BaseModule) {
         discountList: [].concat(editModeDiscount, _toConsumableArray(updatedDiscountList))
       };
     }
+
+    /**
+     * 检查优惠是否符合 PackageSubItemUsageRules 配置
+     * @param discount 优惠券
+     * @param flatItem 扁平化后的商品项（可能是主商品或bundle子商品）
+     * @returns 是否可用
+     */
+  }, {
+    key: "checkPackageSubItemUsageRules",
+    value: function checkPackageSubItemUsageRules(discount, flatItem) {
+      var limitedData = discount.limited_relation_product_data;
+      var usageRules = limitedData === null || limitedData === void 0 ? void 0 : limitedData.package_sub_item_usage_rules;
+
+      // 如果没有配置 package_sub_item_usage_rules，则默认可用
+      if (!usageRules) {
+        return true;
+      }
+      var ruleType = usageRules.type;
+      var isMainProduct = flatItem.type === 'main'; // 单独购买
+      var isBundleItem = flatItem.type === 'bundle'; // 套餐中购买
+
+      // universal_discount: 单独购买和套餐中（子商品为原价）均可使用
+      if (ruleType === 'universal_discount') {
+        if (isMainProduct) {
+          return true; // 单独购买时可用
+        }
+        if (isBundleItem) {
+          var _flatItem$bundleItem5, _flatItem$bundleItem6;
+          // 套餐中购买时，判断是否为原价
+          var priceType = (_flatItem$bundleItem5 = flatItem.bundleItem) === null || _flatItem$bundleItem5 === void 0 ? void 0 : _flatItem$bundleItem5.price_type;
+          var priceTypeExt = (_flatItem$bundleItem6 = flatItem.bundleItem) === null || _flatItem$bundleItem6 === void 0 ? void 0 : _flatItem$bundleItem6.price_type_ext;
+          // 原价包括：price_type: "markup" && price_type_ext: "product_price"
+          return priceType === 'markup' && priceTypeExt === 'product_price';
+        }
+        return true;
+      }
+
+      // package_exclusive: 仅在套餐中（子商品为原价）时可使用
+      if (ruleType === 'package_exclusive') {
+        if (isMainProduct) {
+          return false; // 单独购买时不可用
+        }
+        if (isBundleItem) {
+          var _flatItem$bundleItem7, _flatItem$bundleItem8;
+          // 套餐中购买时，判断是否为原价
+          var _priceType = (_flatItem$bundleItem7 = flatItem.bundleItem) === null || _flatItem$bundleItem7 === void 0 ? void 0 : _flatItem$bundleItem7.price_type;
+          var _priceTypeExt = (_flatItem$bundleItem8 = flatItem.bundleItem) === null || _flatItem$bundleItem8 === void 0 ? void 0 : _flatItem$bundleItem8.price_type_ext;
+          // 原价包括：price_type: "markup" && price_type_ext: "product_price"
+          return _priceType === 'markup' && _priceTypeExt === 'product_price';
+        }
+        return false;
+      }
+
+      // single_item_promo: 仅在单独购买时可使用
+      if (ruleType === 'single_item_promo') {
+        return isMainProduct; // 只有单独购买时可用
+      }
+
+      // custom_usage_rules: 根据自定义规则判断
+      if (ruleType === 'custom_usage_rules') {
+        var customRules = usageRules.custom_usage_rules;
+        if (!customRules) {
+          return true; // 如果没有自定义规则，默认可用
+        }
+        var types = customRules.types,
+          package_sub_item_rules = customRules.package_sub_item_rules;
+
+        // 判断商品类型是否在允许的类型中
+        if (isMainProduct) {
+          // 主商品对应 standalone_product
+          if (!types.includes('standalone_product')) {
+            return false;
+          }
+          return true; // 主商品不需要判断 package_sub_item_rules
+        }
+        if (isBundleItem) {
+          var _flatItem$bundleItem9, _flatItem$bundleItem10;
+          // bundle子商品对应 package_sub_item
+          if (!types.includes('package_sub_item')) {
+            return false;
+          }
+
+          // 如果包含 package_sub_item，还需要判断 price_type
+          var _priceType2 = (_flatItem$bundleItem9 = flatItem.bundleItem) === null || _flatItem$bundleItem9 === void 0 ? void 0 : _flatItem$bundleItem9.price_type;
+          var _priceTypeExt2 = (_flatItem$bundleItem10 = flatItem.bundleItem) === null || _flatItem$bundleItem10 === void 0 ? void 0 : _flatItem$bundleItem10.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: ""
+
+            var isOriginalPrice = _priceType2 === 'markup' && _priceTypeExt2 === 'product_price';
+            var isMarkupPrice = _priceType2 === 'markup' && (_priceTypeExt2 === '' || !_priceTypeExt2);
+            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;
+    }
   }, {
     key: "destroy",
     value: function () {