@pisell/pisellos 0.0.569 → 0.10.2

package/lib/modules/Rules/index.js

@@ -1,32 +1,58 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/modules/Rules/index.ts
+var Rules_exports = {};
+__export(Rules_exports, {
+  RulesModule: () => RulesModule
 });
-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;
+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 {
   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?.hooks;
-    this.store = options?.store;
-    this.window = core.getPlugin('window');
+    this.hooks = options == null ? void 0 : options.hooks;
+    this.store = options == null ? void 0 : options.store;
+    this.window = core.getPlugin("window");
   }
   async setRulesList(rulesList) {
     this.store.rulesList = rulesList;
@@ -36,25 +62,22 @@ class RulesModule extends _BaseModule.BaseModule {
     return this.store.rulesList;
   }
   getWalletPassEvaluator() {
-    return this.window.getWalletPassEvaluator?.();
+    var _a, _b;
+    return (_b = (_a = this.window).getWalletPassEvaluator) == null ? void 0 : _b.call(_a);
   }
-
   // 商品不需要holder,则不需要判断，直接返回true，商品需要holder但是还没填写，那么暂时不使用带有holder的券，直到填写才去匹配
   checkHolderMatch(discount, product, holders) {
-    // 非表单类型 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;
+    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 || holders[0] : void 0;
     const productHolderId = Array.isArray(product.holder_id) ? product.holder_id[0] : product.holder_id;
-    // 商品不需要选holder，则不对比holder，直接返回true，
-    if (!product.isNeedHolder) return true;
-    // 商品需要holder，但父预约及商品都无holder，返回false
-    if (!orderHolderId && !productHolderId) return false;
-    // 最终直接匹配 holder 是否相同
+    if (!product.isNeedHolder)
+      return true;
+    if (!orderHolderId && !productHolderId)
+      return false;
     return (productHolderId || orderHolderId) === discount.holder.holder_id;
   }
-
   // 判断discountList 是否可以对当前productList生效
   isDiscountListAvailable({
     oldDiscountList,
@@ -64,7 +87,6 @@ class RulesModule extends _BaseModule.BaseModule {
     holders,
     isFormSubject
   }) {
-    // 首先检查是否有新的优惠券可应用
     if (!newDiscountList || newDiscountList.length === 0) {
       return {
         isAvailable: false,
@@ -72,58 +94,57 @@ class RulesModule extends _BaseModule.BaseModule {
         productList
       };
     }
-
-    // 编辑商品已有商品券
-    if (productList.every(item => {
+    if (productList.every((item) => {
+      var _a;
       const product = this.hooks.getProduct(item);
-      return product.booking_id && (product.discount_list?.length || product.total == 0);
+      return product.booking_id && (((_a = product.discount_list) == null ? void 0 : _a.length) || product.total == 0);
     })) {
       return {
         isAvailable: false,
         discountList: oldDiscountList,
         productList,
-        unavailableReason: _types.UnavailableReason.AlreadyUsed
+        unavailableReason: import_types.UnavailableReason.AlreadyUsed
       };
     }
-
-    // 合并新旧折扣列表，并计算折扣结果,注意，如果旧折扣里有 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],
-      orderTotalAmount,
-      holders,
-      isFormSubject
-    }, {
-      scan: true
-    });
-
-    // 检查是否有产品使用了新折扣
+    const filteredOldDiscountList = oldDiscountList.filter(
+      (discount) => !discount.isEditMode && (discount.tag !== "good_pass" || discount.isScan)
+    );
+    const mergedDiscountList = (0, import_utils.uniqueById)([
+      ...filteredOldDiscountList,
+      ...newDiscountList
+    ]);
+    const result = this.calcDiscount(
+      {
+        discountList: mergedDiscountList,
+        productList: [...productList],
+        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?.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 == null ? void 0 : item.discount_list) || []);
       });
       if (allDiscountList && allDiscountList.length > 0) {
-        // 检查是否有使用新折扣的情况
-        const usedNewDiscount = allDiscountList.some(discount => newDiscountIds.includes(discount?.discount?.resource_id));
+        const usedNewDiscount = allDiscountList.some(
+          (discount) => {
+            var _a;
+            return newDiscountIds.includes((_a = discount == null ? void 0 : discount.discount) == null ? void 0 : _a.resource_id);
+          }
+        );
         if (usedNewDiscount) {
           hasApplicableDiscount = true;
         }
       }
     });
-
-    // 如果券不可用，判断不可用原因
     let unavailableReason;
     if (!hasApplicableDiscount) {
       unavailableReason = this.getUnavailableReason(newDiscountList, productList);
@@ -136,51 +157,47 @@ class RulesModule extends _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);
+    return (discountList || []).filter((item) => item.type !== type && item.tag !== type);
   }
-
   /** 手动改价场景：去掉 promotion，保留 type=product 等行内折扣 */
   resolveDiscountListForManualOverride(discountList) {
-    return this.excludeDiscountListByType(discountList, 'promotion');
+    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?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss');
-        const filteredList = (0, _utils.filterDiscountListByBookingTime)([discount], bookingTime);
+        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);
         if (filteredList.length === 0) {
-          return _types.UnavailableReason.TimeLimit;
+          return import_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 (limitedData.product_ids?.includes(product.id)) {
+        } else if ((_a = limitedData.product_ids) == null ? void 0 : _a.includes(product.id)) {
           hasApplicableProduct = true;
           break;
         }
       }
       if (!hasApplicableProduct) {
-        return _types.UnavailableReason.ProductNotApplicable;
+        return import_types.UnavailableReason.ProductNotApplicable;
       }
     }
-    return _types.UnavailableReason.Unknown;
+    return import_types.UnavailableReason.Unknown;
   }
   calcDiscount({
     discountList,
@@ -189,84 +206,83 @@ class RulesModule extends _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;
+    var _a;
+    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 == null ? void 0 : options.reapplyBookingDiscountProductUids) || []).filter((uid) => uid !== void 0 && uid !== null && uid !== "").map(String)
+    );
+    const getOriginProductUid = (originProduct) => {
+      var _a2;
+      const uid = ((_a2 = originProduct == null ? void 0 : originProduct.metadata) == null ? void 0 : _a2.unique_identification_number) ?? (originProduct == null ? void 0 : originProduct.unique_identification_number);
+      if (uid === void 0 || uid === null || uid === "")
+        return void 0;
       return String(uid);
     };
     const shouldReapplyBookingDiscount = (originProduct, selectedDiscount) => {
-      if (!selectedDiscount) return false;
+      if (!selectedDiscount)
+        return false;
       const uid = getOriginProductUid(originProduct);
-      if (!uid || !reapplyBookingDiscountProductUids.has(uid)) return false;
+      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);
+      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;
+      var _a2;
+      if (!shouldReapplyBookingDiscount(originProduct, selectedDiscount))
+        return void 0;
+      const discountType = (selectedDiscount == null ? void 0 : selectedDiscount.tag) || (selectedDiscount == null ? void 0 : selectedDiscount.type);
+      if (discountType !== "discount_card" && discountType !== "product_discount_card") {
+        return void 0;
       }
-      const percent = Number(selectedDiscount.discount?.percent);
-      return Number.isFinite(percent) ? percent : undefined;
+      const percent = Number((_a2 = selectedDiscount.discount) == null ? void 0 : _a2.percent);
+      return Number.isFinite(percent) ? percent : void 0;
     };
     const editModeDiscount = [];
     const addModeDiscount = [];
