@pisell/pisellos 1.0.65 → 1.0.67

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

@@ -45,3 +45,26 @@ export declare const checkSubResourcesCapacity: (resource: ResourceItem) => void
  * @returns 如果资源可以容纳额外的容量则返回 true
  */
 export declare const checkResourceCanUseByCapacity: (currentCapacity: number, requiredCapacity: number, maxCapacity: number) => boolean;
+/**
+ * 计算按资源类型分组的容量占用情况
+ *
+ * @param {CartItem[]} cartItems 购物车商品列表
+ * @param {string} timeSlotStart 时间段开始时间
+ * @param {string} timeSlotEnd 时间段结束时间
+ * @param {ResourceItem[]} allProductResources 当前商品的所有资源列表
+ * @return {Record<string, number>} 返回每种资源类型(form_id)的容量占用
+ */
+export declare function calculateCartItemsCapacityUsageByResourceType({ cartItems, timeSlotStart, timeSlotEnd, allProductResources }: {
+    cartItems: CartItem[];
+    timeSlotStart: string;
+    timeSlotEnd: string;
+    allProductResources: ResourceItem[];
+}): Record<string, number>;
+/**
+ * 获取商品的资源ID列表
+ */
+export declare function getResourcesIdsByProduct(product: any): number[];
+/**
+ * 检查特定时间段的容量是否足够
+ */
+export declare function checkTimeSlotCapacity(timeSlotStart: string, timeSlotEnd: string, cartItems: CartItem[], allResources: ResourceItem[]): boolean;

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

@@ -1,6 +1,16 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
 function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import dayjs from 'dayjs';
