@pisell/pisellos 0.0.328 → 0.0.330

package/dist/solution/BookingByStep/index.js

@@ -30,6 +30,7 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 import { BaseModule } from "../../modules/BaseModule";
 import { createModule } from "./types";
+import { formatProductToCartItem, createCartItemOrigin, getUniqueId, handleVariantProduct } from "../../modules/Cart/utils";
 import { getAvailableProductResources } from "./utils/products";
 import { getResourcesByProduct, getTimeSlicesByResource, getTimeSlicesByResources, getIsUsableByTimeItem, getOthersSelectedResources, getOthersCartSelectedResources, filterScheduleByDateRange, checkSessionProductLeadTime, sortCombinedResources, filterResourcesByFormItem, checkTwoResourcesIntersection, isConflict } from "./utils/resources";
 import dayjs from 'dayjs';
@@ -3072,6 +3073,402 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
         minAvailableCount: minAvailableCount
       };
     }
+
+    /**
+     * 将 ProductData 转换为 CartItem，但不添加到购物车
+     * 参考 addProductToCart 方法的实现
+     */
+  }, {
+    key: "convertProductToCartItem",
+    value: function convertProductToCartItem(product) {
+      var _ref11 = product || {},
+        bundle = _ref11.bundle,
+        options = _ref11.options,
+        origin = _ref11.origin,
+        product_variant_id = _ref11.product_variant_id,
+        _ref11$quantity = _ref11.quantity,
+        quantity = _ref11$quantity === void 0 ? 1 : _ref11$quantity;
+
+      // 处理商品数据，类似 addProductToCart 中的逻辑
+      var productData = _objectSpread(_objectSpread({}, origin), {}, {
+        product_variant_id: product_variant_id
+      });
+
+      // 处理组合商品
+      var processedProduct = handleVariantProduct(productData);
+
+      // 创建基础的 CartItem
+      var cartItem = {
+        _id: getUniqueId('temp_'),
+        _origin: createCartItemOrigin(),
+        _productOrigin: processedProduct,
+        _productInit: product
+      };
+
+      // 获取当前活跃账户
+      var activeAccount = this.getActiveAccount();
+
+      // 使用格式化函数填充 CartItem 数据
+      formatProductToCartItem({
+        cartItem: cartItem,
+        product: processedProduct,
+        bundle: bundle,
+        options: options,
+        product_variant_id: product_variant_id,
+        quantity: quantity
+      });
+      return cartItem;
+    }
+  }, {
+    key: "checkMaxDurationCapacityForDetailNums",
+    value: function checkMaxDurationCapacityForDetailNums(currentProduct) {
+      var _this16 = this;
+      var cartItems = cloneDeep(this.store.cart.getItems());
+
+      // 将 ProductData 转换为 CartItem 但不真正添加到购物车
+      var currentCartItem = this.convertProductToCartItem(currentProduct);
+      cartItems.push(currentCartItem);
+      if (cartItems.length === 0) return {
+        success: true,
+        minAvailableCount: 0
+      };
+
+      // 将购物车商品分为有时间的和没有时间的
+      var itemsWithTime = [];
+      var itemsWithoutTime = [];
+      // 记录每种资源类型的可用数量
+      var availableCountsByResourceType = [];
+      cartItems.forEach(function (cartItem) {
+        if (cartItem.start_time && cartItem.end_time && cartItem.start_date) {
+          itemsWithTime.push(cartItem);
+        } else {
+          itemsWithoutTime.push(cartItem);
+        }
+      });
+
+      // 处理没有时间的商品，为它们分配公共可用时间的第一个时间片
+      var processedItemsWithoutTime = [];
+      if (itemsWithoutTime.length > 0) {
+        // 按资源类型分组处理没有时间的商品
+        var itemsByResourceType = {};
+        itemsWithoutTime.forEach(function (cartItem) {
+          var _cartItem$_productOri13;
+          if (!cartItem._productOrigin) return;
+          var resourceTypes = ((_cartItem$_productOri13 = cartItem._productOrigin.product_resource) === null || _cartItem$_productOri13 === void 0 ? void 0 : _cartItem$_productOri13.resources) || [];
+          resourceTypes.forEach(function (resourceType) {
+            if (resourceType.status === 1) {
+              var _resourceType$id2;
+              var resourceCode = resourceType.code || ((_resourceType$id2 = resourceType.id) === null || _resourceType$id2 === void 0 ? void 0 : _resourceType$id2.toString());
+              if (!itemsByResourceType[resourceCode]) {
+                itemsByResourceType[resourceCode] = [];
+              }
+              // 避免重复添加同一个商品
+              if (!itemsByResourceType[resourceCode].find(function (item) {
+                return item._id === cartItem._id;
+              })) {
+                itemsByResourceType[resourceCode].push(cartItem);
+              }
+            }
+          });
+        });
+
+        // 为每种资源类型检查容量
+        var dateRange = this.store.date.getDateRange();
+        if (!dateRange || dateRange.length === 0) return {
+          success: false,
+          minAvailableCount: 0
+        };
+        var resourcesDates = this.store.date.getDateList();
+        var targetResourceDate = resourcesDates.find(function (n) {
+          return n.date === dateRange[0].date;
+        });
+        if (!targetResourceDate) return {
+          success: false,
+          minAvailableCount: 0
+        };
+        var resourcesMap = getResourcesMap(targetResourceDate.resource || []);
+
+        // 从购物车商品中获取资源类型配置，建立 resourceCode 到 form_id 的映射关系
+        var resourceCodeToFormIdMap = {};
+
+        // 遍历购物车中的商品，收集所有资源类型配置
+        Object.values(itemsByResourceType).flat().forEach(function (cartItem) {
+          var _cartItem$_productOri14;
+          if ((_cartItem$_productOri14 = cartItem._productOrigin) !== null && _cartItem$_productOri14 !== void 0 && (_cartItem$_productOri14 = _cartItem$_productOri14.product_resource) !== null && _cartItem$_productOri14 !== void 0 && _cartItem$_productOri14.resources) {
+            cartItem._productOrigin.product_resource.resources.forEach(function (resourceConfig) {
+              // 只处理启用的资源类型 (status === 1)
+              if (resourceConfig.status === 1 && resourceConfig.code) {
+                var _resourceConfig$id2, _resourceConfig$resou2;
+                var formId = ((_resourceConfig$id2 = resourceConfig.id) === null || _resourceConfig$id2 === void 0 ? void 0 : _resourceConfig$id2.toString()) || ((_resourceConfig$resou2 = resourceConfig.resource_type_id) === null || _resourceConfig$resou2 === void 0 ? void 0 : _resourceConfig$resou2.toString());
+                if (formId) {
+                  resourceCodeToFormIdMap[resourceConfig.code] = formId;
+                }
+              }
+            });
+          }
+        });
+        var hasCapacityIssue = false;
+        var resourceCapacityInfo = [];
+
+        // 用于跟踪已处理的商品，避免重复添加
+        var processedCartItemIds = new Set();
+
+        // 先检查所有资源类型，收集可用数量信息
+        var _loop5 = function _loop5() {
+            var _resourceTypeConfig2;
+            var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+              resourceCode = _Object$entries3$_i[0],
+              items = _Object$entries3$_i[1];
+            // 获取该资源类型对应的 form_id
+            var targetFormId = resourceCodeToFormIdMap[resourceCode];
+            if (!targetFormId) {
+              console.log("\u8D44\u6E90\u7C7B\u578B ".concat(resourceCode, " \u627E\u4E0D\u5230\u5BF9\u5E94\u7684 form_id"));
+              return {
+                v: {
+                  success: false,
+                  minAvailableCount: 0
+                }
+              };
+            }
+
+            // 获取该资源类型的所有资源
+            var resourcesOfThisType = [];
+            items.forEach(function (cartItem) {
+              var productResourceIds = getResourcesIdsByProduct(cartItem._productOrigin);
+              productResourceIds.forEach(function (resourceId) {
+                var _resource$form_id2;
+                var resource = resourcesMap[resourceId];
+                if (resource && ((_resource$form_id2 = resource.form_id) === null || _resource$form_id2 === void 0 ? void 0 : _resource$form_id2.toString()) === targetFormId) {
+                  // 避免重复添加同一个资源
+                  if (!resourcesOfThisType.find(function (r) {
+                    return r.id === resource.id;
+                  })) {
+                    resourcesOfThisType.push(resource);
+                  }
+                }
+              });
+            });
+            if (resourcesOfThisType.length === 0) {
+              console.log("\u8D44\u6E90\u7C7B\u578B ".concat(resourceCode, " \u6CA1\u6709\u627E\u5230\u53EF\u7528\u8D44\u6E90"));
+              return {
+                v: {
+                  success: false,
+                  minAvailableCount: 0
+                }
+              };
+            }
+
+            // 检查资源类型（单个预约 vs 多个预约）
+            // 从商品配置中获取资源类型信息
+            var resourceTypeConfig = null;
+            var _iterator4 = _createForOfIteratorHelper(items),
+              _step4;
+            try {
+              for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+                var _cartItem$_productOri15;
+                var cartItem = _step4.value;
+                if ((_cartItem$_productOri15 = cartItem._productOrigin) !== null && _cartItem$_productOri15 !== void 0 && (_cartItem$_productOri15 = _cartItem$_productOri15.product_resource) !== null && _cartItem$_productOri15 !== void 0 && _cartItem$_productOri15.resources) {
+                  resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(function (r) {
+                    return r.code === resourceCode && r.status === 1;
+                  });
+                  if (resourceTypeConfig) break;
+                }
+              }
+            } catch (err) {
+              _iterator4.e(err);
+            } finally {
+              _iterator4.f();
+            }
+            var isMultipleBooking = ((_resourceTypeConfig2 = resourceTypeConfig) === null || _resourceTypeConfig2 === void 0 ? void 0 : _resourceTypeConfig2.type) === 'multiple';
+            var totalAvailable;
+            var requiredAmount;
+            var availableAmount;
+            if (isMultipleBooking) {
+              // 多个预约：计算容量
+              totalAvailable = resourcesOfThisType.reduce(function (sum, resource) {
+                return sum + (resource.capacity || 0);
+              }, 0);
+              requiredAmount = items.reduce(function (sum, cartItem) {
+                var _getCapacityInfoByCar8 = getCapacityInfoByCartItem(cartItem),
+                  currentCapacity = _getCapacityInfoByCar8.currentCapacity;
+                return sum + currentCapacity;
+              }, 0);
+              availableAmount = Math.max(0, totalAvailable - requiredAmount);
+            } else {
+              // 单个预约：计算资源个数
+              totalAvailable = resourcesOfThisType.length;
+              requiredAmount = items.reduce(function (sum, cartItem) {
+                return sum + (cartItem.num || 1);
+              }, 0);
+              availableAmount = Math.max(0, totalAvailable - requiredAmount);
+            }
+
+            // 记录资源容量信息
+            resourceCapacityInfo.push({
+              code: resourceCode,
+              available: availableAmount,
+              total: totalAvailable,
+              required: requiredAmount,
+              isMultiple: isMultipleBooking
+            });
+            availableCountsByResourceType.push(availableAmount);
+
+            // 检查是否有容量问题
+            if (requiredAmount > totalAvailable) {
+              hasCapacityIssue = true;
+              console.log("\u8D44\u6E90\u7C7B\u578B ".concat(resourceCode, " ").concat(isMultipleBooking ? '容量' : '资源数量', "\u4E0D\u8DB3: \u9700\u8981 ").concat(requiredAmount, ", \u603B\u5171 ").concat(totalAvailable));
+            }
+
+            // 为通过检测的商品分配一个公共可用时间段
+            console.log("\u8D44\u6E90\u7C7B\u578B ".concat(resourceCode, " \u7684\u8D44\u6E90\u65F6\u95F4\u4FE1\u606F:"), resourcesOfThisType.map(function (r) {
+              return {
+                id: r.id,
+                times: r.times.map(function (t) {
+                  return "".concat(t.start_at, " - ").concat(t.end_at);
+                })
+              };
+            }));
+
+            // 找到所有资源都可用的时间段
+            var commonTimeSlots = _this16.findCommonAvailableTimeSlots(resourcesOfThisType);
+            console.log("\u8D44\u6E90\u7C7B\u578B ".concat(resourceCode, " \u7684\u516C\u5171\u65F6\u95F4\u6BB5:"), commonTimeSlots);
+            if (commonTimeSlots.length === 0) {
+              console.log("\u8D44\u6E90\u7C7B\u578B ".concat(resourceCode, " \u6CA1\u6709\u516C\u5171\u53EF\u7528\u65F6\u95F4\u6BB5"));
+              return {
+                v: {
+                  success: false,
+                  minAvailableCount: 0
+                }
+              };
+            }
+
+            // 使用第一个公共可用时间段，但只处理未处理过的商品
+            var firstCommonSlot = commonTimeSlots[0];
+            console.log("\u4F7F\u7528\u516C\u5171\u65F6\u95F4\u6BB5: ".concat(firstCommonSlot.startTime, " - ").concat(firstCommonSlot.endTime));
+            items.forEach(function (cartItem) {
+              // 只处理未处理过的商品，避免重复添加
+              if (!processedCartItemIds.has(cartItem._id)) {
+                processedCartItemIds.add(cartItem._id);
+                var processedItem = _objectSpread(_objectSpread({}, cartItem), {}, {
+                  start_date: dateRange[0].date,
+                  start_time: firstCommonSlot.startTime,
+                  end_time: firstCommonSlot.endTime,
+                  end_date: dateRange[0].date
+                });
+                processedItemsWithoutTime.push(processedItem);
+              }
+            });
+          },
+          _ret5;
+        for (var _i3 = 0, _Object$entries3 = Object.entries(itemsByResourceType); _i3 < _Object$entries3.length; _i3++) {
+          _ret5 = _loop5();
+          if (_ret5) return _ret5.v;
+        }
+
+        // 如果有容量问题，找出限制最严格的资源类型，返回其总容量
+        if (hasCapacityIssue) {
+          // 找出超出容量的资源类型中，总容量最少的那个
+          var overCapacityResources = resourceCapacityInfo.filter(function (info) {
+            return info.required > info.total;
+          });
+          if (overCapacityResources.length > 0) {
+            var _minTotalCapacity2 = Math.min.apply(Math, _toConsumableArray(overCapacityResources.map(function (info) {
+              return info.total;
+            })));
+            return {
+              success: false,
+              minAvailableCount: _minTotalCapacity2
+            };
+          }
+          // 如果没有超出容量的（理论上不应该发生），返回总容量最少的
+          var minTotalCapacity = Math.min.apply(Math, _toConsumableArray(resourceCapacityInfo.map(function (info) {
+            return info.total;
+          })));
+          return {
+            success: false,
+            minAvailableCount: minTotalCapacity
+          };
+        }
+      }
+
+      // 合并所有商品（有时间的 + 处理后的没有时间的）
+      var allProcessedItems = [].concat(itemsWithTime, processedItemsWithoutTime);
+
+      // 按时间段分组检查
+      var cartItemsByTimeSlot = {};
+      allProcessedItems.forEach(function (cartItem) {
+        if (!cartItem.start_time || !cartItem.end_time || !cartItem.start_date) return;
+        var timeSlotKey = "".concat(cartItem.start_date, "_").concat(cartItem.start_time, "_").concat(cartItem.end_date || cartItem.start_date, "_").concat(cartItem.end_time);
+        if (!cartItemsByTimeSlot[timeSlotKey]) {
+          cartItemsByTimeSlot[timeSlotKey] = [];
+        }
+        cartItemsByTimeSlot[timeSlotKey].push(cartItem);
+      });
+      // 检查每个时间段是否有足够的资源容量
+      var _loop6 = function _loop6() {
+          var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+            timeSlotKey = _Object$entries4$_i[0],
+            itemsInTimeSlot = _Object$entries4$_i[1];
+          var _timeSlotKey$split3 = timeSlotKey.split('_'),
+            _timeSlotKey$split4 = _slicedToArray(_timeSlotKey$split3, 4),
+            startDate = _timeSlotKey$split4[0],
+            startTime = _timeSlotKey$split4[1],
+            endDate = _timeSlotKey$split4[2],
+            endTime = _timeSlotKey$split4[3];
+          var timeSlotStart = "".concat(startDate, " ").concat(startTime);
+          var timeSlotEnd = "".concat(endDate, " ").concat(endTime);
+
+          // 获取这个时间段所有商品涉及的资源
+          var allResourcesForTimeSlot = [];
+          var resourcesIdSet = new Set();
+
+          // 获取资源数据
+          var dateRange = _this16.store.date.getDateRange();
+          var resourcesDates = _this16.store.date.getDateList();
+          var targetResourceDate = resourcesDates.find(function (n) {
+            return n.date === startDate;
+          });
+          if (!targetResourceDate) return 0; // continue
+          var resourcesMap = getResourcesMap(targetResourceDate.resource || []);
+          itemsInTimeSlot.forEach(function (cartItem) {
+            if (!cartItem._productOrigin) return;
+
+            // 获取商品的资源配置
+            var productResourceIds = getResourcesIdsByProduct(cartItem._productOrigin);
+            productResourceIds.forEach(function (resourceId) {
+              if (resourcesMap[resourceId] && !resourcesIdSet.has(resourceId)) {
+                resourcesIdSet.add(resourceId);
+                allResourcesForTimeSlot.push(resourcesMap[resourceId]);
+              }
+            });
+          });
+
+          // 按资源类型分组检查容量
+          if (!checkTimeSlotCapacity(timeSlotStart, timeSlotEnd, itemsInTimeSlot, allResourcesForTimeSlot)) {
+            // 如果有可用数量记录，返回最小值；否则返回 0
+            var _minAvailableCount2 = availableCountsByResourceType.length > 0 ? Math.min.apply(Math, availableCountsByResourceType) : 0;
+            return {
+              v: {
+                success: false,
+                minAvailableCount: _minAvailableCount2
+              }
+            };
+          }
+        },
+        _ret6;
+      for (var _i4 = 0, _Object$entries4 = Object.entries(cartItemsByTimeSlot); _i4 < _Object$entries4.length; _i4++) {
+        _ret6 = _loop6();
+        if (_ret6 === 0) continue;
+        if (_ret6) return _ret6.v;
+      }
+
+      // 全部通过检测，返回成功和最小可用数量
+      var minAvailableCount = availableCountsByResourceType.length > 0 ? Math.min.apply(Math, availableCountsByResourceType) : 0;
+      return {
+        success: true,
+        minAvailableCount: minAvailableCount
+      };
+    }
   }, {
     key: "setOtherData",
     value: function setOtherData(key, value) {
@@ -3143,7 +3540,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "getResourcesByCartItemAndCode",
     value: function getResourcesByCartItemAndCode(cartItemId, resourceCode) {
-      var _cartItem$_productOri13;
+      var _cartItem$_productOri16;
       var dateRange = this.store.date.getDateRange();
       var resources = [];
       if (dateRange !== null && dateRange !== void 0 && dateRange.length) {
@@ -3166,16 +3563,16 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
       });
       if (!cartItem) return [];
       var selectedResources = [];
-      var _getCapacityInfoByCar8 = getCapacityInfoByCartItem(cartItem),
-        currentCapacity = _getCapacityInfoByCar8.currentCapacity,
-        formatCapacity = _getCapacityInfoByCar8.formatCapacity;
+      var _getCapacityInfoByCar9 = getCapacityInfoByCartItem(cartItem),
+        currentCapacity = _getCapacityInfoByCar9.currentCapacity,
+        formatCapacity = _getCapacityInfoByCar9.formatCapacity;
       cartItem._origin.metadata.capacity = formatCapacity;
       if (cartItem.holder_id) {
         selectedResources = getOthersSelectedResources(cartItems, cartItem.holder_id, resourcesMap);
       } else {
         selectedResources = getOthersCartSelectedResources(cartItems, cartItem._id, resourcesMap);
       }
-      var productResources = getResourcesByProduct(resourcesMap, ((_cartItem$_productOri13 = cartItem._productOrigin) === null || _cartItem$_productOri13 === void 0 || (_cartItem$_productOri13 = _cartItem$_productOri13.product_resource) === null || _cartItem$_productOri13 === void 0 ? void 0 : _cartItem$_productOri13.resources) || [], selectedResources, currentCapacity);
+      var productResources = getResourcesByProduct(resourcesMap, ((_cartItem$_productOri16 = cartItem._productOrigin) === null || _cartItem$_productOri16 === void 0 || (_cartItem$_productOri16 = _cartItem$_productOri16.product_resource) === null || _cartItem$_productOri16 === void 0 ? void 0 : _cartItem$_productOri16.resources) || [], selectedResources, currentCapacity);
       var targetResource = productResources.find(function (resource) {
         return resource.code === resourceCode;
       });
@@ -3198,7 +3595,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
           });
           if (mTimes.length === 0) return false;
           var canUseArr = mTimes.map(function (item) {
-            var _cartItem$_productOri14;
+            var _cartItem$_productOri17;
             var res = getIsUsableByTimeItem({
               timeSlice: {
                 start_time: startTime.format('HH:mm'),
@@ -3210,7 +3607,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
               resource: m,
               currentCount: currentCapacity || 0,
               resourcesUseableMap: resourcesUseableMap,
-              cut_off_time: (_cartItem$_productOri14 = cartItem._productOrigin) === null || _cartItem$_productOri14 === void 0 ? void 0 : _cartItem$_productOri14.cut_off_time
+              cut_off_time: (_cartItem$_productOri17 = cartItem._productOrigin) === null || _cartItem$_productOri17 === void 0 ? void 0 : _cartItem$_productOri17.cut_off_time
             });
             if ((resourcesUseableMap === null || resourcesUseableMap === void 0 ? void 0 : resourcesUseableMap[m.id]) !== false && res.reason !== 'capacityOnly') {
               resourcesUseableMap[m.id] = res.usable;
@@ -3224,12 +3621,12 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
         });
       } else {
         targetResource.renderList = targetResource.renderList.filter(function (n) {
-          var _cartItem$_productOri15;
+          var _cartItem$_productOri18;
           var recordCount = n.capacity || 0;
           if (n.onlyComputed) return false;
           var timeSlots = getTimeSlicesByResource({
             resource: n,
-            duration: ((_cartItem$_productOri15 = cartItem._productOrigin) === null || _cartItem$_productOri15 === void 0 || (_cartItem$_productOri15 = _cartItem$_productOri15.duration) === null || _cartItem$_productOri15 === void 0 ? void 0 : _cartItem$_productOri15.value) || 10,
+            duration: ((_cartItem$_productOri18 = cartItem._productOrigin) === null || _cartItem$_productOri18 === void 0 || (_cartItem$_productOri18 = _cartItem$_productOri18.duration) === null || _cartItem$_productOri18 === void 0 ? void 0 : _cartItem$_productOri18.value) || 10,
             split: 10,
             currentDate: dateRange[0].date
           });
@@ -3247,12 +3644,12 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
   }, {
     key: "getTimeslotsScheduleByDateRange",
     value: (function () {
-      var _getTimeslotsScheduleByDateRange = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26(_ref11) {
-        var startDate, endDate, scheduleIds, resources, dates, currentDate, end, results, _i3, _dates, date;
+      var _getTimeslotsScheduleByDateRange = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee26(_ref12) {
+        var startDate, endDate, scheduleIds, resources, dates, currentDate, end, results, _i5, _dates, date;
         return _regeneratorRuntime().wrap(function _callee26$(_context26) {
           while (1) switch (_context26.prev = _context26.next) {
             case 0:
-              startDate = _ref11.startDate, endDate = _ref11.endDate, scheduleIds = _ref11.scheduleIds, resources = _ref11.resources;
+              startDate = _ref12.startDate, endDate = _ref12.endDate, scheduleIds = _ref12.scheduleIds, resources = _ref12.resources;
               console.log('appoimentBooking-session-date-getTimeslotsScheduleByDateRange', {
                 startDate: startDate,
                 endDate: endDate,
@@ -3269,8 +3666,8 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
               }
               // 如果不支持 Web Worker，使用同步方式处理
               results = {};
-              for (_i3 = 0, _dates = dates; _i3 < _dates.length; _i3++) {
-                date = _dates[_i3];
+              for (_i5 = 0, _dates = dates; _i5 < _dates.length; _i5++) {
+                date = _dates[_i5];
                 results[date] = this.getTimeslotBySchedule({
                   date: date,
                   scheduleIds: scheduleIds,
@@ -3311,7 +3708,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
           openResources,
           allProductResources,
           targetSchedules,
-          _loop5,
+          _loop7,
           _args28 = arguments;
         return _regeneratorRuntime().wrap(function _callee27$(_context28) {
           while (1) switch (_context28.prev = _context28.next) {
@@ -3388,9 +3785,9 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                 }
               });
               targetSchedules = this.store.schedule.getScheduleListByIds(tempProducts['schedule.ids']);
-              _loop5 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop5() {
+              _loop7 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop7() {
                 var currentDateStr, status, _checkSessionProductL, latestStartDate, earliestEndDate, scheduleByDate, minTimeMaxTime, scheduleTimeSlots, timesSlotCanUse;
-                return _regeneratorRuntime().wrap(function _loop5$(_context27) {
+                return _regeneratorRuntime().wrap(function _loop7$(_context27) {
                   while (1) switch (_context27.prev = _context27.next) {
                     case 0:
                       currentDateStr = currentDate.format('YYYY-MM-DD');
@@ -3493,14 +3890,14 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                     case "end":
                       return _context27.stop();
                   }
-                }, _loop5);
+                }, _loop7);
               });
             case 28:
               if (!(dayjs(currentDate).isBefore(dayjs(endDate), 'day') || dayjs(currentDate).isSame(dayjs(endDate), 'day'))) {
                 _context28.next = 34;
                 break;
               }
-              return _context28.delegateYield(_loop5(), "t0", 30);
+              return _context28.delegateYield(_loop7(), "t0", 30);
             case 30:
               if (!_context28.t0) {
                 _context28.next = 32;

package/dist/solution/BookingByStep/utils/capacity.d.ts

@@ -15,8 +15,9 @@ export declare const formatDefaultCapacitys: ({ capacity, product_bundle, }: any
  * @return {*}
  * @Author: zhiwei.Wang
  */
-export declare const getSumCapacity: ({ capacity }: {
+export declare const getSumCapacity: ({ capacity, num }: {
     capacity: CapacityItem[];
+    num: number;
 }) => number;
 /**
  * 给定购物车数据，返回对应的 capacity 信息和套餐 capacity

package/dist/solution/BookingByStep/utils/capacity.js

@@ -60,7 +60,9 @@ export var formatDefaultCapacitys = function formatDefaultCapacitys(_ref) {
  * @Author: zhiwei.Wang
  */
 export var getSumCapacity = function getSumCapacity(_ref2) {
-  var capacity = _ref2.capacity;
+  var capacity = _ref2.capacity,
+    _ref2$num = _ref2.num,
+    num = _ref2$num === void 0 ? 1 : _ref2$num;
   var sum = 0;
   var _iterator = _createForOfIteratorHelper(capacity || []),
     _step;
@@ -74,7 +76,7 @@ export var getSumCapacity = function getSumCapacity(_ref2) {
   } finally {
     _iterator.f();
   }
-  return sum;
+  return sum * num;
 };
 
 /**
@@ -85,13 +87,14 @@ export var getSumCapacity = function getSumCapacity(_ref2) {
  * @return {*} 
  */
 export function getCapacityInfoByCartItem(targetCartItem) {
-  var _targetCartItem$_prod;
+  var _targetCartItem$_prod, _targetCartItem$_orig;
   var formatCapacity = formatDefaultCapacitys({
     capacity: (_targetCartItem$_prod = targetCartItem._productOrigin) === null || _targetCartItem$_prod === void 0 ? void 0 : _targetCartItem$_prod.capacity,
     product_bundle: targetCartItem._origin.product.product_bundle
   });
   var currentCapacity = getSumCapacity({
-    capacity: formatCapacity
+    capacity: formatCapacity,
+    num: (targetCartItem === null || targetCartItem === void 0 || (_targetCartItem$_orig = targetCartItem._origin) === null || _targetCartItem$_orig === void 0 || (_targetCartItem$_orig = _targetCartItem$_orig.product) === null || _targetCartItem$_orig === void 0 ? void 0 : _targetCartItem$_orig.quantity) || 1
   });
   return {
     formatCapacity: formatCapacity,

package/dist/solution/Checkout/index.d.ts

@@ -19,6 +19,7 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private store;
     private otherParams;
     private logger;
+    private calculationCache;
     order: OrderModule;
     payment: PaymentModule;
     constructor(name?: string, version?: string);
@@ -302,16 +303,46 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 删除本地 IndexDB 中超过指定天数且已同步到后端的订单数据
      */
     private cleanupExpiredOrdersAsync;
+    /**
+     * 清除计算缓存
+     */
+    private clearCalculationCache;
+    /**
+     * 批量获取订单数据（用于性能优化）
+     * 一次性获取所有需要的数据，避免重复查询
+     */
+    private fetchOrderDataBatch;
+    /**
+     * 从支付项数组计算已支付金额（纯计算，不查询数据库）
+     */
+    private calculatePaidAmountFromItems;
     /**
      * 计算已支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculatePaidAmountAsync;
+    /**
+     * 从订单和支付项计算剩余金额（纯计算，不查询数据库）
+     */
+    private calculateRemainingAmountFromData;
+    /**
+     * 从订单和支付项计算剩余总金额（纯计算，排除定金）
+     */
+    private calculateRemainingTotalAmountFromData;
     /**
      * 计算剩余未支付金额（从 Payment 模块获取最新数据）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingAmountAsync;
     /**
      * 计算剩余未支付金额（排除定金计算，始终使用订单总金额）
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 等批量操作中会使用缓存优化。
      */
     private calculateRemainingTotalAmountAsync;
     /**
@@ -320,12 +351,24 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
     private updateBalanceDueAmount;
     /**
      * 更新 stateAmount 为当前剩余未支付金额
+     *
+     * 优化版本：批量获取数据，避免重复查询数据库
      */
     private updateStateAmountToRemaining;
+    /**
+     * 检查订单支付是否完成（优化版，复用已获取的数据）
+     *
+     * @param paymentItems 已获取的支付项数据
+     * @param remainingAmount 已计算的剩余金额
+     */
+    private checkOrderPaymentCompletionOptimized;
     /**
      * 检查订单支付是否完成
      *
      * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
+     *
+     * 注意：此方法保持独立性，可以单独调用。
+     * 在 updateStateAmountToRemaining 中会使用优化版本。
      */
     private checkOrderPaymentCompletion;
     /**
@@ -381,6 +424,8 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 重置 store 状态
      *
      * 在创建新订单前调用，确保状态完全干净
+     *
+     * 🚀 性能优化：改为同步方法，事件发射不阻塞主流程
      */
-    private resetStoreStateAsync;
+    private resetStoreState;
 }