-    discountList.forEach(discount => {
+    discountList.forEach((discount) => {
       if (discount.isEditMode) {
         editModeDiscount.push(discount);
       } else {
         addModeDiscount.push(discount);
       }
     });
-
-    // 🔥 检查 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);
+    const editModeOrderLevelProductIds = /* @__PURE__ */ new Set();
+    editModeDiscount.forEach((discount) => {
+      var _a2, _b;
+      if (((_a2 = discount.discount) == null ? void 0 : _a2.discount_calculation_mode) === "order_level") {
+        editModeOrderLevelProductIds.add((_b = discount == null ? void 0 : discount.discount) == null ? void 0 : _b.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 hasDiscountInput = editModeDiscount.length > 0 || addModeDiscount.length > 0 || Boolean(options?.discountId) || Boolean(options?.selectedList?.length) || Boolean(options?.scan);
+    const hasDiscountInput = editModeDiscount.length > 0 || addModeDiscount.length > 0 || Boolean(options == null ? void 0 : options.discountId) || Boolean((_a = options == null ? void 0 : options.selectedList) == null ? void 0 : _a.length) || Boolean(options == null ? void 0 : options.scan);
     if (!hasDiscountInput) {
       return {
         discountList,
         productList
       };
     }
-    const canUseEditModeDiscountForReapply = discount => {
+    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);
+      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 filteredDiscountList = [
+      ...addModeDiscount.filter((discount) => !discount.isManualSelect),
+      ...editModeDiscount.filter(canUseEditModeDiscountForReapply)
+    ];
+    const flattenProductsWithBundle = (productList2) => {
       const flattened = [];
-      productList.forEach(originProduct => {
+      productList2.forEach((originProduct) => {
         const product = this.hooks.getProduct(originProduct);
-
-        // 1. 添加主商品
         flattened.push({
-          type: 'main',
+          type: "main",
           originProduct,
           product,
           price: Number(product.price || 0),
@@ -277,12 +293,10 @@ class RulesModule extends _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,
@@ -295,8 +309,8 @@ class RulesModule extends _BaseModule.BaseModule {
               parentId: product._id,
               num: bundleItem.num || 1,
               quantity: bundleItem.num || 1,
-              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(),
+              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(),
               original_price: bundleItem.original_price,
               // 继承主商品属性
               booking_id: bundleItem.booking_id,
@@ -307,157 +321,120 @@ class RulesModule extends _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) => {
-      // 辅助函数：判断是否是带有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 isHolderDiscount = (discount) => {
+        var _a2, _b;
+        return ((_b = (_a2 = discount.metadata) == null ? void 0 : _a2.holder) == null ? void 0 : _b.type) === "custom";
+      };
+      const isGoodPass = (discount) => discount.tag === "good_pass";
+      const isOrderLevelDiscount = (discount) => {
+        var _a2;
+        return discount.tag === "product_discount_card" && ((_a2 = discount.metadata) == null ? void 0 : _a2.discount_calculation_mode) === "order_level";
+      };
+      const isItemLevelDiscount = (discount) => {
+        var _a2;
+        return discount.tag === "product_discount_card" && ((_a2 = discount.metadata) == null ? void 0 : _a2.discount_calculation_mode) !== "order_level";
+      };
+      const getPriority = (discount) => {
         const isHolder = isHolderDiscount(discount);
         if (isHolder) {
-          if (isGoodPass(discount)) return 1; // 带有Holder的商品券
-          if (isItemLevelDiscount(discount)) return 2; // 带有Holder的商品级折扣卡
-          if (isOrderLevelDiscount(discount)) return 3; // 带有Holder的订单级折扣卡
+          if (isGoodPass(discount))
+            return 1;
+          if (isItemLevelDiscount(discount))
+            return 2;
+          if (isOrderLevelDiscount(discount))
+            return 3;
         } else {
-          if (isGoodPass(discount)) return 4; // Customer商品券
-          if (isItemLevelDiscount(discount)) return 5; // Customer商品级折扣卡
-          if (isOrderLevelDiscount(discount)) return 6; // Customer订单级固定金额折扣
+          if (isGoodPass(discount))
+            return 4;
+          if (isItemLevelDiscount(discount))
+            return 5;
+          if (isOrderLevelDiscount(discount))
+            return 6;
         }
-        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) {
-        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') {
+        var _a2, _b;
+        const typeA = ((_a2 = itemA.metadata) == null ? void 0 : _a2.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") {
           if (itemA.par_value !== itemB.par_value) {
-            const valueA = new _decimal.default(itemA.par_value || 0);
-            const valueB = new _decimal.default(itemB.par_value || 0);
-            return valueB.minus(valueA).toNumber(); // 金额大的在前
+            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();
           }
         }
-
-        // 3. 都是百分比时，折扣越大越优先（par_value越大越优先）
-        if (typeA === 'percent' && typeB === 'percent') {
+        if (typeA === "percent" && typeB === "percent") {
           if (itemA.par_value !== itemB.par_value) {
-            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(); // 折扣大的在前
+            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();
           }
         }
         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);
       }
-
-      // 如果是折扣卡（优先级2、3、5、6），按折扣力度排序，然后按过期时间
-      if (a.tag === 'product_discount_card' && b.tag === 'product_discount_card') {
+      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 sortedFlattenedList = flattenedList.sort((a, b) => {
-      // 子商品优先使用 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');
+      var _a2, _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"
+      );
       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 (b.product.discount_list?.length || 0) - (a.product.discount_list?.length || 0);
+            return (((_a2 = b.product.discount_list) == null ? void 0 : _a2.length) || 0) - (((_b = a.product.discount_list) == null ? void 0 : _b.length) || 0);
           }
           return a.product.quantity - b.product.quantity;
         }
-        // 都是bundle时，按数量排序
-        if (a.type === 'bundle' && b.type === '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 => {
+      addModeDiscount.forEach((discount) => {
+        var _a2, _b;
         const discountType = discount.tag || discount.type;
-        // 只对 good_pass 和 discount_card 类型执行策略检查
-        if (['good_pass', 'discount_card', 'product_discount_card'].includes(discountType)) {
-          // 转换 discount 为 Voucher 格式
+        if (["good_pass", "discount_card", "product_discount_card"].includes(
+          discountType
+        )) {
           const voucher = {
             id: discount.id,
             amount: Number(discount.par_value || 0),
@@ -465,27 +442,24 @@ class RulesModule extends _BaseModule.BaseModule {
             type: discountType,
             product_id: discount.product_id,
             unified_available_status: 1,
-            available_product_type: discount.limited_relation_product_data?.type,
-            available_product_ids: discount.limited_relation_product_data?.product_ids
+            available_product_type: (_a2 = discount.limited_relation_product_data) == null ? void 0 : _a2.type,
+            available_product_ids: (_b = discount.limited_relation_product_data) == null ? void 0 : _b.product_ids
           };
-
-          // 转换 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 productsForEvaluate = sortedFlattenedList.map((item) => {
+            var _a3;
+            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" ? (_a3 = item.product) == null ? void 0 : _a3.options : void 0
+            };
+          });
           const result = evaluator.checkVoucherAvailability({
-            orderTotalAmount: orderTotalAmount,
+            orderTotalAmount,
             products: productsForEvaluate,
             vouchers: [voucher]
           });
-
-          // 将 config 附加到 discount 对象
           if (result.isAvailable) {
             discount.config = {
               ...result.config,
@@ -499,74 +473,21 @@ class RulesModule extends _BaseModule.BaseModule {
         }
       });
     }
-    // 检查商品是否被排除（全品类）
-    const isProductIncludedByLimitedData = (limitedData, productId) => {
-      const excludedIds = limitedData?.exclude_product_ids || [];
-      const isExcluded = limitedData?.filter === 1 && excludedIds.some(id => String(id) === String(productId));
-      return !isExcluded;
-    };
-
-    /**
-    // 对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)) {
-        const currentCount = usedDiscountCardLimitCounts.get(discount.id) || 0;
-        usedDiscountCardLimitCounts.set(discount.id, currentCount + (discount.metadata?.num || 1));
-      }
-    });
-
-    // 记录每个优惠券适用的商品ID
-    const discountApplicability = new Map();
-
-    // 记录每个优惠券适用的商品详细信息
-    const discountApplicableProducts = new Map();
-
-    // 初始化每个优惠券的适用性和可抵扣商品
-    addModeDiscount.forEach(discount => {
+    const usedDiscounts = /* @__PURE__ */ new Map();
+    const usedProductIdCounts = /* @__PURE__ */ new Map();
+    const discountApplicability = /* @__PURE__ */ new Map();
+    const discountApplicableProducts = /* @__PURE__ */ new Map();
+    addModeDiscount.forEach((discount) => {
       discountApplicability.set(discount.id, []);
       discountApplicableProducts.set(discount.id, []);
     });
-
-    // 预处理 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 orderLevelDiscountAllocations = /* @__PURE__ */ new Map();
+    const orderLevelDiscountApplicableItems = /* @__PURE__ */ new Map();
+    const itemApplicableDiscounts = /* @__PURE__ */ new Map();
     const checkItemApplicableForDiscount = (flatItem, discount) => {
+      var _a2, _b, _c, _d, _e, _f, _g, _h;
       let product;
-      if (flatItem.type === 'main') {
+      if (flatItem.type === "main") {
         product = flatItem.product;
       } else {
         product = {
@@ -577,38 +498,27 @@ class RulesModule extends _BaseModule.BaseModule {
           num: flatItem.num,
           booking_id: flatItem.booking_id,
           discount_list: flatItem.discount_list || [],
-          startDate: flatItem.parentProduct?.startDate
+          startDate: (_a2 = flatItem.parentProduct) == null ? void 0 : _a2.startDate
         };
       }
-
-      // 编辑的商品使用了优惠券不可用
-      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));
+      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)));
       if (!isAvailableProduct) {
         return false;
       }
-
-      // vouchersApplicable 为 false 的商品不参与订单级别折扣均摊
-      if ((0, _lodashEs.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
+      if ((0, import_lodash_es.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, _utils.filterDiscountListByBookingTime)([discount], (product?.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss')).length;
+      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;
       if (!timeLimit) {
         return false;
       }
-
-      // 判断商品是否适用
       let isLimitedProduct = false;
-      if (limitedData.type === 'product_all') {
-        // 全品类，但需要检查是否被排除
-        if (limitedData.filter === 1 && limitedData.exclude_product_ids?.includes(product.id)) {
+      if (limitedData.type === "product_all") {
+        if (limitedData.filter === 1 && ((_h = limitedData.exclude_product_ids) == null ? void 0 : _h.includes(product.id))) {
           isLimitedProduct = false;
         } else {
           isLimitedProduct = true;
@@ -616,51 +526,33 @@ class RulesModule extends _BaseModule.BaseModule {
       } else if (limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
         isLimitedProduct = true;
       }
-
-      // 套餐规则检查
       const isBundleAvailable = this.checkPackageSubItemUsageRules(discount, flatItem);
       return isLimitedProduct && isBundleAvailable;
     };
-
-    // 收集所有被勾选的 order_level 折扣卡及其适用商品
-    const selectedOrderLevelDiscounts = sortedDiscountList.filter(discount => {
-      return (0, _utils.isOrderLevelFixedAmountDiscount)(discount) && discount.isSelected !== false;
+    const selectedOrderLevelDiscounts = sortedDiscountList.filter((discount) => {
+      return (0, import_utils3.isOrderLevelFixedAmountDiscount)(discount) && discount.isSelected !== false;
     });
-
-    // 遍历所有被勾选的 order_level 折扣卡，建立双向映射
-    selectedOrderLevelDiscounts.forEach(discount => {
-      const applicableItemIds = new Set();
-      sortedFlattenedList.forEach(flatItem => {
+    selectedOrderLevelDiscounts.forEach((discount) => {
+      const applicableItemIds = /* @__PURE__ */ new Set();
+      sortedFlattenedList.forEach((flatItem) => {
         if (checkItemApplicableForDiscount(flatItem, discount)) {
           applicableItemIds.add(flatItem._id);
-
-          // 记录商品可以被哪些折扣卡使用
           if (!itemApplicableDiscounts.has(flatItem._id)) {
-            itemApplicableDiscounts.set(flatItem._id, new Set());
+            itemApplicableDiscounts.set(flatItem._id, /* @__PURE__ */ new Set());
           }
           itemApplicableDiscounts.get(flatItem._id).add(discount.id);
         }
       });
       orderLevelDiscountApplicableItems.set(discount.id, applicableItemIds);
     });
-
-    // 专属折扣卡定义：限定了特定商品（product_ids），而不是全品类（product_all）的折扣卡
-    // 如果专属折扣卡被勾选，它适用的商品会被占用，其他折扣卡均摊时应排除这些商品
-    // Map<flatItemId, discountId> - 记录被占用的商品及其对应的折扣卡
-    const occupiedItems = new Map();
-
-    // 按排序顺序遍历折扣卡，判断哪些是专属折扣卡
-    selectedOrderLevelDiscounts.forEach(discount => {
+    const occupiedItems = /* @__PURE__ */ 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);
             }
@@ -668,27 +560,22 @@ class RulesModule extends _BaseModule.BaseModule {
         }
       }
     });
-
-    // 🔥 第三步：识别 order_level 折扣卡并预计算分摊（排除被其他专属折扣卡占用的商品）
-    sortedDiscountList.forEach(discount => {
-      if (!(0, _utils.isOrderLevelFixedAmountDiscount)(discount)) {
+    sortedDiscountList.forEach((discount) => {
+      if (!(0, import_utils3.isOrderLevelFixedAmountDiscount)(discount)) {
         return;
       }
-
-      // 收集该折扣卡适用的商品（排除被其他专属折扣卡占用的商品）
       const applicableProducts = [];
-      sortedFlattenedList.forEach(flatItem => {
-        // 🔥 检查该商品是否被其他专属折扣卡占用
+      sortedFlattenedList.forEach((flatItem) => {
+        var _a2, _b, _c;
         const occupyingDiscountId = occupiedItems.get(flatItem._id);
-        if (occupyingDiscountId !== undefined && occupyingDiscountId !== discount.id) {
-          // 该商品被其他专属折扣卡占用，跳过
+        if (occupyingDiscountId !== void 0 && occupyingDiscountId !== discount.id) {
           return;
         }
         if (!checkItemApplicableForDiscount(flatItem, discount)) {
           return;
         }
         let product;
-        if (flatItem.type === 'main') {
+        if (flatItem.type === "main") {
           product = flatItem.product;
         } else {
           product = {
@@ -699,53 +586,33 @@ class RulesModule extends _BaseModule.BaseModule {
             num: flatItem.num
           };
         }
-
-        // 对于 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 quantity = flatItem.type === "main" ? product.num || product.quantity || 1 : (product.num || product.quantity || 1) * (((_a2 = flatItem.parentProduct) == null ? void 0 : _a2.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);
         const productData = {
           productId: flatItem._id,
           amount: originalAmount,
-          quantity: quantity
+          quantity
         };
-
-        // 子商品需要传递主商品数量
-        if (flatItem.type === 'bundle') {
-          productData.parentQuantity = flatItem.parentProduct?.quantity || 1;
+        if (flatItem.type === "bundle") {
+          productData.parentQuantity = ((_c = flatItem.parentProduct) == null ? void 0 : _c.quantity) || 1;
         }
         applicableProducts.push(productData);
       });
-
-      // 计算分摊
       if (applicableProducts.length > 0) {
-        const allocation = (0, _utils.calculateOrderLevelDiscountAllocation)(discount, applicableProducts);
+        const allocation = (0, import_utils4.calculateOrderLevelDiscountAllocation)(discount, applicableProducts);
         orderLevelDiscountAllocations.set(discount.id, allocation);
       }
     });
-
-    // 处理后的商品列表（按排序后的顺序处理，记录优惠信息）
-    const processedProductsMap = new Map();
-
-    // 记录已应用优惠券的商品信息
-    const appliedDiscountProducts = new Map();
-
-    // 首先遍历所有商品和所有优惠券，确定每个优惠券的适用范围，包括isSelected为false的优惠券
-    // 🔥 使用扁平化后的列表，包含主商品和bundle子商品
-    sortedFlattenedList.forEach(flatItem => {
-      // 获取商品数据
+    const processedProductsMap = /* @__PURE__ */ new Map();
+    const appliedDiscountProducts = /* @__PURE__ */ new Map();
+    sortedFlattenedList.forEach((flatItem) => {
+      var _a2;
       let product, originProduct;
-      if (flatItem.type === 'main') {
+      if (flatItem.type === "main") {
         product = flatItem.product;
         originProduct = flatItem.originProduct;
       } else {
-        // bundle子商品：构造虚拟商品对象
         product = {
-          startDate: flatItem?.parentProduct?.startDate,
           _id: flatItem._id,
           id: flatItem.id,
           price: flatItem.price,
@@ -754,49 +621,48 @@ class RulesModule extends _BaseModule.BaseModule {
           total: flatItem.total,
           origin_total: flatItem.origin_total,
           booking_id: flatItem.booking_id,
-          discount_list: flatItem.discount_list || []
+          discount_list: flatItem.discount_list || [],
+          startDate: (_a2 = flatItem.parentProduct) == null ? void 0 : _a2.startDate
         };
         originProduct = flatItem.originProduct;
       }
-      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);
+      addModeDiscount.forEach((discount) => {
+        var _a3, _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: resolveIsFormSubject(_tempVar) && !(_tempVar == null ? void 0 : _tempVar.isNormalProduct),
+            holder_id: (_tempVar == null ? void 0 : _tempVar.holder_id) || product.holder_id
+          },
+          holders
+        );
         let timeLimit = true;
-        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));
-
-        // 套餐是否可用判断
+        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) && ((_a3 = product == null ? void 0 : product.discount_list) == null ? void 0 : _a3.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)));
         const isBundleAvailable = this.checkPackageSubItemUsageRules(discount, flatItem);
-
-        // 判断优惠券是否适用于该商品
-        if (isAvailableProduct && isLimitedProduct && timeLimit && isBundleAvailable && discount.config?.isAvailable) {
-          // 记录此优惠券适用的商品
-          discountApplicability.get(discount.id)?.push(product.id);
-
-          // 记录可抵扣的商品详情
+        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);
           const applicableProducts = discountApplicableProducts.get(discount.id) || [];
           const discountType = discount.tag || discount.type;
-          const isGoodPass = discountType === 'good_pass';
-
-          // 使用数量
-          const num = isGoodPass || flatItem?.type === 'main' ? 1 : product.num;
+          const isGoodPass = discountType === "good_pass";
+          const num = isGoodPass || (flatItem == null ? void 0 : flatItem.type) === "main" ? 1 : product.num;
           const productData = {
             amount: product.price * num,
             type: discountType,
             tag: discountType,
             discount: {
-              discount_card_type: discount?.metadata?.discount_card_type,
+              discount_card_type: (_i = discount == null ? void 0 : discount.metadata) == null ? void 0 : _i.discount_card_type,
               fixed_amount: product.price,
-              discount_calculation_mode: discount?.metadata?.discount_calculation_mode,
+              discount_calculation_mode: (_j = discount == null ? void 0 : discount.metadata) == null ? void 0 : _j.discount_calculation_mode,
               resource_id: discount.id,
               title: discount.format_title,
               original_amount: product.price || product.origin_total,
@@ -805,8 +671,8 @@ class RulesModule extends _BaseModule.BaseModule {
               discount_product_id: discount.product_id
             },
             metadata: {
-              num: num,
-              discount_rule_uncheck_flag: discount?.discount_rule_uncheck_flag
+              num,
+              discount_rule_uncheck_flag: discount == null ? void 0 : discount.discount_rule_uncheck_flag
             }
           };
           applicableProducts.push(productData);
@@ -814,145 +680,128 @@ class RulesModule extends _BaseModule.BaseModule {
         }
       });
     });
-
-    // 🔥 用于存储扁平化商品处理结果的Map
-    const processedFlatItemsMap = new Map();
-
-    // 🔥 Option 折扣辅助函数
-    const applyDiscountToOptions = (options, discount) => {
-      if (!options?.length) return {
-        discountedOptions: options,
-        optionDiscountAmount: 0
-      };
+    const processedFlatItemsMap = /* @__PURE__ */ new Map();
+    const applyDiscountToOptions = (options2, discount) => {
+      if (!(options2 == null ? void 0 : options2.length))
+        return { discountedOptions: options2, optionDiscountAmount: 0 };
       let optionDiscountAmount = 0;
-      const discountedOptions = options.map(option => {
-        // 折前单价：优先 price，缺失再 add_price；已写回折后价时用 _original_price（或旧字段 _original_add_price）
+      const discountedOptions = options2.map((option) => {
         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, _utils.getDiscountAmount)(discount, baseUnitNum, baseUnitNum);
+        if (baseUnitNum <= 0)
+          return option;
+        const discountedPrice = (0, import_utils.getDiscountAmount)(discount, baseUnitNum, baseUnitNum);
         const optQty = Number(option.num ?? option.quantity ?? 1);
-        optionDiscountAmount = new _decimal.default(optionDiscountAmount).plus(new _decimal.default(baseUnitNum).minus(discountedPrice).mul(optQty)).toNumber();
-        const {
-          _original_add_price,
-          ...rest
-        } = option;
+        optionDiscountAmount = new import_decimal.default(optionDiscountAmount).plus(new import_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 !== undefined ? _original_add_price : rawUnit),
+          _original_price: option._original_price ?? (_original_add_price !== void 0 ? _original_add_price : rawUnit),
           price: nextPrice
         };
       });
-      return {
-        discountedOptions,
-        optionDiscountAmount
-      };
+      return { discountedOptions, optionDiscountAmount };
     };
-    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
-          };
+    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 };
         }
         return option;
       });
     };
-    const getOptionTotal = options => {
-      if (!options?.length) return 0;
-      return options.reduce((sum, opt) => {
+    const getOptionTotal = (options2) => {
+      if (!(options2 == null ? void 0 : options2.length))
+        return 0;
+      return options2.reduce((sum, opt) => {
         const unit = Number(opt.price ?? opt.add_price ?? 0);
         const n = Number(opt.num ?? opt.quantity ?? 1);
-        return new _decimal.default(sum).plus(new _decimal.default(unit).mul(n)).toNumber();
+        return new import_decimal.default(sum).plus(new import_decimal.default(unit).mul(n)).toNumber();
       }, 0);
     };
-
-    // 然后再处理应用哪些优惠券，此时只考虑filteredDiscountList中的优惠券
-    // 🔥 使用扁平化后的列表进行处理
     sortedFlattenedList.forEach((flatItem, index) => {
-      // 获取商品数据
+      var _a2, _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;
       let product, originProduct;
-      if (flatItem.type === 'main') {
+      if (flatItem.type === "main") {
         product = flatItem.product;
         originProduct = flatItem.originProduct;
       } else {
-        // bundle子商品
         product = {
-          startDate: flatItem?.parentProduct?.startDate,
           _id: flatItem._id,
           id: flatItem.id,
           price: flatItem.price,
           quantity: flatItem.quantity,
           num: flatItem.num,
           total: flatItem.total,
-          original_price: flatItem?.bundleItem?.original_price,
-          origin_total: flatItem?.bundleItem?.original_price,
+          original_price: (_a2 = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _a2.original_price,
+          origin_total: (_b = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _b.original_price,
           booking_id: flatItem.booking_id,
-          discount_list: flatItem?.bundleItem?.discount_list || []
+          discount_list: ((_c = flatItem == null ? void 0 : flatItem.bundleItem) == null ? void 0 : _c.discount_list) || [],
+          startDate: (_d = flatItem.parentProduct) == null ? void 0 : _d.startDate
         };
         originProduct = flatItem.originProduct;
       }
-      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 isPersistedProduct = (product == null ? void 0 : product.booking_id) || (originProduct == null ? void 0 : originProduct.order_detail_id) || (originProduct == null ? void 0 : originProduct.orderDetailId) || (originProduct == null ? void 0 : originProduct.booking_id);
+      const hasExistingWalletDiscount = ((_e = product.discount_list) == null ? void 0 : _e.length) && ((_f = product == null ? void 0 : product.discount_list) == null ? void 0 : _f.every((discount) => {
+        var _a3;
+        const discountIdentity = discount.id ?? ((_a3 = discount.discount) == null ? void 0 : _a3.resource_id);
         const discountType = discount.tag || discount.type;
-        return Boolean(discountIdentity && ['good_pass', 'discount_card', 'product_discount_card'].includes(discountType));
-      });
-
-      // 已持久化且已有钱包券/折扣卡的商品行跳过，保留后端历史折扣结果。
+        return Boolean(
+          discountIdentity && ["good_pass", "discount_card", "product_discount_card"].includes(
+            discountType
+          )
+        );
+      }));
       if (isPersistedProduct && hasExistingWalletDiscount) {
-        if (flatItem.type === 'main') {
+        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;
       }
-
-      // 找到适用于此商品的所有优惠券，仅考虑isSelected不为false的优惠券
-      const applicableDiscounts = sortedDiscountList.filter(discount => {
-        // 🔥 检查策略可用性（针对 good_pass 和折扣卡）
+      const applicableDiscounts = sortedDiscountList.filter((discount) => {
+        var _a3, _b2, _c2, _d2;
         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 (!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) {
+        if (["good_pass", "discount_card", "product_discount_card"].includes(
+          discountType
+        ) && !isReapplyEditModeDiscountForProduct) {
+          if (discount.config === void 0 || !((_a3 = discount == null ? void 0 : discount.config) == null ? void 0 : _a3.isAvailable)) {
             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;
-        // 如果优惠券已被使用，则跳过
+        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 _a4;
+          return ((_a4 = n.discount) == null ? void 0 : _a4.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;
-
-        // 🔥 检查 maxUsagePerOrder 限制：同一 product_id 的商品券使用数量不能超过配置值
-        if ((discount.tag || discount.type) === 'good_pass') {
-          const maxUsagePerOrder = discount.config?.maxUsagePerOrder;
+        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 (maxUsagePerOrder && maxUsagePerOrder > 0) {
             const currentUsedCount = usedProductIdCounts.get(discount.product_id) || 0;
             if (currentUsedCount >= maxUsagePerOrder) {
@@ -960,47 +809,32 @@ class RulesModule extends _BaseModule.BaseModule {
             }
           }
         }
-
-        // 🔥 检查折扣卡的 applicableProductLimit 限制：折扣卡可使用的最大次数（跨商品全局）
-        const discountTypeForLimit = discount.tag || discount.type;
-        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) {
-              return false;
-            }
-          }
-        }
         const limitedData = discount.limited_relation_product_data;
-
-        // 拿到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;
+        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: resolveIsFormSubject(_tempVar) && !(_tempVar == null ? void 0 : _tempVar.isNormalProduct),
+            holder_id: (_tempVar == null ? void 0 : _tempVar.holder_id) || product.holder_id
+          },
+          holders
+        );
+        if (!isHolderMatch)
+          return false;
         let timeLimit = true;
-        timeLimit = !!(0, _utils.filterDiscountListByBookingTime)([discount], (product.startDate || (0, _dayjs.default)()).format('YYYY-MM-DD HH:mm:ss')).length;
+        timeLimit = !!(0, import_utils.filterDiscountListByBookingTime)([discount], (product.startDate || (0, import_dayjs.default)()).format("YYYY-MM-DD HH:mm:ss")).length;
         if (!timeLimit) {
           return false;
         }
-
-        // 判断优惠券是否适用于该商品
-        if (limitedData.type === 'product_all') {
-          if (!isProductIncludedByLimitedData(limitedData, product.id)) {
+        if (limitedData.type === "product_all") {
+          if (limitedData.filter === 1 && limitedData.exclude_product_ids.includes(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;
           }
@@ -1008,109 +842,158 @@ class RulesModule extends _BaseModule.BaseModule {
         }
         return false;
       });
-
-      // 选择第一个适用的优惠券（已经按过期时间排序）
-      // 如果有 isScan 且 isSelected 的折扣卡，则优先选中，否则再选择第一个
-      // 用于处理：先手动扫描了一张折扣卡，扫描完以后带入客户信息，但是之前那张折扣卡不是最优惠的情况
-      const selectedDiscountCard = applicableDiscounts.find(n => n.isScan && n.isSelected && (n.tag || n.type) !== 'good_pass');
+      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.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 (flatItem.type === "main") {
+        isManualDiscount = typeof product.isManualDiscount === "boolean" ? product.isManualDiscount : ((_g = product.discount_list) == null ? void 0 : _g.some((item) => item.type === "product")) || product.total != product.origin_total && (product.bundle || []).every(
+          (item) => {
+            var _a3;
+            return !((_a3 = item.discount_list || []) == null ? void 0 : _a3.length);
+          }
+        ) && (!((_h = product.discount_list) == null ? void 0 : _h.length) || ((_j = (_i = product == null ? void 0 : product.discount_list) == null ? void 0 : _i.every) == null ? void 0 : _j.call(
+          _i,
+          (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.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'));
+          isManualDiscount = typeof parentProduct.isManualDiscount === "boolean" ? parentProduct.isManualDiscount : ((_k = parentProduct.discount_list) == null ? void 0 : _k.some((item) => item.type === "product")) || parentProduct.total != parentProduct.origin_total && (parentProduct.bundle || []).every(
+            (item) => {
+              var _a3;
+              return !((_a3 = item.discount_list || []) == null ? void 0 : _a3.length);
+            }
+          ) && (!((_l = parentProduct.discount_list) == null ? void 0 : _l.length) || ((_n = (_m = parentProduct == null ? void 0 : parentProduct.discount_list) == null ? void 0 : _m.every) == null ? void 0 : _n.call(
+            _m,
+            (item) => item.type === "product"
+          )));
         }
       }
-
-      // 勾选时覆盖手动折扣
-      if (options?.discountId) {
-        // 主商品：检查自己的 discount_list
-        if (flatItem.type === 'main' && product.discount_list?.some(item => item.discount?.resource_id === options.discountId)) {
+      if (options == null ? void 0 : options.discountId) {
+        if (flatItem.type === "main" && ((_o = product.discount_list) == null ? void 0 : _o.some(
+          (item) => {
+            var _a3;
+            return ((_a3 = item.discount) == null ? void 0 : _a3.resource_id) === options.discountId;
+          }
+        ))) {
           isManualDiscount = false;
         }
-        // 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)) {
+        if (flatItem.type === "bundle") {
+          if (((_p = product.discount_list) == null ? void 0 : _p.some(
+            (item) => {
+              var _a3;
+              return ((_a3 = item.discount) == null ? void 0 : _a3.resource_id) === options.discountId;
+            }
+          )) || ((_r = (_q = flatItem.parentProduct) == null ? void 0 : _q.discount_list) == null ? void 0 : _r.some(
+            (item) => {
+              var _a3;
+              return ((_a3 = item.discount) == null ? void 0 : _a3.resource_id) === options.discountId;
+            }
+          ))) {
             isManualDiscount = false;
           }
         }
       }
-      if (options?.selectedList) {
-        // 主商品：检查自己的 discount_list
-        if (flatItem.type === 'main' && product.discount_list?.some(item => options?.selectedList?.some(n => n.discountId === item.discount?.resource_id))) {
+      if (options == null ? void 0 : options.selectedList) {
+        if (flatItem.type === "main" && ((_s = product.discount_list) == null ? void 0 : _s.some(
+          (item) => {
+            var _a3;
+            return (_a3 = options == null ? void 0 : options.selectedList) == null ? void 0 : _a3.some(
+              (n) => {
+                var _a4;
+                return n.discountId === ((_a4 = item.discount) == null ? void 0 : _a4.resource_id);
+              }
+            );
+          }
+        ))) {
           isManualDiscount = false;
         }
-        // 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))) {
+        if (flatItem.type === "bundle") {
+          if (((_t = product.discount_list) == null ? void 0 : _t.some(
+            (item) => {
+              var _a3;
+              return (_a3 = options == null ? void 0 : options.selectedList) == null ? void 0 : _a3.some(
+                (n) => {
+                  var _a4;
+                  return n.discountId === ((_a4 = item.discount) == null ? void 0 : _a4.resource_id);
+                }
+              );
+            }
+          )) || ((_v = (_u = flatItem.parentProduct) == null ? void 0 : _u.discount_list) == null ? void 0 : _v.some(
+            (item) => {
+              var _a3;
+              return (_a3 = options == null ? void 0 : options.selectedList) == null ? void 0 : _a3.some(
+                (n) => {
+                  var _a4;
+                  return n.discountId === ((_a4 = item.discount) == null ? void 0 : _a4.resource_id);
+                }
+              );
+            }
+          ))) {
             isManualDiscount = false;
           }
         }
       }
-
-      // 如果没有适用的优惠券，或者手动折扣，则不适用优惠券
-      if (applicableDiscounts.length === 0 || isManualDiscount || (0, _lodashEs.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
-        if (flatItem.type === 'main') {
-          // 主商品：保持原有逻辑，还原 option 价格
+      if (applicableDiscounts.length === 0 || isManualDiscount || (0, import_lodash_es.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
+        if (flatItem.type === "main") {
           const restoredOptions = restoreOptionPrices(product.options);
           if (product.isClient) {
-            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
-                }),
-                variant: originProduct._productInit.variant,
-                original_price: originProduct._productInit.original_price,
-                total: (0, _utils2.getProductTotalPrice)({
-                  product: {
-                    price: product.price
-                  },
-                  bundle: product.bundle,
+            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,
                   options: restoredOptions
-                }),
-                price: product.price,
-                options: restoredOptions
-              }),
-              discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.discount_list) : this.filterDiscountListByType(product.discount_list, 'promotion')
-            })]);
+                },
+                discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.discount_list) : this.filterDiscountListByType(product.discount_list, "promotion")
+              })
+            ]);
           } else {
-            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, _lodashEs.isBoolean)(product.vouchersApplicable) && !product.vouchersApplicable) {
+            let total = product.inPromotion ? ((_w = product == null ? void 0 : product._promotion) == null ? void 0 : _w.finalPrice) ?? product.origin_total ?? product.total : product.origin_total ?? product.total;
+            let main_product_selling_price = product.price;
+            if ((product.discount_list || []).some((item) => item.type === "promotion") || (0, import_lodash_es.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,
-                price: product.price,
-                main_product_selling_price,
-                options: restoredOptions
-              }),
-              discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(product.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: isManualDiscount ? this.resolveDiscountListForManualOverride(flatItem.bundleItem?.discount_list || []) : this.filterDiscountListByType(flatItem.bundleItem?.discount_list || [], 'promotion'),
+            discount_list: isManualDiscount ? this.resolveDiscountListForManualOverride(((_x = flatItem.bundleItem) == null ? void 0 : _x.discount_list) || []) : this.filterDiscountListByType(((_y = flatItem.bundleItem) == null ? void 0 : _y.discount_list) || [], "promotion"),
             price: isManualDiscount ? flatItem.bundleItem.price : flatItem.bundleItem.original_price,
             processed: true
           }]);
@@ -1118,98 +1001,57 @@ class RulesModule extends _BaseModule.BaseModule {
         return;
       }
       const shouldReapplyBookingDiscountForProduct = shouldReapplyBookingDiscount(originProduct, selectedDiscount);
-      if (applicableDiscounts.length && product.booking_id && typeof selectedDiscount.isManualSelect === 'undefined' && !options?.scan && !isEditModeAddNewProduct && !shouldReapplyBookingDiscountForProduct) {
+      if (applicableDiscounts.length && product.booking_id && typeof selectedDiscount.isManualSelect === "undefined" && !(options == null ? void 0 : 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 = selectedDiscount.config?.applicableProductLimit || 0;
-
-      // 商品券始终需要拆分，折扣卡在 applicableProductLimit > 0 时需要拆分
-      const isNeedSplit = isGoodPass || isDiscountCard && applicableProductLimit > 0;
-
-      // 需要拆分出来的数量
+      const isNeedSplit = (selectedDiscount.tag || selectedDiscount.type) === "good_pass";
       const totalQuantity = product.quantity || product.num || 1;
-      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);
-        }
-      } else if (isDiscountCard && applicableProductLimit > 0) {
-        // 折扣卡：使用 applicableProductLimit 限制（一个商品使用一次折扣卡算1次）
-        // 需要减去已使用次数（跨商品全局计数）
-        const usedLimitCount = usedDiscountCardLimitCounts.get(selectedDiscount.id) || 0;
-        maxUsageLimit = Math.max(0, applicableProductLimit - usedLimitCount);
-      } else {
-        // 其他情况不拆分
-        maxUsageLimit = 1;
+      const availableGoodPassCount = applicableDiscounts.filter(
+        (item) => (item.tag || item.type) === "good_pass"
+      ).length;
+      let maxUsageLimit = availableGoodPassCount;
+      if (selectedDiscount.config && selectedDiscount.config.maxUsagePerOrder) {
+        maxUsageLimit = Math.min(
+          availableGoodPassCount,
+          selectedDiscount.config.maxUsagePerOrder
+        );
       }
       const splitCount = isNeedSplit ? Math.min(product.quantity || product.num || 1, maxUsageLimit) : 1;
       const arr = [];
-
-      // 🔥 主商品和bundle子商品分别处理
-      if (flatItem.type === 'main') {
-        // 主商品：保持原有逻辑
+      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);
-          // 🔥 更新 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)) {
-            const currentLimitCount = usedDiscountCardLimitCounts.get(currentSelectedDiscount.id) || 0;
-            usedDiscountCardLimitCounts.set(currentSelectedDiscount.id, currentLimitCount + 1);
+          const selectedDiscount2 = selectedDiscountCard || applicableDiscounts[i];
+          usedDiscounts.set(selectedDiscount2.id, true);
+          if ((selectedDiscount2.tag || selectedDiscount2.type) === "good_pass") {
+            const currentCount = usedProductIdCounts.get(selectedDiscount2.product_id) || 0;
+            usedProductIdCounts.set(selectedDiscount2.product_id, currentCount + 1);
           }
-
-          // 记录实际应用了优惠券的商品信息
-          const appliedProducts = appliedDiscountProducts.get(currentSelectedDiscount.id) || [];
-
-          // 优先从 origin_total拿，可能会拿不到（比如用户端预约在没有配置 original_price 的情况下）
+          const appliedProducts = appliedDiscountProducts.get(selectedDiscount2.id) || [];
           let productOriginTotal = product.origin_total || product.total || 0;
-          // 如果当前 product 有 discount_list，则先从 origin_total 拿
-          if (this.filterDiscountListByType(product.discount_list, 'promotion').length && product.origin_total) {
+          if (this.filterDiscountListByType(product.discount_list, "promotion").length && product.origin_total) {
             productOriginTotal = product.origin_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) {
+          if (Number(((_z = originProduct == null ? void 0 : originProduct._productInit) == null ? void 0 : _z.original_price) || 0) > 0 && product.origin_total && product.total && product.origin_total !== product.total) {
             productOriginTotal = product.total;
           }
-
-          // 计算使用折扣卡/商品券以后，单个商品的总 total
-          // 🔥 检查是否是 order_level 固定金额折扣卡
-          const isOrderLevel = (0, _utils.isOrderLevelFixedAmountDiscount)(selectedDiscount);
-          const orderLevelAllocation = isOrderLevel ? orderLevelDiscountAllocations.get(selectedDiscount.id) : null;
-          const productAllocation = orderLevelAllocation?.get(flatItem._id);
-          const isDeductOptionPrice = !!selectedDiscount.config?.deductOptionPrice;
-
-          // 主商品折后价（不含 option）；勿与 option 合计混在同一变量，否则 main_product_selling_price 错误
+          const isOrderLevel = (0, import_utils3.isOrderLevelFixedAmountDiscount)(selectedDiscount2);
+          const orderLevelAllocation = isOrderLevel ? orderLevelDiscountAllocations.get(selectedDiscount2.id) : null;
+          const productAllocation = orderLevelAllocation == null ? void 0 : orderLevelAllocation.get(flatItem._id);
+          const isDeductOptionPrice = !!((_A = selectedDiscount2.config) == null ? void 0 : _A.deductOptionPrice);
           let mainProductSellingPrice;
           let amount;
           let productDiscountDifference;
@@ -1217,166 +1059,146 @@ class RulesModule extends _BaseModule.BaseModule {
           let optionDiscountAmount = 0;
           let reapplyDiscountPercent;
           if (isOrderLevel && productAllocation) {
-            // order_level：使用预计算的分摊金额
             amount = productAllocation.discountAmount;
             productDiscountDifference = productAllocation.difference;
-            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();
+            mainProductSellingPrice = Math.max(new import_decimal.default(product.price).minus(amount).toNumber(), 0);
+          } else if (resolveReapplyEditModeDiscountPercent(originProduct, selectedDiscount2) !== void 0) {
+            const percent = resolveReapplyEditModeDiscountPercent(originProduct, selectedDiscount2);
+            reapplyDiscountPercent = new import_decimal.default(percent).toFixed(2);
+            mainProductSellingPrice = new import_decimal.default(product.price || 0).mul(new import_decimal.default(100).minus(percent)).div(100).toDecimalPlaces(2).toNumber();
+            amount = new import_decimal.default(product.price).minus(mainProductSellingPrice).toNumber();
           } else {
-            // item_level 或其他类型：使用原有逻辑
-            mainProductSellingPrice = (0, _utils.getDiscountAmount)(selectedDiscount, product.price, product.price);
-            amount = new _decimal.default(product.price).minus(new _decimal.default(mainProductSellingPrice)).toNumber();
+            mainProductSellingPrice = (0, import_utils.getDiscountAmount)(
+              selectedDiscount2,
+              product.price,
+              product.price
+            );
+            amount = new import_decimal.default(product.price).minus(new import_decimal.default(mainProductSellingPrice)).toNumber();
           }
-          if (isDeductOptionPrice && product.options?.length) {
-            const optionResult = applyDiscountToOptions(product.options, selectedDiscount);
+          if (isDeductOptionPrice && ((_B = product.options) == null ? void 0 : _B.length)) {
+            const optionResult = applyDiscountToOptions(
+              product.options,
+              selectedDiscount2
+            );
             discountedOptions = optionResult.discountedOptions;
             optionDiscountAmount = optionResult.optionDiscountAmount;
           }
-
-          // total = 主商品折后 + option 行合计；开启 option 抵扣时必须用 discountedOptions，不能用未折扣的 product.options 再算一遍
-          const optionsForLineTotal = isDeductOptionPrice && product.options?.length ? discountedOptions : product.options;
+          const optionsForLineTotal = isDeductOptionPrice && ((_C = product.options) == null ? void 0 : _C.length) ? discountedOptions : product.options;
           const optionsLineTotal = getOptionTotal(optionsForLineTotal || []);
-          const total = new _decimal.default(mainProductSellingPrice).plus(optionsLineTotal).toNumber();
-
-          // discount_list.amount / fixed_amount：行级总优惠 = 主商品优惠 + option 优惠（与 total 变化一致）
+          const total = new import_decimal.default(mainProductSellingPrice).plus(optionsLineTotal).toNumber();
           const mainProductDiscountAmount = amount;
-          const lineDiscountAmount = new _decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
-          const discountType = selectedDiscount.tag || selectedDiscount.type;
-          const currentIsGoodPass = discountType === 'good_pass';
+          const lineDiscountAmount = new import_decimal.default(mainProductDiscountAmount).plus(optionDiscountAmount).toNumber();
+          const discountType = selectedDiscount2.tag || selectedDiscount2.type;
+          const isGoodPass = discountType === "good_pass";
           const discountDetail = {
             amount: lineDiscountAmount,
-            type: selectedDiscount.tag === 'product_discount_card' ? 'discount_card' : discountType,
+            type: selectedDiscount2.tag === "product_discount_card" ? "discount_card" : discountType,
             discount: {
-              discount_card_type: selectedDiscount?.metadata?.discount_card_type,
+              discount_card_type: (_D = selectedDiscount2 == null ? void 0 : selectedDiscount2.metadata) == null ? void 0 : _D.discount_card_type,
               fixed_amount: lineDiscountAmount,
-              discount_calculation_mode: selectedDiscount?.metadata?.discount_calculation_mode,
-              resource_id: selectedDiscount.id,
-              title: selectedDiscount.format_title,
+              discount_calculation_mode: (_E = selectedDiscount2 == null ? void 0 : selectedDiscount2.metadata) == null ? void 0 : _E.discount_calculation_mode,
+              resource_id: selectedDiscount2.id,
+              title: selectedDiscount2.format_title,
               original_amount: product.price,
               product_id: originProduct.id || originProduct.product_id,
-              percent: reapplyDiscountPercent ?? selectedDiscount.par_value,
-              discount_product_id: selectedDiscount.product_id
+              percent: reapplyDiscountPercent ?? selectedDiscount2.par_value,
+              discount_product_id: selectedDiscount2.product_id
             },
-            // 前端使用的num数量，为了计算优惠金额（拆分时为1）
-            _num: isNeedSplit ? 1 : product.num,
-            config: currentSelectedDiscount?.config,
+            // 前端使用的num数量，为了计算优惠金额
+            _num: isGoodPass ? 1 : product.num,
+            config: selectedDiscount2 == null ? void 0 : selectedDiscount2.config,
             metadata: {
               num: 1,
-              discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
+              discount_rule_uncheck_flag: selectedDiscount2 == null ? void 0 : selectedDiscount2.discount_rule_uncheck_flag,
               // 🔥 order_level 分摊差值
-              ...(productDiscountDifference !== undefined && {
-                product_discount_difference: productDiscountDifference
-              }),
+              ...productDiscountDifference !== void 0 && { product_discount_difference: productDiscountDifference },
               /** 仅主商品上的优惠金额（不含 option） */
               mainProductDiscountAmount,
               optionDiscountAmount
             }
           };
           appliedProducts.push(discountDetail);
-          appliedDiscountProducts.set(selectedDiscount.id, appliedProducts);
-
-          // 记录应用了优惠券的商品
-          // 后续更新价格改为 getProductTotalPrice getProductOriginTotalPrice逻辑
+          appliedDiscountProducts.set(selectedDiscount2.id, appliedProducts);
           if (product.isClient) {
-            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
-            }));
+            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, 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
+              })
+            );
           } 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: 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] + "___" + selectedDiscount2.id + index,
+                price: selectedDiscount2.tag === "good_pass" ? 0 : product.price,
+                quantity: isNeedSplit ? 1 : product.quantity,
+                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);
-            // 🔥 更新 product_id 使用计数
-            if ((currentBundleDiscount.tag || currentBundleDiscount.type) === 'good_pass') {
-              const currentCount = usedProductIdCounts.get(currentBundleDiscount.product_id) || 0;
-              usedProductIdCounts.set(currentBundleDiscount.product_id, currentCount + 1);
+            const selectedDiscount2 = applicableDiscounts[i];
+            usedDiscounts.set(selectedDiscount2.id, true);
+            if ((selectedDiscount2.tag || selectedDiscount2.type) === "good_pass") {
+              const currentCount = usedProductIdCounts.get(selectedDiscount2.product_id) || 0;
+              usedProductIdCounts.set(selectedDiscount2.product_id, currentCount + 1);
             }
-            // 🔥 更新折扣卡 applicableProductLimit 使用计数（跨商品全局）
-            const bundleDiscountTypeForCount = currentBundleDiscount.tag || currentBundleDiscount.type;
-            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}`;
-
-            // 计算折扣后的价格（使用 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();
+            const discountedPrice = (0, import_utils.getDiscountAmount)(
+              selectedDiscount2,
+              product.origin_total,
+              product.origin_total
+            );
+            const bundleDiscountAmount = new import_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,
+              type: "good_pass",
               discount: {
-                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,
+                fixed_amount: product.origin_total,
+                discount_calculation_mode: (_F = selectedDiscount2 == null ? void 0 : selectedDiscount2.metadata) == null ? void 0 : _F.discount_calculation_mode,
+                resource_id: selectedDiscount2.id,
+                title: selectedDiscount2.format_title,
                 original_amount: product.origin_total,
                 product_id: product.id || product.product_id,
-                discount_product_id: selectedDiscount.product_id
+                discount_product_id: selectedDiscount2.product_id
               },
               metadata: {
                 // 🔥 使用拆分后的唯一 _id
                 custom_product_bundle_map_id: uniqueId,
-                discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
+                discount_rule_uncheck_flag: selectedDiscount2 == null ? void 0 : selectedDiscount2.discount_rule_uncheck_flag,
                 num: 1
               },
               _num: 1,
-              config: currentBundleDiscount?.config
+              config: selectedDiscount2 == null ? void 0 : selectedDiscount2.config
             };
-
-            // 记录实际应用的折扣
-            const appliedProducts = appliedDiscountProducts.get(currentBundleDiscount.id) || [];
+            const appliedProducts = appliedDiscountProducts.get(selectedDiscount2.id) || [];
             appliedProducts.push(discountDetail);
-            appliedDiscountProducts.set(currentBundleDiscount.id, appliedProducts);
+            appliedDiscountProducts.set(selectedDiscount2.id, appliedProducts);
             processedItems.push({
               ...flatItem,
               // 🔥 使用唯一的 _id
@@ -1388,333 +1210,100 @@ class RulesModule extends _BaseModule.BaseModule {
               total: discountedPrice,
               discount_list: [discountDetail],
               processed: true,
-              _discountId: currentBundleDiscount.id
+              _discountId: selectedDiscount2.id
             });
           }
-
-          // 🔥 对拆分后的剩余商品继续匹配其他可用折扣（而不是等到下次执行才应用）
-          let remainingNum = normalNum;
-          let continueSplitIndex = discountNum;
-          while (remainingNum > 0) {
-            // 重新查找适用于剩余商品的可用折扣（已使用的会被自动过滤掉）
-            const nextApplicableDiscounts = sortedDiscountList.filter(nextDiscount => {
-              const nextDiscountType = nextDiscount.tag || nextDiscount.type;
-              // 检查策略可用性
-              if (['good_pass', 'discount_card', 'product_discount_card'].includes(nextDiscountType)) {
-                if (nextDiscount.config === undefined || !nextDiscount?.config?.isAvailable) {
-                  return false;
-                }
-              }
-              // 折扣卡时总价为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) {
-                    return false;
-                  }
-                }
-              }
-
-              // 检查折扣卡的 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) {
-                    return false;
-                  }
-                }
-              }
-              const limitedData = nextDiscount.limited_relation_product_data;
-              if (limitedData.type === 'product_all') {
-                if (limitedData.filter === 1 && limitedData.exclude_product_ids.includes(product.id)) {
-                  return false;
-                }
-                if (!this.checkPackageSubItemUsageRules(nextDiscount, flatItem)) {
-                  return false;
-                }
-                return true;
-              } else if (limitedData.product_ids && limitedData.product_ids.includes(product.id)) {
-                if (!this.checkPackageSubItemUsageRules(nextDiscount, flatItem)) {
-                  return false;
-                }
-                return true;
-              }
-              return false;
+          if (normalNum > 0) {
+            processedItems.push({
+              ...flatItem,
+              // 🔥 为剩余商品生成唯一的 _id
+              _id: `${flatItem._id}_split_rest`,
+              num: normalNum,
+              quantity: normalNum,
+              discount_list: this.filterDiscountListByType(flatItem.discount_list, "promotion"),
+              processed: true
             });
-
-            // 没有更多可用折扣，剩余商品无折扣存储
-            if (nextApplicableDiscounts.length === 0) {
-              processedItems.push({
-                ...flatItem,
-                _id: `${flatItem._id}_split_rest`,
-                num: remainingNum,
-                quantity: remainingNum,
-                discount_list: [],
-                processed: true
-              });
-              break;
-            }
-
-            // 选择最优折扣
-            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 = 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') {
-                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)) {
-                const curCount = usedDiscountCardLimitCounts.get(nextBundleDiscount.id) || 0;
-                usedDiscountCardLimitCounts.set(nextBundleDiscount.id, curCount + remainingNum);
-              }
-              const nextOriginTotal = product.original_price || product.price || 0;
-              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 nextDiscountDetail = {
-                amount: nextDiscountAmount * remainingNum,
-                type: nextBundleDiscType,
-                discount: {
-                  discount_card_type: nextBundleDiscount?.metadata?.discount_card_type,
-                  fixed_amount: nextDiscountAmount,
-                  resource_id: nextBundleDiscount.id,
-                  title: nextBundleDiscount.format_title,
-                  original_amount: product.original_price,
-                  product_id: product.id,
-                  percent: nextBundleDiscount.par_value,
-                  discount_product_id: nextBundleDiscount.product_id
-                },
-                metadata: {
-                  custom_product_bundle_map_id: nextUniqueId,
-                  num: remainingNum
-                },
-                config: nextBundleDiscount?.config,
-                _num: remainingNum * (flatItem?.parentProduct?.num || 1)
-              };
-              const nextAppliedProducts = appliedDiscountProducts.get(nextBundleDiscount.id) || [];
-              nextAppliedProducts.push(nextDiscountDetail);
-              appliedDiscountProducts.set(nextBundleDiscount.id, nextAppliedProducts);
-              processedItems.push({
-                ...flatItem,
-                _id: nextUniqueId,
-                num: remainingNum,
-                quantity: remainingNum,
-                total: nextTargetTotal,
-                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;
-              nextMaxUsageLimit = nextGoodPassCount;
-              if (nextSelectedDiscount.config?.maxUsagePerOrder) {
-                const usedCount = usedProductIdCounts.get(nextSelectedDiscount.product_id) || 0;
-                nextMaxUsageLimit = Math.min(nextGoodPassCount, Math.max(0, nextSelectedDiscount.config.maxUsagePerOrder - usedCount));
-              }
-            } else if (nextIsDiscountCard && nextApplicableProductLimit > 0) {
-              const usedLimitCount = usedDiscountCardLimitCounts.get(nextSelectedDiscount.id) || 0;
-              nextMaxUsageLimit = Math.max(0, nextApplicableProductLimit - usedLimitCount);
-            } else {
-              nextMaxUsageLimit = 1;
-            }
-            const nextSplitCount = Math.min(remainingNum, nextMaxUsageLimit);
-            if (nextSplitCount === 0) {
-              // 已达使用上限，剩余商品无折扣存储
-              processedItems.push({
-                ...flatItem,
-                _id: `${flatItem._id}_split_rest`,
-                num: remainingNum,
-                quantity: remainingNum,
-                discount_list: [],
-                processed: true
-              });
-              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') {
-                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)) {
-                const curLimitCount = usedDiscountCardLimitCounts.get(nextBundleDiscount.id) || 0;
-                usedDiscountCardLimitCounts.set(nextBundleDiscount.id, curLimitCount + 1);
-              }
-              const nextUniqueId = `${flatItem._id}_split_${continueSplitIndex}`;
-              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: nextBundleDiscount?.metadata?.discount_card_type,
-                  fixed_amount: nextBundleDiscAmount,
-                  resource_id: nextBundleDiscount.id,
-                  title: nextBundleDiscount.format_title,
-                  original_amount: product.origin_total,
-                  product_id: product.id,
-                  percent: nextBundleDiscount.par_value,
-                  discount_product_id: nextBundleDiscount.product_id
-                },
-                metadata: {
-                  custom_product_bundle_map_id: nextUniqueId,
-                  num: 1
-                },
-                _num: 1,
-                config: nextBundleDiscount?.config
-              };
-              const nextAppliedProducts = appliedDiscountProducts.get(nextBundleDiscount.id) || [];
-              nextAppliedProducts.push(nextDiscountDetail);
-              appliedDiscountProducts.set(nextBundleDiscount.id, nextAppliedProducts);
-              processedItems.push({
-                ...flatItem,
-                _id: nextUniqueId,
-                num: 1,
-                quantity: 1,
-                price: nextDiscountedPrice,
-                total: nextDiscountedPrice,
-                discount_list: [nextDiscountDetail],
-                processed: true,
-                _discountId: nextBundleDiscount.id
-              });
-              continueSplitIndex++;
-            }
-            remainingNum -= nextSplitCount;
           }
         } else {
-          // 不拆分：直接应用折扣
-          const currentBundleDiscount = selectedDiscountCard || applicableDiscounts[0];
-          usedDiscounts.set(currentBundleDiscount.id, true);
-          // 🔥 更新 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)) {
-            const bundleQuantity = product.num || 1;
-            const currentNoSplitCount = usedDiscountCardLimitCounts.get(currentBundleDiscount.id) || 0;
-            usedDiscountCardLimitCounts.set(currentBundleDiscount.id, currentNoSplitCount + bundleQuantity);
+          const selectedDiscount2 = selectedDiscountCard || applicableDiscounts[0];
+          usedDiscounts.set(selectedDiscount2.id, true);
+          if ((selectedDiscount2.tag || selectedDiscount2.type) === "good_pass") {
+            const currentCount = usedProductIdCounts.get(selectedDiscount2.product_id) || 0;
+            usedProductIdCounts.set(selectedDiscount2.product_id, currentCount + 1);
           }
           const productOriginTotal = product.original_price || product.price || 0;
-
-          // 🔥 检查是否是 order_level 固定金额折扣卡
-          const isOrderLevel = (0, _utils.isOrderLevelFixedAmountDiscount)(selectedDiscount);
-          const orderLevelAllocation = isOrderLevel ? orderLevelDiscountAllocations.get(selectedDiscount.id) : null;
-          const productAllocation = orderLevelAllocation?.get(flatItem._id);
+          const isOrderLevel = (0, import_utils3.isOrderLevelFixedAmountDiscount)(selectedDiscount2);
+          const orderLevelAllocation = isOrderLevel ? orderLevelDiscountAllocations.get(selectedDiscount2.id) : null;
+          const productAllocation = orderLevelAllocation == null ? void 0 : 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 _decimal.default(productOriginTotal).minus(fixedAmountPerItem).toNumber(), 0);
+            targetProductTotal = Math.max(new import_decimal.default(productOriginTotal).minus(fixedAmountPerItem).toNumber(), 0);
           } else {
-            // item_level 或其他类型：使用原有逻辑
-            targetProductTotal = (0, _utils.getDiscountAmount)(currentBundleDiscount, productOriginTotal, productOriginTotal);
-            fixedAmountPerItem = new _decimal.default(productOriginTotal).minus(targetProductTotal).toNumber();
+            targetProductTotal = (0, import_utils.getDiscountAmount)(
+              selectedDiscount2,
+              productOriginTotal,
+              productOriginTotal
+            );
+            fixedAmountPerItem = 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,
+            amount: fixedAmountPerItem * (product.num || 1),
+            type: selectedDiscount2.tag === "product_discount_card" ? "discount_card" : selectedDiscount2.tag,
             discount: {
-              discount_card_type: currentBundleDiscount?.metadata?.discount_card_type,
-              fixed_amount: bundleActualDiscountAmount,
-              discount_calculation_mode: currentBundleDiscount?.metadata?.discount_calculation_mode,
-              resource_id: currentBundleDiscount.id,
-              title: currentBundleDiscount.format_title,
+              discount_card_type: (_G = selectedDiscount2 == null ? void 0 : selectedDiscount2.metadata) == null ? void 0 : _G.discount_card_type,
+              fixed_amount: fixedAmountPerItem,
+              discount_calculation_mode: (_H = selectedDiscount2 == null ? void 0 : selectedDiscount2.metadata) == null ? void 0 : _H.discount_calculation_mode,
+              resource_id: selectedDiscount2.id,
+              title: selectedDiscount2.format_title,
               original_amount: product.original_price,
               product_id: product.id || product.product_id,
-              percent: selectedDiscount.par_value,
-              discount_product_id: selectedDiscount.product_id
+              percent: selectedDiscount2.par_value,
+              discount_product_id: selectedDiscount2.product_id
             },
             metadata: {
               // 🔥 使用唯一的 _id
               custom_product_bundle_map_id: uniqueId,
-              discount_rule_uncheck_flag: selectedDiscount?.discount_rule_uncheck_flag,
+              discount_rule_uncheck_flag: selectedDiscount2 == null ? void 0 : selectedDiscount2.discount_rule_uncheck_flag,
               num: product.num || 1,
               // 🔥 order_level 分摊差值
-              ...(productDiscountDifference !== undefined && {
-                product_discount_difference: productDiscountDifference
-              })
+              ...productDiscountDifference !== void 0 && { product_discount_difference: productDiscountDifference }
             },
-            config: currentBundleDiscount?.config,
-            _num: (product.num || 1) * (flatItem?.parentProduct?.num || 1)
+            config: selectedDiscount2 == null ? void 0 : selectedDiscount2.config,
+            _num: (product.num || 1) * (((_I = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _I.num) || 1)
           };
-
-          // 记录实际应用的折扣
-          const appliedProducts = appliedDiscountProducts.get(currentBundleDiscount.id) || [];
+          const appliedProducts = appliedDiscountProducts.get(selectedDiscount2.id) || [];
           appliedProducts.push(discountDetail);
-          appliedDiscountProducts.set(currentBundleDiscount.id, appliedProducts);
+          appliedDiscountProducts.set(selectedDiscount2.id, appliedProducts);
           processedItems.push({
             ...flatItem,
             total: targetProductTotal,
-            price: new _decimal.default(productOriginTotal || 0).minus(fixedAmountPerItem).toNumber(),
-            discount_list: this.filterDiscountListByType(flatItem.discount_list, 'promotion').concat([discountDetail]),
+            price: new import_decimal.default(productOriginTotal || 0).minus(fixedAmountPerItem).toNumber(),
+            discount_list: this.filterDiscountListByType(flatItem.discount_list, "promotion").concat([discountDetail]),
             processed: true
           });
         }
         processedFlatItemsMap.set(flatItem._id, processedItems);
       }
     });
-
-    // 🔥 重组：将处理后的bundle子商品重新组装回主商品
-    const reconstructProductsWithBundle = (processedProductsMap, processedFlatItemsMap, originalProductList) => {
+    const reconstructProductsWithBundle = (processedProductsMap2, processedFlatItemsMap2, originalProductList) => {
       const result = [];
-      originalProductList.forEach(originProduct => {
+      originalProductList.forEach((originProduct) => {
         const product = this.hooks.getProduct(originProduct);
-
-        // 获取主商品处理结果
-        const mainProductArr = processedProductsMap.get(product._id);
+        const mainProductArr = processedProductsMap2.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, _utils2.getProductOriginTotalPrice)({
+                origin_total: (0, import_utils2.getProductOriginTotalPrice)({
                   product: {
                     original_price: product.original_price
                   },
@@ -1723,7 +1312,7 @@ class RulesModule extends _BaseModule.BaseModule {
                 }),
                 variant: originProduct._productInit.variant,
                 original_price: originProduct._productInit.original_price,
-                total: (0, _utils2.getProductTotalPrice)({
+                total: (0, import_utils2.getProductTotalPrice)({
                   product: {
                     price: product.price
                   },
@@ -1734,7 +1323,7 @@ class RulesModule extends _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,
@@ -1745,359 +1334,325 @@ class RulesModule extends _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 {
-          // 🔥 有bundle，需要检查子商品是否应用了商品券
-          // 1. 先收集所有bundle子商品的处理结果
-          const bundleProcessingInfo = new Map();
-          let hasGoodPassApplied = false; // 标记是否有子商品应用了商品券
-
+          const bundleProcessingInfo = /* @__PURE__ */ 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 = processedFlatItemsMap.get(bundleItemId);
+              const processedBundleItems = processedFlatItemsMap2.get(bundleItemId);
               if (!processedBundleItems || processedBundleItems.length === 0) {
-                // 未处理的bundle item，保持原样
                 bundleProcessingInfo.set(bundleIndex, [bundleItem]);
               } else {
-                // 处理过的bundle item
                 bundleProcessingInfo.set(bundleIndex, processedBundleItems);
-                // 🔥 检查是否应用了商品券（good_pass）
-                const hasGoodPass = processedBundleItems.some(item => item.discount_list?.some(discount => discount.type === 'good_pass' || discount.tag === 'good_pass'));
+                const hasGoodPass = processedBundleItems.some(
+                  (item) => {
+                    var _a2;
+                    return (_a2 = item.discount_list) == null ? void 0 : _a2.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 => {
-                  // 🔥 更新 discount_list 中的 num，使其与拆分后的 item.num 一致
-                  const updatedDiscountList = (item.discount_list || []).map(discount => ({
-                    ...discount,
-                    metadata: {
-                      ...discount.metadata,
-                      num: item.num,
-                      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) {
-                  // 🔥 同样需要更新 discount_list 中的 num
-                  const updatedDiscountList = (item.discount_list || []).map(discount => ({
-                    ...discount,
-                    metadata: {
-                      ...discount.metadata,
+            (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 _a2;
+                      return {
+                        ...discount,
+                        metadata: {
+                          ...discount.metadata,
+                          num: item.num,
+                          custom_product_bundle_map_id: (_a2 = item.metadata) == null ? void 0 : _a2.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,
-                      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
+                      discount_list: updatedDiscountList2
+                    });
                   });
                 } else {
-                  newBundleWithDiscount.push(item);
+                  const item = processedItems[0];
+                  if (item.processed) {
+                    const updatedDiscountList2 = (item.discount_list || []).map((discount) => {
+                      var _a2;
+                      return {
+                        ...discount,
+                        metadata: {
+                          ...discount.metadata,
+                          num: item.num,
+                          custom_product_bundle_map_id: (_a2 = item.metadata) == null ? void 0 : _a2.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,
+                      discount_list: updatedDiscountList2
+                    });
+                  } else {
+                    newBundleWithDiscount.push(item);
+                  }
                 }
               }
-            });
-
-            // 计算第一个主商品的总价（包含拆分后的bundle）
+            );
             let newTotalWithDiscount = Number(mainProductData.price || 0);
-            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保持不变
+            let newOriginTotalWithDiscount = Number(
+              mainProductData.original_price || mainProductData.price || 0
+            );
+            const updatedMainDiscountList = mainProductData.discount_list.map((discount) => {
+              var _a2, _b;
+              if ((_a2 = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a2.custom_product_bundle_map_id) {
                 return discount;
               }
-              // 主商品自己的discount，更新num为1
               return {
                 ...discount,
                 // num: 1,
                 metadata: {
                   ...discount.metadata,
-                  custom_product_bundle_map_id: discount?.metadata?.custom_product_bundle_map_id,
+                  custom_product_bundle_map_id: (_b = discount == null ? void 0 : discount.metadata) == null ? void 0 : _b.custom_product_bundle_map_id,
                   num: 1
                 }
               };
             });
-
-            // 🔥 使用更新后的列表计算折扣金额
-            const mainDiscountList = updatedMainDiscountList.filter(item => !item?.metadata?.custom_product_bundle_map_id);
+            const mainDiscountList = updatedMainDiscountList.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, _utils.getDiscountListAmountTotal)(mainDiscountList);
-              newTotalWithDiscount = new _decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotalWithDiscount;
+              const allDiscountAmount = (0, import_utils.getDiscountListAmountTotal)(mainDiscountList);
+              newTotalWithDiscount = new import_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 => {
-                const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
+              newBundleWithDiscount.forEach((item) => {
+                var _a2, _b, _c;
+                const originalPrice = ((_c = (_b = (_a2 = item.discount_list) == null ? void 0 : _a2[0]) == null ? void 0 : _b.discount) == null ? void 0 : _c.original_amount) || item.price;
                 newOriginTotalWithDiscount += Number(originalPrice) * Number(item.num);
               });
             }
-
-            // 累加options的价格（options不参与折扣，在最终设置total时处理）
-            if (product?.options) {
+            if (product == null ? void 0 : product.options) {
               newTotalWithDiscount = product.options.reduce((accumulator, currentValue) => {
-                const currentPrice = new _decimal.default(currentValue.price || 0);
-                const currentNum = new _decimal.default(currentValue.num || 0);
+                const currentPrice = new import_decimal.default(currentValue.price || 0);
+                const currentNum = new import_decimal.default(currentValue.num || 0);
                 return accumulator.add(currentPrice.mul(currentNum));
-              }, new _decimal.default(newTotalWithDiscount)).toNumber();
+              }, new import_decimal.default(newTotalWithDiscount)).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)
+            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()
+              })
+            );
             if (mainProductQuantity > 1) {
               const newBundleOriginal = [];
-              (product.bundle || []).forEach((bundleItem, bundleIndex) => {
-                // 使用原始的bundle配置，不包含拆分
-                newBundleOriginal.push({
-                  ...bundleItem,
-                  discount_list: []
-                });
-              });
-
-              // 计算第二个主商品的总价
+              (product.bundle || []).forEach(
+                (bundleItem, bundleIndex) => {
+                  newBundleOriginal.push({
+                    ...bundleItem,
+                    discount_list: []
+                  });
+                }
+              );
               let newTotalOriginal = Number(mainProductData.price || 0);
-              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保持不变
+              let newOriginTotalOriginal = Number(
+                mainProductData.original_price || mainProductData.price || 0
+              );
+              const updatedMainDiscountListOriginal = mainProductData.discount_list.map((discount) => {
+                var _a2, _b;
+                if ((_a2 = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a2.custom_product_bundle_map_id) {
                   return discount;
                 }
-                // 主商品自己的discount，更新num为 mainProductQuantity - 1
                 return {
                   ...discount,
                   metadata: {
                     ...discount.metadata,
                     num: mainProductQuantity - 1,
-                    custom_product_bundle_map_id: discount?.metadata?.custom_product_bundle_map_id
+                    custom_product_bundle_map_id: (_b = discount == null ? void 0 : discount.metadata) == null ? void 0 : _b.custom_product_bundle_map_id
                   }
                   // num: mainProductQuantity - 1,
                 };
               });
-
-              // 🔥 使用更新后的列表计算折扣金额
-              const mainDiscountListOriginal = updatedMainDiscountListOriginal.filter(item => !item?.metadata?.custom_product_bundle_map_id);
+              const mainDiscountListOriginal = updatedMainDiscountListOriginal.filter(
+                (item) => {
+                  var _a2;
+                  return !((_a2 = item == null ? void 0 : item.metadata) == null ? void 0 : _a2.custom_product_bundle_map_id);
+                }
+              );
               if (mainDiscountListOriginal && mainDiscountListOriginal.length > 0) {
-                const allDiscountAmount = (0, _utils.getDiscountListAmount)(mainDiscountListOriginal);
-                newTotalOriginal = new _decimal.default(mainProductData.price || 0).minus(allDiscountAmount).toNumber() ?? newTotalOriginal;
+                const allDiscountAmount = (0, import_utils.getDiscountListAmount)(
+                  mainDiscountListOriginal
+                );
+                newTotalOriginal = new import_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);
                 });
               }
-
-              // 累加options的价格（options不参与折扣，在最终设置total时处理）
-              if (product?.options) {
+              if (product == null ? void 0 : product.options) {
                 newTotalOriginal = product.options.reduce((accumulator, currentValue) => {
-                  const currentPrice = new _decimal.default(currentValue.price || 0);
-                  const currentNum = new _decimal.default(currentValue.num || 0);
+                  const currentPrice = new import_decimal.default(currentValue.price || 0);
+                  const currentNum = new import_decimal.default(currentValue.num || 0);
                   return accumulator.add(currentPrice.mul(currentNum));
-                }, new _decimal.default(newTotalOriginal)).toNumber();
+                }, new import_decimal.default(newTotalOriginal)).toNumber();
               }
-              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
-              }));
+              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
+                })
+              );
             }
           } else {
-            // 🔥 没有子商品被拆分，使用原有逻辑
-            mainProductArr.forEach(mainProduct => {
+            mainProductArr.forEach((mainProduct) => {
+              var _a2, _b, _c;
               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 = processedFlatItemsMap.get(bundleItemId);
+                  const processedBundleItems = processedFlatItemsMap2.get(bundleItemId);
                   if (!processedBundleItems || processedBundleItems.length === 0) {
-                    // 未处理的bundle item，保持原样
                     newBundle.push(bundleItem);
                   } else {
-                    // 🔥 关键：拆分后的bundle item
-                    processedBundleItems.forEach(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
-                      }));
+                      const updatedDiscountList2 = (item.discount_list || []).map((discount) => {
+                        var _a3;
+                        return {
+                          ...discount,
+                          metadata: {
+                            ...discount.metadata,
+                            num: item.num,
+                            custom_product_bundle_map_id: (_a3 = discount == null ? void 0 : discount.metadata) == null ? void 0 : _a3.custom_product_bundle_map_id
+                          }
+                          // num: item.num, // 使用拆分后的 num
+                        };
+                      });
                       newBundle.push({
                         ...bundleItem,
                         _id: item._id,
                         product_id: bundleItem.product_id,
                         price: nextBundlePrice,
                         num: item.num,
-                        discount_list: updatedDiscountList,
-                        bundle_selling_price: bundleItem.bundle_selling_price !== undefined ? nextBundleSellingPrice : undefined
+                        discount_list: updatedDiscountList2,
+                        bundle_selling_price: bundleItem.bundle_selling_price !== void 0 ? nextBundleSellingPrice : void 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 && (!mainProductData.discount_list?.length || mainProductData?.discount_list?.every?.(item => item.type === 'product'));
-
-              // 如果是手动折扣，使用原有的total和origin_total，不重新计算
+              const isManualDiscount = typeof mainProductData.isManualDiscount === "boolean" ? mainProductData.isManualDiscount : mainProductData.total != mainProductData.origin_total && (!((_a2 = mainProductData.discount_list) == null ? void 0 : _a2.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")));
               if (isManualDiscount) {
                 newTotal = mainProductData.total ?? newTotal;
                 newOriginTotal = mainProductData.origin_total ?? newOriginTotal;
               } else {
-                // 累加bundle的折后价格（只累加一次）
                 if (newBundle.length > 0) {
-                  newBundle.forEach(item => {
-                    newTotal += Number(item.price) * Number(item.num);
-                    const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
-                    newOriginTotal += Number(originalPrice) * Number(item.num);
+                  newBundle.forEach((item) => {
+                    const bundleSellingPrice = item.bundle_selling_price ?? item.price;
+                    newTotal += Number(bundleSellingPrice) * Number(item.num);
                   });
-                  // 计算原始总价（不考虑折扣）
-                  newBundle.forEach(item => {
-                    const originalPrice = item.discount_list?.[0]?.discount?.original_amount || item.price;
+                  newBundle.forEach((item) => {
+                    var _a3, _b2, _c2;
+                    const originalPrice = ((_c2 = (_b2 = (_a3 = item.discount_list) == null ? void 0 : _a3[0]) == null ? void 0 : _b2.discount) == null ? void 0 : _c2.original_amount) || item.price;
                     newOriginTotal += Number(originalPrice) * Number(item.num);
                   });
                 }
               }
-
-              // 累加options的价格（options不参与折扣，在最终设置total时处理）
-              if (product?.options) {
+              if (product == null ? void 0 : product.options) {
                 newTotal = product.options.reduce((accumulator, currentValue) => {
-                  const currentPrice = new _decimal.default(currentValue.price || 0);
-                  const currentNum = new _decimal.default(currentValue.num || 0);
+                  const currentPrice = new import_decimal.default(currentValue.price || 0);
+                  const currentNum = new import_decimal.default(currentValue.num || 0);
                   return accumulator.add(currentPrice.mul(currentNum));
-                }, new _decimal.default(newTotal)).toNumber();
+                }, new import_decimal.default(newTotal)).toNumber();
               }
-              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
-              }));
+              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
+                })
+              );
             });
           }
         }
       });
       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;
-
-      // 如果此优惠券被明确设置为不选中，保持其状态，但正确设置isAvailable
-      if (typeof discount.isSelected === 'boolean' && discount.isSelected === false && discount.isManualSelect) {
+      if (typeof discount.isSelected === "boolean" && discount.isSelected === false && discount.isManualSelect) {
         return {
           ...discount,
           isSelected: false,
-          isAvailable: isAvailable,
+          isAvailable,
           // 正确设置可用性
           applicableProductIds: applicableProducts,
           // 添加可抵扣的商品详情
-          applicableProductDetails: applicableProductDetails,
+          applicableProductDetails,
           // 添加实际抵扣的商品详情（对于未选中的优惠券，为空数组）
           appliedProductDetails: []
         };
@@ -2106,20 +1661,18 @@ class RulesModule extends _BaseModule.BaseModule {
         return {
           ...discount,
           isSelected: true,
-          isManualSelect: options?.scan ? false : discount.isManualSelect,
+          isManualSelect: (options == null ? void 0 : options.scan) ? false : discount.isManualSelect,
           // 标记为可用，因为它已被应用
           isAvailable: true,
           // 记录适用的商品IDs
           applicableProductIds: applicableProducts,
           // 添加可抵扣的商品详情
-          applicableProductDetails: applicableProductDetails,
+          applicableProductDetails,
           // 添加实际抵扣的商品详情
-          appliedProductDetails: appliedProductDetails
+          appliedProductDetails
         };
       }
-      let isSelected = typeof discount.isSelected === 'boolean' ? discount.isSelected : undefined;
-
-      // 如果是可用的 并且没有手动标记 则设置为选中
+      let isSelected = typeof discount.isSelected === "boolean" ? discount.isSelected : void 0;
       if (isAvailable && appliedProductDetails.length && !discount.isManualSelect) {
         isSelected = true;
       } else if (!appliedProductDetails.length) {
@@ -2128,14 +1681,14 @@ class RulesModule extends _BaseModule.BaseModule {
       return {
         ...discount,
         // 如果有适用的商品，标记为可用
-        isAvailable: isAvailable,
+        isAvailable,
         isSelected,
         // 如果是扫码进来的，要手动设置为手动选择：false
-        isManualSelect: options?.scan ? false : discount.isManualSelect,
+        isManualSelect: (options == null ? void 0 : options.scan) ? false : discount.isManualSelect,
         // 记录适用的商品IDs
         applicableProductIds: applicableProducts,
         // 添加可抵扣的商品详情
-        applicableProductDetails: applicableProductDetails,
+        applicableProductDetails,
         // 添加实际抵扣的商品详情（对于未使用的优惠券，为空数组）
         appliedProductDetails: []
       };
@@ -2145,7 +1698,6 @@ class RulesModule extends _BaseModule.BaseModule {
       discountList: [...editModeDiscount, ...updatedDiscountList]
     };
   }
-
   /**
    * 检查优惠是否符合 PackageSubItemUsageRules 配置
    * @param discount 优惠券
@@ -2153,229 +1705,105 @@ class RulesModule extends _BaseModule.BaseModule {
    * @returns 是否可用
    */
   checkPackageSubItemUsageRules(discount, flatItem) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const limitedData = discount.limited_relation_product_data;
-    const usageRules = limitedData?.package_sub_item_usage_rules;
-    const rules = ['original_price', ...(usageRules?.rules || [])];
-
-    // 如果没有配置 package_sub_item_usage_rules，则默认可用
+    const usageRules = limitedData == null ? void 0 : limitedData.package_sub_item_usage_rules;
+    const rules = ["original_price", ...(usageRules == null ? void 0 : usageRules.rules) || []];
     if (!usageRules) {
       return true;
     }
     const ruleType = usageRules.type;
-    // 套餐适用范围配置
-    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;
-
-    // 主商品直接可用
+    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 bundleMainProductId = (_a = flatItem.product) == null ? void 0 : _a.product_id;
     if (isMainProduct) {
       return true;
     }
-
-    // universal_discount: 单独购买和套餐中（子商品为原价）均可使用
-    if (ruleType === 'universal_discount') {
+    if (ruleType === "universal_discount") {
       if (isMainProduct) {
-        return true; // 单独购买时可用
+        return true;
       }
       if (isBundleItem) {
-        // 套餐中购买时，判断是否为原价
-        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
+        const priceType = (_b = flatItem.bundleItem) == null ? void 0 : _b.price_type;
+        const priceTypeExt = (_c = flatItem.bundleItem) == null ? void 0 : _c.price_type_ext;
+        const mainProductId = ((_e = (_d = flatItem == null ? void 0 : flatItem.originProduct) == null ? void 0 : _d._productOrigin) == null ? void 0 : _e.id) || ((_f = flatItem == null ? void 0 : flatItem.parentProduct) == null ? void 0 : _f.id) || 0;
+        const isOriginalPrice = priceType === "markup" && priceTypeExt === "product_price";
+        const isMarkupPrice = priceType === "markup" && (priceTypeExt === "" || !priceTypeExt);
         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;
-
-          // 排除套餐判断, product_all值兼容旧数据
-          if (scopeType === 'all_packages' || scopeType === 'product_all') {
-            // 所有套餐可用
+          if (scopeType === "all_packages" || scopeType === "product_all") {
             if (!filter) {
               isScopeValid = true;
             } else {
               isScopeValid = !exclude_bundle_product_ids.includes(Number(bundleMainProductId));
             }
           }
-
-          // 包含套餐判断, products值兼容旧数据
-          if (scopeType === 'specific_packages' || scopeType === '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;
     }
-
-    // package_exclusive: 仅在套餐中（子商品为原价）时可使用
-    if (ruleType === 'package_exclusive') {
+    if (ruleType === "package_exclusive") {
       if (isMainProduct) {
-        return false; // 单独购买时不可用
+        return false;
       }
       if (isBundleItem) {
-        // 套餐中购买时，判断是否为原价
-        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
+        const priceType = (_g = flatItem.bundleItem) == null ? void 0 : _g.price_type;
+        const priceTypeExt = (_h = flatItem.bundleItem) == null ? void 0 : _h.price_type_ext;
+        const isOriginalPrice = priceType === "markup" && priceTypeExt === "product_price";
+        const isMarkupPrice = priceType === "markup" && (priceTypeExt === "" || !priceTypeExt);
         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;
-
-          // 排除套餐判断, product_all值兼容旧数据
-          if (scopeType === 'all_packages' || scopeType === 'product_all') {
-            // 所有套餐可用
+          if (scopeType === "all_packages" || scopeType === "product_all") {
             if (!filter) {
               isScopeValid = true;
             } else {
               isScopeValid = !exclude_bundle_product_ids.includes(Number(bundleMainProductId));
             }
           }
-
-          // 包含套餐判断, products值兼容旧数据
-          if (scopeType === 'specific_packages' || scopeType === '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;
     }
-
-    // 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;
+    if (ruleType === "single_item_promo") {
+      return isMainProduct;
     }
-    * */
-
-    // 默认可用
     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() {}
-}
-exports.RulesModule = RulesModule;
+  async clear() {
+    console.log("[Rules] clear");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RulesModule
+});