+
 /**
  * @title: 基于选择的商品格式化容量
  * @description:
@@ -129,4 +139,212 @@ export var checkResourceCanUseByCapacity = function checkResourceCanUseByCapacit
     return false;
   }
   return currentCapacity + requiredCapacity <= maxCapacity;
-};
+};
+
+/**
+ * 计算按资源类型分组的容量占用情况
+ * 
+ * @param {CartItem[]} cartItems 购物车商品列表
+ * @param {string} timeSlotStart 时间段开始时间
+ * @param {string} timeSlotEnd 时间段结束时间
+ * @param {ResourceItem[]} allProductResources 当前商品的所有资源列表
+ * @return {Record<string, number>} 返回每种资源类型(form_id)的容量占用
+ */
+export function calculateCartItemsCapacityUsageByResourceType(_ref3) {
+  var cartItems = _ref3.cartItems,
+    timeSlotStart = _ref3.timeSlotStart,
+    timeSlotEnd = _ref3.timeSlotEnd,
+    allProductResources = _ref3.allProductResources;
+  // 按 form_id 分组当前商品的资源
+  var resourceTypeMap = {};
+  allProductResources.forEach(function (resource) {
+    var _resource$form_id;
+    var formId = ((_resource$form_id = resource.form_id) === null || _resource$form_id === void 0 ? void 0 : _resource$form_id.toString()) || 'default';
+    if (!resourceTypeMap[formId]) {
+      resourceTypeMap[formId] = [];
+    }
+    resourceTypeMap[formId].push(resource);
+  });
+
+  // 计算每种资源类型的容量占用
+  var capacityUsageByType = {};
+  Object.keys(resourceTypeMap).forEach(function (formId) {
+    var totalUsage = 0;
+    var resourcesInThisType = resourceTypeMap[formId];
+    var resourceIdsInThisType = resourcesInThisType.map(function (r) {
+      return r.id;
+    });
+    cartItems.forEach(function (cartItem) {
+      // 检查该商品是否已经选定了时间
+      if (!cartItem.start_time || !cartItem.end_time) return;
+
+      // 构建该商品的时间段
+      var itemStart = "".concat(cartItem.start_date, " ").concat(cartItem.start_time);
+      var itemEnd = "".concat(cartItem.end_date || cartItem.start_date, " ").concat(cartItem.end_time);
+
+      // 检查时间段是否有重叠
+      var hasTimeOverlap = !(dayjs(itemEnd).isBefore(dayjs(timeSlotStart)) || dayjs(itemStart).isAfter(dayjs(timeSlotEnd)));
+      if (!hasTimeOverlap) return;
+
+      // 检查该商品的资源配置中是否需要这种类型的资源
+      // 由于购物车商品只选定了时间，没有选定具体资源，我们需要看商品的资源配置
+      var productResourceIds = getResourcesIdsByProduct(cartItem._productOrigin);
+      var hasResourceTypeOverlap = productResourceIds.some(function (id) {
+        return resourceIdsInThisType.includes(id);
+      });
+      if (!hasResourceTypeOverlap) return;
+
+      // 计算该商品的容量占用
+      var _getCapacityInfoByCar = getCapacityInfoByCartItem(cartItem),
+        currentCapacity = _getCapacityInfoByCar.currentCapacity;
+      totalUsage += currentCapacity;
+    });
+    capacityUsageByType[formId] = totalUsage;
+  });
+  return capacityUsageByType;
+}
+
+/**
+ * 获取商品的资源ID列表
+ */
+export function getResourcesIdsByProduct(product) {
+  var _product$product_reso, _product$product_reso2;
+  var tempResourceIds = [];
+  product === null || product === void 0 || (_product$product_reso = product.product_resource) === null || _product$product_reso === void 0 || (_product$product_reso = _product$product_reso.resources) === null || _product$product_reso === void 0 || (_product$product_reso2 = _product$product_reso.forEach) === null || _product$product_reso2 === void 0 || _product$product_reso2.call(_product$product_reso, function (resource) {
+    if ((resource === null || resource === void 0 ? void 0 : resource.status) == 1) {
+      var _resource$default_res, _resource$optional_re;
+      if (resource !== null && resource !== void 0 && (_resource$default_res = resource.default_resource) !== null && _resource$default_res !== void 0 && _resource$default_res.length) {
+        tempResourceIds.push.apply(tempResourceIds, _toConsumableArray(resource === null || resource === void 0 ? void 0 : resource.default_resource));
+      } else if (resource !== null && resource !== void 0 && (_resource$optional_re = resource.optional_resource) !== null && _resource$optional_re !== void 0 && _resource$optional_re.length) {
+        tempResourceIds.push.apply(tempResourceIds, _toConsumableArray(resource === null || resource === void 0 ? void 0 : resource.optional_resource));
+      }
+    }
+  });
+  return tempResourceIds;
+}
+
+/**
+ * 检查特定时间段的容量是否足够
+ */
+export function checkTimeSlotCapacity(timeSlotStart, timeSlotEnd, cartItems, allResources) {
+  // 按资源类型分组
+  var resourceTypeMap = {};
+  allResources.forEach(function (resource) {
+    var _resource$form_id2;
+    var formId = ((_resource$form_id2 = resource.form_id) === null || _resource$form_id2 === void 0 ? void 0 : _resource$form_id2.toString()) || 'default';
+    if (!resourceTypeMap[formId]) {
+      resourceTypeMap[formId] = [];
+    }
+    resourceTypeMap[formId].push(resource);
+  });
+
+  // 计算每种资源类型需要的总容量
+  var requiredCapacityByType = {};
+  cartItems.forEach(function (cartItem) {
+    var productResourceIds = getResourcesIdsByProduct(cartItem._productOrigin);
+    var _getCapacityInfoByCar2 = getCapacityInfoByCartItem(cartItem),
+      currentCapacity = _getCapacityInfoByCar2.currentCapacity;
+    Object.keys(resourceTypeMap).forEach(function (formId) {
+      var resourcesInType = resourceTypeMap[formId];
+      var resourceIdsInType = resourcesInType.map(function (r) {
+        return r.id;
+      });
+
+      // 检查该商品是否需要这种类型的资源
+      var needsThisResourceType = productResourceIds.some(function (id) {
+        return resourceIdsInType.includes(id);
+      });
+      if (needsThisResourceType) {
+        requiredCapacityByType[formId] = (requiredCapacityByType[formId] || 0) + currentCapacity;
+      }
+    });
+  });
+
+  // 检查每种资源类型是否有足够的容量
+  var _loop = function _loop() {
+      var _resourceTypeConfig, _resourceTypeConfig2;
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        formId = _Object$entries$_i[0],
+        requiredCapacity = _Object$entries$_i[1];
+      var resourcesInType = resourceTypeMap[formId];
+      if (resourcesInType.length === 0) return 0; // continue
+
+      // 从购物车商品中获取正确的资源类型配置
+      var resourceTypeConfig = null;
+      var _iterator2 = _createForOfIteratorHelper(cartItems),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _cartItem$_productOri;
+          var cartItem = _step2.value;
+          if ((_cartItem$_productOri = cartItem._productOrigin) !== null && _cartItem$_productOri !== void 0 && (_cartItem$_productOri = _cartItem$_productOri.product_resource) !== null && _cartItem$_productOri !== void 0 && _cartItem$_productOri.resources) {
+            resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(function (r) {
+              var _r$id;
+              return ((_r$id = r.id) === null || _r$id === void 0 ? void 0 : _r$id.toString()) === formId && r.status === 1;
+            });
+            if (resourceTypeConfig) break;
+          }
+        }
+
+        // 确定这种资源类型的预约类型
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var isMultipleBooking = ((_resourceTypeConfig = resourceTypeConfig) === null || _resourceTypeConfig === void 0 ? void 0 : _resourceTypeConfig.type) === 'multiple';
+      console.log("capacity.ts - \u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u914D\u7F6E:"), {
+        resourceTypeConfig: resourceTypeConfig,
+        type: (_resourceTypeConfig2 = resourceTypeConfig) === null || _resourceTypeConfig2 === void 0 ? void 0 : _resourceTypeConfig2.type,
+        isMultipleBooking: isMultipleBooking,
+        requiredCapacity: requiredCapacity
+      });
+      if (isMultipleBooking) {
+        // 多个预约：计算总可用容量
+        var totalAvailableCapacity = 0;
+        resourcesInType.forEach(function (resource) {
+          // 过滤出在时间段内的资源时间片
+          var availableTimes = resource.times.filter(function (time) {
+            return !dayjs(time.start_at).isAfter(dayjs(timeSlotStart), 'minute') && !dayjs(time.end_at).isBefore(dayjs(timeSlotEnd), 'minute') || dayjs(time.start_at).isBefore(dayjs(timeSlotEnd), 'minute') && dayjs(time.end_at).isAfter(dayjs(timeSlotStart), 'minute');
+          });
+          if (availableTimes.length > 0) {
+            // 简化逻辑：如果资源在时间段内有可用时间，就计算其容量
+            totalAvailableCapacity += resource.capacity || 0;
+          }
+        });
+        console.log("capacity.ts - \u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u591A\u4E2A\u9884\u7EA6\u68C0\u67E5: \u603B\u5BB9\u91CF ").concat(totalAvailableCapacity, ", \u9700\u6C42 ").concat(requiredCapacity));
+        if (totalAvailableCapacity < requiredCapacity) {
+          console.log("\u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u5BB9\u91CF\u4E0D\u8DB3: \u9700\u8981 ").concat(requiredCapacity, ", \u53EF\u7528 ").concat(totalAvailableCapacity));
+          return {
+            v: false
+          };
+        }
+      } else {
+        // 单个预约：计算可用资源数量
+        var availableResourceCount = 0;
+        resourcesInType.forEach(function (resource) {
+          // 过滤出在时间段内的资源时间片
+          var availableTimes = resource.times.filter(function (time) {
+            return !dayjs(time.start_at).isAfter(dayjs(timeSlotStart), 'minute') && !dayjs(time.end_at).isBefore(dayjs(timeSlotEnd), 'minute') || dayjs(time.start_at).isBefore(dayjs(timeSlotEnd), 'minute') && dayjs(time.end_at).isAfter(dayjs(timeSlotStart), 'minute');
+          });
+          if (availableTimes.length > 0) {
+            availableResourceCount++;
+          }
+        });
+        console.log("capacity.ts - \u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u5355\u4E2A\u9884\u7EA6\u68C0\u67E5: \u53EF\u7528\u8D44\u6E90\u6570 ").concat(availableResourceCount, ", \u9700\u6C42 ").concat(requiredCapacity));
+        if (availableResourceCount < requiredCapacity) {
+          console.log("\u8D44\u6E90\u7C7B\u578B ".concat(formId, " \u6570\u91CF\u4E0D\u8DB3: \u9700\u8981 ").concat(requiredCapacity, ", \u53EF\u7528 ").concat(availableResourceCount));
+          return {
+            v: false
+          };
+        }
+      }
+    },
+    _ret;
+  for (var _i = 0, _Object$entries = Object.entries(requiredCapacityByType); _i < _Object$entries.length; _i++) {
+    _ret = _loop();
+    if (_ret === 0) continue;
+    if (_ret) return _ret.v;
+  }
+  return true;
+}

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

@@ -0,0 +1,29 @@
+import { CartItem } from '../../../modules';
+/**
+ * 检测商品库存是否足够
+ *
+ * 只有同时满足以下条件时才会进行库存检测：
+ * - is_track 开启（值为 1 或 true）
+ * - over_sold 为 0（不允许超卖）
+ *
+ * 对于多规格商品：
+ * - 如果有 product_variant_id，则从 productData.variant 数组中查找对应规格
+ * - 使用规格的 is_track, over_sold, stock_quantity 而不是主商品的
+ *
+ * @param productData 商品数据（需包含 is_track, over_sold, stock_quantity 字段，多规格商品需包含 variant 数组）
+ * @param product_variant_id 商品变体ID，如果存在则为多规格商品
+ * @param quantity 需要添加的数量
+ * @param bundle 套餐配置（子商品需包含 is_track, over_sold, stock_quantity 字段）
+ * @param currentCartItems 当前购物车商品列表
+ * @returns 库存检测结果
+ */
+export declare function checkProductStock({ productData, product_variant_id, quantity, bundle, currentCartItems }: {
+    productData: any;
+    product_variant_id?: any;
+    quantity: number;
+    bundle?: any[];
+    currentCartItems: CartItem[];
+}): {
+    success: boolean;
+    errorCode?: string;
+};

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

@@ -0,0 +1,126 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ * 检测商品库存是否足够
+ * 
+ * 只有同时满足以下条件时才会进行库存检测：
+ * - is_track 开启（值为 1 或 true）
+ * - over_sold 为 0（不允许超卖）
+ * 
+ * 对于多规格商品：
+ * - 如果有 product_variant_id，则从 productData.variant 数组中查找对应规格
+ * - 使用规格的 is_track, over_sold, stock_quantity 而不是主商品的
+ * 
+ * @param productData 商品数据（需包含 is_track, over_sold, stock_quantity 字段，多规格商品需包含 variant 数组）
+ * @param product_variant_id 商品变体ID，如果存在则为多规格商品
+ * @param quantity 需要添加的数量
+ * @param bundle 套餐配置（子商品需包含 is_track, over_sold, stock_quantity 字段）
+ * @param currentCartItems 当前购物车商品列表
+ * @returns 库存检测结果
+ */
+export function checkProductStock(_ref) {
+  var productData = _ref.productData,
+    product_variant_id = _ref.product_variant_id,
+    quantity = _ref.quantity,
+    bundle = _ref.bundle,
+    currentCartItems = _ref.currentCartItems;
+  // 1. 检测主商品库存
+  // 处理多规格商品：如果有product_variant_id，则从variant数组中查找对应的规格配置
+  var mainProductConfig = productData;
+  if (product_variant_id && productData.variant && Array.isArray(productData.variant)) {
+    var variant = productData.variant.find(function (v) {
+      return v.id === product_variant_id;
+    });
+    if (variant) {
+      mainProductConfig = variant; // 使用规格的配置替换主商品配置
+    }
+  }
+
+  // 只有开启库存控制且不允许超卖时才需要检测主商品库存
+  var isMainProductTrackingEnabled = mainProductConfig.is_track === 1 || mainProductConfig.is_track === true;
+  var isMainProductOverSoldDisabled = mainProductConfig.over_sold === 0;
+  if (isMainProductTrackingEnabled && isMainProductOverSoldDisabled) {
+    var existingQuantity = currentCartItems.reduce(function (total, cartItem) {
+      var _cartItem$_productOri, _cartItem$_productOri2, _cartItem$_productOri3;
+      // 检查是否为相同商品（比较商品ID和变体ID）
+      var isSameProduct = ((_cartItem$_productOri = cartItem._productOrigin) === null || _cartItem$_productOri === void 0 ? void 0 : _cartItem$_productOri.id) === productData.id;
+      var isSameVariant = !product_variant_id && !((_cartItem$_productOri2 = cartItem._productOrigin) !== null && _cartItem$_productOri2 !== void 0 && _cartItem$_productOri2.product_variant_id) || ((_cartItem$_productOri3 = cartItem._productOrigin) === null || _cartItem$_productOri3 === void 0 ? void 0 : _cartItem$_productOri3.product_variant_id) === product_variant_id;
+      if (isSameProduct && isSameVariant) {
+        return total + (cartItem.num || 0);
+      }
+      return total;
+    }, 0);
+    var totalQuantity = existingQuantity + quantity;
+    var stockQuantity = mainProductConfig.stock_quantity;
+
+    // 检查主商品库存是否足够
+    if (stockQuantity !== undefined && stockQuantity !== null && totalQuantity > stockQuantity) {
+      return {
+        success: false,
+        errorCode: 'not_enough_stock'
+      };
+    }
+  }
+
+  // 2. 检测套餐商品库存
+  if (bundle && Array.isArray(bundle)) {
+    // 直接遍历套餐商品数组
+    var _iterator = _createForOfIteratorHelper(bundle),
+      _step;
+    try {
+      var _loop = function _loop() {
+          var bundleItem = _step.value;
+          var bundleProductId = bundleItem.bundle_product_id;
+          var bundleStockQuantity = bundleItem.stock_quantity;
+          var bundleRequiredQuantity = (bundleItem.num || 1) * quantity; // 子商品需求数量 = 子商品配置数量 * 主商品购买数量
+
+          // 检查套餐子商品是否需要进行库存控制
+          var isBundleTrackingEnabled = bundleItem.is_track === 1 || bundleItem.is_track === true;
+          var isBundleOverSoldDisabled = bundleItem.over_sold === 0;
+
+          // 跳过没有开启库存控制或允许超卖的子商品
+          if (!isBundleTrackingEnabled || !isBundleOverSoldDisabled) return 0; // continue
+
+          // 跳过没有库存配置的子商品
+          if (bundleStockQuantity === undefined || bundleStockQuantity === null) return 0; // continue
+
+          // 计算购物车中已有的相同子商品数量
+          var existingBundleQuantity = currentCartItems.reduce(function (total, cartItem) {
+            // 检查购物车中商品的套餐配置
+            if (!cartItem._bundleOrigin || !Array.isArray(cartItem._bundleOrigin)) return total;
+            cartItem._bundleOrigin.forEach(function (cartBundleItem) {
+              if (cartBundleItem.bundle_product_id === bundleProductId) {
+                total += (cartBundleItem.num || 1) * (cartItem.num || 1);
+              }
+            });
+            return total;
+          }, 0);
+          var totalBundleQuantity = existingBundleQuantity + bundleRequiredQuantity;
+
+          // 检查子商品库存是否足够
+          if (totalBundleQuantity > bundleStockQuantity) {
+            return {
+              v: {
+                success: false,
+                errorCode: 'not_enough_stock'
+              }
+            };
+          }
+        },
+        _ret;
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        _ret = _loop();
+        if (_ret === 0) continue;
+        if (_ret) return _ret.v;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return {
+    success: true
+  };
+}

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

@@ -111,7 +111,7 @@ export declare class BookingTicketImpl extends BaseModule implements Module {
      * 获取当前的客户搜索条件
      * @returns 当前搜索条件
      */
-    getCurrentCustomerSearchParams(): Omit<import("../../modules").ShopGetCustomerListParams, "num" | "skip">;
+    getCurrentCustomerSearchParams(): Omit<import("../../modules").ShopGetCustomerListParams, "skip" | "num">;
     /**
      * 获取客户列表状态（包含滚动加载相关状态）
      * @returns 客户状态

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

@@ -2,7 +2,7 @@ import { Module, PisellCore, ModuleOptions } from '../../types';
 import { BaseModule } from '../../modules/BaseModule';
 import { OrderModule } from '../../modules/Order';
 import { PaymentModule } from '../../modules/Payment';
-import { CheckoutModuleAPI, CheckoutStep, CheckoutInitParams, CreateLocalOrderParams, PlaceOrderParams, CreateOrderParams, ProcessPaymentParams, CheckoutStatusInfo, CheckoutSummary, CurrentOrderInfo, CartSummaryItem, ExtractedAmountInfo, SendCustomerPayLinkParams } from './types';
+import { CheckoutModuleAPI, CheckoutInitParams, CreateLocalOrderParams, CurrentOrderInfo, CartSummaryItem, SendCustomerPayLinkParams } from './types';
 import { PaymentOrder, PaymentMethod, PaymentItem, PaymentItemInput } from '../../modules/Payment/types';
 export * from './types';
 /**
@@ -64,24 +64,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 方法会记录参数并创建本地虚拟订单，然后用 Payment 模块管理支付流程。
      */
     createLocalOrderAsync(params: CreateLocalOrderParams): Promise<PaymentOrder>;
-    /**
-     * 手动下单 (根据虚拟订单生成实际订单)
-     *
-     * 使用当前存储的本地订单数据调用 Order 模块创建真实订单
-     */
-    placeOrderAsync(params?: PlaceOrderParams): Promise<{
-        success: boolean;
-        orderId?: string;
-        error?: string;
-    }>;
-    /**
-     * 创建订单
-     */
-    createOrderAsync(params: CreateOrderParams): Promise<PaymentOrder>;
-    /**
-     * 处理支付
-     */
-    processPaymentAsync(params: ProcessPaymentParams): Promise<void>;
     /**
      * 完成结账
      */
@@ -89,28 +71,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
         success: boolean;
         orderId?: string;
     }>;
-    /**
-     * 取消结账
-     */
-    cancelCheckoutAsync(): Promise<void>;
-    /**
-     * 获取结账状态
-     */
-    getCheckoutStatus(): CheckoutStatusInfo;
-    /**
-     * 获取结账摘要
-     */
-    getCheckoutSummaryAsync(): Promise<CheckoutSummary>;
-    /**
-     * 获取可用支付方式
-     */
-    getAvailablePaymentMethodsAsync(): Promise<PaymentMethod[]>;
-    /**
-     * 刷新支付方式缓存
-     *
-     * 强制重新从服务器获取支付方式列表，更新本地缓存
-     */
-    refreshPaymentMethodsAsync(): Promise<PaymentMethod[]>;
     /**
      * 获取订单原始数据
      */
@@ -127,21 +87,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 返回当前订单的所有支付项，包括活跃和已撤销的支付项
      */
     getCurrentOrderPaymentItemsAsync(): Promise<PaymentItem[]>;
-    /**
-     * 验证结账前置条件
-     */
-    validateCheckoutAsync(): Promise<{
-        valid: boolean;
-        errors: string[];
-    }>;
-    /**
-     * 重试失败的操作
-     */
-    retryFailedOperationAsync(): Promise<void>;
-    /**
-     * 设置当前步骤
-     */
-    setCurrentStep(step: CheckoutStep): void;
     /**
      * 获取订单模块
      */
@@ -181,12 +126,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * @returns 当前系统计算的待付金额
      */
     getBalanceDueAmount(): string;
-    /**
-     * 刷新 stateAmount 为当前剩余未支付金额
-     *
-     * UI 可以调用此方法来主动刷新支付金额状态
-     */
-    refreshStateAmountAsync(): Promise<void>;
     /**
      * 获取购物车小计数据
      *
@@ -195,14 +134,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * @returns 购物车小计数据数组，如果没有则返回 null
      */
     getCartSummary(): CartSummaryItem[] | null;
-    /**
-     * 获取提取的金额详细信息
-     *
-     * 从当前的购物车小计数据中提取结构化的金额信息
-     *
-     * @returns 提取的金额信息对象，如果没有小计数据则返回 null
-     */
-    getExtractedAmountInfo(): ExtractedAmountInfo | null;
     /**
      * 获取支付方式列表
      *
@@ -252,33 +183,15 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      */
     updateOrderDepositStatusAsync(isDeposit: number): Promise<void>;
     /**
-     * 更新当前订单的客户信息
+     * 手动设置当前订单的定金金额
      *
-     * 更新当前订单关联的客户信息，用于标识订单的所属客户
+     * 允许手动设置订单的定金金额，通常用于用户自定义定金支付场景
      *
-     * @param customer 客户信息 (customer_id 和/或 customer_name)
+     * @param depositAmount 定金金额，必须是有效的数字字符串，且不能超过订单总额
      * @throws 当前没有活跃订单时抛出错误
+     * @throws 定金金额格式无效或超过订单总额时抛出错误
      */
-    updateOrderCustomerAsync(customer: {
-        customer_id?: string;
-        customer_name?: string;
-    }): Promise<void>;
-    /**
-     * 获取当前订单的客户信息
-     *
-     * @returns 当前客户信息，如果没有则返回 null
-     */
-    getCurrentCustomer(): {
-        customer_id?: string;
-        customer_name?: string;
-    } | null;
-    /**
-     * 检查订单是否需要手动同步（异步版本）
-     *
-     * 返回订单是否为纯代金券支付且待付金额<=0但未同步的状态
-     * 从 Payment 模块获取最新的支付项数据
-     */
-    needsManualSyncAsync(): Promise<boolean>;
+    setDepositAmountAsync(depositAmount: string): Promise<void>;
     /**
      * 手动同步订单到后端
      *
@@ -335,34 +248,12 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
         orderUuid?: string;
         response?: any;
     }>;
-    /**
-     * 获取当前商店折扣金额
-     *
-     * @returns 当前的商店折扣金额，如果没有则返回0
-     */
-    getShopDiscount(): number;
-    /**
-     * 更新订单商店折扣
-     *
-     * 同时更新cartSummary和localOrderData中的shop_discount值
-     *
-     * @param discountAmount 商店折扣金额
-     */
-    updateShopDiscountAsync(discountAmount: number): Promise<void>;
     /**
      * 更新订单备注
      *
      * @param note 订单备注内容
      */
     updateOrderNoteAsync(note: string): Promise<void>;
-    /**
-     * 设置状态
-     */
-    private setStatus;
-    /**
-     * 设置步骤
-     */
-    private setStep;
     /**
      * 处理错误
      */
@@ -386,14 +277,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * @returns 处理后的支付项（包含找零信息）
      */
     private processCashPaymentItem;
-    /**
-     * 判断是否为现金支付
-     *
-     * @param paymentCode 支付代码
-     * @param paymentType 支付类型
-     * @returns 是否为现金支付
-     */
-    private isCashPayment;
     /**
      * 预加载支付方式（在初始化时调用）
      */
@@ -426,11 +309,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 当剩余待付款金额 <= 0 时，触发订单支付完成事件
      */
     private checkOrderPaymentCompletion;
-    /**
-     * 同步订单到后端
-     *
-     * 调用后端 /order/checkout 接口创建真实订单
-     */
     /**
      * 同步订单到后端并返回真实订单ID
      *
@@ -439,11 +317,6 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * @returns 包含订单ID、UUID和完整后端响应的对象
      */
     private syncOrderToBackendWithReturn;
-    private syncOrderToBackend;
-    /**
-     * 获取状态消息
-     */
-    private getStatusMessage;
     setOtherParams(params: Record<string, any>, { cover }?: {
         cover?: boolean;
     }): Promise<void>;
@@ -491,19 +364,4 @@ export declare class CheckoutImpl extends BaseModule implements Module, Checkout
      * 在创建新订单前调用，确保状态完全干净
      */
     private resetStoreStateAsync;
-    /**
-     * 手动清理已完成的订单状态（公开方法）
-     *
-     * 供UI层调用的公开方法，用于手动清理订单状态
-     *
-     * @returns 清理结果
-     */
-    clearCompletedOrderAsync(): Promise<{
-        success: boolean;
-        message?: string;
-        clearedOrder?: {
-            uuid: string;
-            orderId: string;
-        } | null;
-    }>;
 }