@pisell/pisellos 0.10.14 → 0.10.16

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

@@ -1,27 +1,27 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+"use strict";
 
-// src/solution/BookingByStep/utils/stock.ts
-var stock_exports = {};
-__export(stock_exports, {
-  checkProductStock: () => checkProductStock
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(stock_exports);
+exports.checkProductStock = checkProductStock;
+/**
+ * 检测商品库存是否足够
+ * 
+ * 只有同时满足以下条件时才会进行库存检测：
+ * - 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 库存检测结果
+ */
 function checkProductStock({
   productData,
   product_variant_id,
@@ -29,20 +29,24 @@ function checkProductStock({
   bundle,
   currentCartItems
 }) {
+  // 1. 检测主商品库存
+  // 处理多规格商品：如果有product_variant_id，则从variant数组中查找对应的规格配置
   let mainProductConfig = productData;
   if (product_variant_id && productData.variant && Array.isArray(productData.variant)) {
-    const variant = productData.variant.find((v) => v.id === product_variant_id);
+    const variant = productData.variant.find(v => v.id === product_variant_id);
     if (variant) {
-      mainProductConfig = variant;
+      mainProductConfig = variant; // 使用规格的配置替换主商品配置
     }
   }
+
+  // 只有开启库存控制且不允许超卖时才需要检测主商品库存
   const isMainProductTrackingEnabled = mainProductConfig.is_track === 1 || mainProductConfig.is_track === true;
   const isMainProductOverSoldDisabled = mainProductConfig.over_sold === 0;
   if (isMainProductTrackingEnabled && isMainProductOverSoldDisabled) {
     const existingQuantity = currentCartItems.reduce((total, cartItem) => {
-      var _a, _b, _c;
-      const isSameProduct = ((_a = cartItem._productOrigin) == null ? void 0 : _a.id) === productData.id;
-      const isSameVariant = !product_variant_id && !((_b = cartItem._productOrigin) == null ? void 0 : _b.product_variant_id) || ((_c = cartItem._productOrigin) == null ? void 0 : _c.product_variant_id) === product_variant_id;
+      // 检查是否为相同商品（比较商品ID和变体ID）
+      const isSameProduct = cartItem._productOrigin?.id === productData.id;
+      const isSameVariant = !product_variant_id && !cartItem._productOrigin?.product_variant_id || cartItem._productOrigin?.product_variant_id === product_variant_id;
       if (isSameProduct && isSameVariant) {
         return total + (cartItem.num || 0);
       }
@@ -50,25 +54,39 @@ function checkProductStock({
     }, 0);
     const totalQuantity = existingQuantity + quantity;
     const stockQuantity = mainProductConfig.stock_quantity;
-    if (stockQuantity !== void 0 && stockQuantity !== null && totalQuantity > stockQuantity) {
-      return { success: false, errorCode: "not_enough_stock" };
+
+    // 检查主商品库存是否足够
+    if (stockQuantity !== undefined && stockQuantity !== null && totalQuantity > stockQuantity) {
+      return {
+        success: false,
+        errorCode: 'not_enough_stock'
+      };
     }
   }
+
+  // 2. 检测套餐商品库存
   if (bundle && Array.isArray(bundle)) {
+    // 直接遍历套餐商品数组
     for (const bundleItem of bundle) {
       const bundleProductId = bundleItem.bundle_product_id;
       const bundleStockQuantity = bundleItem.stock_quantity;
-      const bundleRequiredQuantity = (bundleItem.num || 1) * quantity;
+      const bundleRequiredQuantity = (bundleItem.num || 1) * quantity; // 子商品需求数量 = 子商品配置数量 * 主商品购买数量
+
+      // 检查套餐子商品是否需要进行库存控制
       const isBundleTrackingEnabled = bundleItem.is_track === 1 || bundleItem.is_track === true;
       const isBundleOverSoldDisabled = bundleItem.over_sold === 0;
-      if (!isBundleTrackingEnabled || !isBundleOverSoldDisabled)
-        continue;
-      if (bundleStockQuantity === void 0 || bundleStockQuantity === null)
-        continue;
+
+      // 跳过没有开启库存控制或允许超卖的子商品
+      if (!isBundleTrackingEnabled || !isBundleOverSoldDisabled) continue;
+
+      // 跳过没有库存配置的子商品
+      if (bundleStockQuantity === undefined || bundleStockQuantity === null) continue;
+
+      // 计算购物车中已有的相同子商品数量
       const existingBundleQuantity = currentCartItems.reduce((total, cartItem) => {
-        if (!cartItem._bundleOrigin || !Array.isArray(cartItem._bundleOrigin))
-          return total;
-        cartItem._bundleOrigin.forEach((cartBundleItem) => {
+        // 检查购物车中商品的套餐配置
+        if (!cartItem._bundleOrigin || !Array.isArray(cartItem._bundleOrigin)) return total;
+        cartItem._bundleOrigin.forEach(cartBundleItem => {
           if (cartBundleItem.bundle_product_id === bundleProductId) {
             total += (cartBundleItem.num || 1) * (cartItem.num || 1);
           }
@@ -76,14 +94,17 @@ function checkProductStock({
         return total;
       }, 0);
       const totalBundleQuantity = existingBundleQuantity + bundleRequiredQuantity;
+
+      // 检查子商品库存是否足够
       if (totalBundleQuantity > bundleStockQuantity) {
-        return { success: false, errorCode: "not_enough_stock" };
+        return {
+          success: false,
+          errorCode: 'not_enough_stock'
+        };
       }
     }
   }
-  return { success: true };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  checkProductStock
-});
+  return {
+    success: true
+  };
+}

package/lib/solution/BookingByStep/utils/timeslots.js

@@ -1,79 +1,85 @@
-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/solution/BookingByStep/utils/timeslots.ts
-var timeslots_exports = {};
-__export(timeslots_exports, {
-  calculateResourceAvailableTime: () => calculateResourceAvailableTime,
-  filterConditionTimeSlots: () => filterConditionTimeSlots,
-  findFastestAvailableResource: () => findFastestAvailableResource
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(timeslots_exports);
-var import_dayjs = __toESM(require("dayjs"));
+exports.calculateResourceAvailableTime = calculateResourceAvailableTime;
+exports.filterConditionTimeSlots = filterConditionTimeSlots;
+exports.findFastestAvailableResource = findFastestAvailableResource;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/**
+ * 计算资源在指定时间段内的总可用时间（以分钟为单位）
+ * @param resource 需要计算可用时间的资源
+ * @param timeSlots 要检查可用性的时间段
+ * @param currentCapacity 当前预约所需的容量
+ * @returns 总可用时间（分钟）
+ */
 function calculateResourceAvailableTime({
   resource,
   timeSlots,
   currentCapacity = 1
 }) {
-  const matchingTimes = resource.times.filter((time) => {
-    return (0, import_dayjs.default)(time.start_at).isSame((0, import_dayjs.default)(timeSlots.start_at), "day");
+  // 过滤出与给定日期相同的资源时间
+  const matchingTimes = resource.times.filter(time => {
+    return (0, _dayjs.default)(time.start_at).isSame((0, _dayjs.default)(timeSlots.start_at), 'day');
   });
-  if (matchingTimes.length === 0)
-    return 0;
+  if (matchingTimes.length === 0) return 0;
+
+  // 计算所有时间段与目标时间槽的重叠部分
   const overlaps = [];
   for (const time of matchingTimes) {
-    const overlapStart = (0, import_dayjs.default)(time.start_at).isAfter((0, import_dayjs.default)(timeSlots.start_at)) ? (0, import_dayjs.default)(time.start_at) : (0, import_dayjs.default)(timeSlots.start_at);
-    const overlapEnd = (0, import_dayjs.default)(time.end_at).isBefore((0, import_dayjs.default)(timeSlots.end_at)) ? (0, import_dayjs.default)(time.end_at) : (0, import_dayjs.default)(timeSlots.end_at);
+    // 计算实际重叠的时间段
+    const overlapStart = (0, _dayjs.default)(time.start_at).isAfter((0, _dayjs.default)(timeSlots.start_at)) ? (0, _dayjs.default)(time.start_at) : (0, _dayjs.default)(timeSlots.start_at);
+    const overlapEnd = (0, _dayjs.default)(time.end_at).isBefore((0, _dayjs.default)(timeSlots.end_at)) ? (0, _dayjs.default)(time.end_at) : (0, _dayjs.default)(timeSlots.end_at);
+
+    // 只有当重叠时间段有效时才添加
     if (overlapStart.isBefore(overlapEnd)) {
-      overlaps.push({ start: overlapStart, end: overlapEnd });
+      overlaps.push({
+        start: overlapStart,
+        end: overlapEnd
+      });
     }
   }
-  if (overlaps.length === 0)
-    return 0;
+
+  // 合并重叠的时间段，计算并集
+  if (overlaps.length === 0) return 0;
+
+  // 按开始时间排序
   overlaps.sort((a, b) => a.start.diff(b.start));
+
+  // 合并重叠的时间段
   const merged = [];
   let current = overlaps[0];
   for (let i = 1; i < overlaps.length; i++) {
     const next = overlaps[i];
+
+    // 如果当前时间段与下一个时间段重叠或相邻，则合并
     if (current.end.isSameOrAfter(next.start)) {
       current.end = current.end.isAfter(next.end) ? current.end : next.end;
     } else {
+      // 不重叠，添加当前时间段到结果中，开始处理下一个
       merged.push(current);
       current = next;
     }
   }
   merged.push(current);
+
+  // 计算所有合并后时间段的总时长
   let totalAvailableMinutes = 0;
   for (const segment of merged) {
-    totalAvailableMinutes += segment.end.diff(segment.start, "minute");
+    totalAvailableMinutes += segment.end.diff(segment.start, 'minute');
   }
   return totalAvailableMinutes;
 }
+
+/**
+ * 查找最快可用的资源，如果有多个资源在相同时间点可用，则选择空闲时间最长的资源
+ * @param resources 资源列表
+ * @param currentCapacity 当前预约所需的容量
+ * @param countMap 已预约数量映射
+ * @returns 最快可用的资源
+ */
 function findFastestAvailableResource({
   resources,
   currentCapacity = 1,
@@ -81,148 +87,140 @@ function findFastestAvailableResource({
   targetDate,
   durationMinutes = 30
 }) {
-  var _a, _b, _c;
-  const currentTime = (0, import_dayjs.default)();
+  const currentTime = (0, _dayjs.default)();
   const resolvedDuration = durationMinutes > 0 ? durationMinutes : 30;
-  const targetDay = targetDate ? (0, import_dayjs.default)(targetDate) : currentTime;
-  const isTargetDayToday = targetDay.isSame(currentTime, "day");
+  const targetDay = targetDate ? (0, _dayjs.default)(targetDate) : currentTime;
+  const isTargetDayToday = targetDay.isSame(currentTime, 'day');
   let fastestTime = null;
   let fastestResources = [];
-  console.log("[TimeslotUtils] 查找最快可用资源:", {
-    currentTime: currentTime.format("YYYY-MM-DD HH:mm:ss"),
-    resourceCount: resources.length,
-    currentCapacity,
-    countMap
-  });
+  // 遍历所有资源，找到最快可用的时间点
   for (const resource of resources) {
-    const targetDayTimes = resource.times.filter((time) => {
-      const isSameTargetDay = (0, import_dayjs.default)(time.start_at).isSame(targetDay, "day");
-      if (!isSameTargetDay)
-        return false;
-      if (!isTargetDayToday)
-        return true;
-      return (0, import_dayjs.default)(time.end_at).isAfter(currentTime);
+    // 获取资源在目标日期且还在工作时间内的时间段
+    const targetDayTimes = resource.times.filter(time => {
+      const isSameTargetDay = (0, _dayjs.default)(time.start_at).isSame(targetDay, 'day');
+      if (!isSameTargetDay) return false;
+      if (!isTargetDayToday) return true;
+      return (0, _dayjs.default)(time.end_at).isAfter(currentTime);
     });
     if (targetDayTimes.length === 0) {
-      console.log(`[TimeslotUtils] 资源 ${resource.id}(${resource.main_field}) 今日无可用时间段`);
       continue;
     }
     for (const time of targetDayTimes) {
-      const workStartTime = (0, import_dayjs.default)(time.start_at);
-      const workEndTime = (0, import_dayjs.default)(time.end_at);
+      const workStartTime = (0, _dayjs.default)(time.start_at);
+      const workEndTime = (0, _dayjs.default)(time.end_at);
+
+      // 确定检查的起始时间（当前时间 vs 工作开始时间）
       let nextAvailableTime = isTargetDayToday && currentTime.isAfter(workStartTime) ? currentTime : workStartTime;
-      console.log(`[TimeslotUtils] 检查资源 ${resource.id}(${resource.main_field}):`, {
-        workTime: `${workStartTime.format("HH:mm")}-${workEndTime.format("HH:mm")}`,
-        checkStartTime: nextAvailableTime.format("HH:mm:ss"),
-        eventCount: ((_a = time.event_list) == null ? void 0 : _a.length) || 0
-      });
-      const relevantEvents = ((_b = time.event_list) == null ? void 0 : _b.filter((event) => {
-        const eventEnd = (0, import_dayjs.default)(event.end_at);
+      // 获取所有影响的预约事件（当前时间之后的）
+      const relevantEvents = time.event_list?.filter(event => {
+        const eventEnd = (0, _dayjs.default)(event.end_at);
         return eventEnd.isAfter(nextAvailableTime);
-      })) || [];
-      relevantEvents.sort(
-        (a, b) => (0, import_dayjs.default)(a.start_at).diff((0, import_dayjs.default)(b.start_at))
-      );
+      }) || [];
+
+      // 按开始时间排序
+      relevantEvents.sort((a, b) => (0, _dayjs.default)(a.start_at).diff((0, _dayjs.default)(b.start_at)));
+
+      // 检查从 nextAvailableTime 开始的可用性
       let finalAvailableTime = nextAvailableTime;
       for (const event of relevantEvents) {
-        const eventStart = (0, import_dayjs.default)(event.start_at);
-        const eventEnd = (0, import_dayjs.default)(event.end_at);
-        console.log(`[TimeslotUtils] 检查事件冲突:`, {
-          resourceId: resource.id,
-          eventTime: `${eventStart.format("HH:mm")}-${eventEnd.format("HH:mm")}`,
-          checkTime: finalAvailableTime.format("HH:mm:ss"),
-          pax: event.pax || 1
-        });
-        if (resource.resourceType === "single" || (resource.capacity || 1) === 1) {
-          if (finalAvailableTime.isBefore(eventEnd) && eventStart.isBefore(finalAvailableTime.add(resolvedDuration, "minute"))) {
+        const eventStart = (0, _dayjs.default)(event.start_at);
+        const eventEnd = (0, _dayjs.default)(event.end_at);
+        // 检查资源类型和容量
+        if (resource.resourceType === 'single' || (resource.capacity || 1) === 1) {
+          // 单人预约资源：检查时间冲突
+          if (finalAvailableTime.isBefore(eventEnd) && eventStart.isBefore(finalAvailableTime.add(resolvedDuration, 'minute'))) {
+            // 有冲突，使用事件结束时间
             finalAvailableTime = eventEnd;
-            console.log(`[TimeslotUtils] 发现时间冲突，调整到: ${finalAvailableTime.format("HH:mm:ss")}`);
           }
         } else {
+          // 多人预约资源：检查容量
           const totalCapacity = resource.capacity || 0;
           const currentUsedCapacity = countMap[resource.id] || 0;
           const eventUsedCapacity = event.pax || 1;
-          if (finalAvailableTime.isBefore(eventEnd) && eventStart.isBefore(finalAvailableTime.add(resolvedDuration, "minute"))) {
+
+          // 如果在事件时间范围内，检查容量是否足够
+          if (finalAvailableTime.isBefore(eventEnd) && eventStart.isBefore(finalAvailableTime.add(resolvedDuration, 'minute'))) {
             const totalRequiredCapacity = currentUsedCapacity + currentCapacity + eventUsedCapacity;
             if (totalRequiredCapacity > totalCapacity) {
+              // 容量不足，使用事件结束时间
               finalAvailableTime = eventEnd;
-              console.log(`[TimeslotUtils] 容量不足，调整到: ${finalAvailableTime.format("HH:mm:ss")}`);
             }
           }
         }
       }
-      if (finalAvailableTime.add(resolvedDuration, "minute").isAfter(workEndTime)) {
-        console.log(`[TimeslotUtils] 资源 ${resource.id} 可用时间超出工作时间，跳过`);
+
+      // 确保可用时间在工作时间内
+      if (finalAvailableTime.add(resolvedDuration, 'minute').isAfter(workEndTime)) {
         continue;
       }
-      console.log(`[TimeslotUtils] 资源 ${resource.id}(${resource.main_field}) 最快可用时间: ${finalAvailableTime.format("HH:mm:ss")}`);
+      // 更新最快可用时间和资源
       if (!fastestTime || finalAvailableTime.isBefore(fastestTime)) {
         fastestTime = finalAvailableTime;
         fastestResources = [resource];
-        console.log(`[TimeslotUtils] 更新最快时间: ${fastestTime.format("HH:mm:ss")}, 资源: ${resource.main_field}`);
       } else if (finalAvailableTime.isSame(fastestTime)) {
         fastestResources.push(resource);
-        console.log(`[TimeslotUtils] 添加相同时间资源: ${resource.main_field}`);
       }
-      break;
+      break; // 每个资源只需要计算一次
     }
   }
+
+  // 如果没有找到可用资源，返回null
   if (!fastestTime || fastestResources.length === 0) {
-    console.log("[TimeslotUtils] 未找到可用资源");
     return null;
   }
-  console.log(`[TimeslotUtils] 找到 ${fastestResources.length} 个最快可用资源，时间: ${fastestTime.format("HH:mm:ss")}`);
+  // 如果只有一个最快可用的资源，直接返回
   if (fastestResources.length === 1) {
-    console.log(`[TimeslotUtils] 返回唯一最快资源: ${fastestResources[0].main_field}`);
     return fastestResources[0];
   }
+
+  // 如果有多个最快可用的资源，选择空闲时间最长的资源
   let selectedResource = fastestResources[0];
   let maxIdleTime = 0;
-  console.log(`[TimeslotUtils] 比较 ${fastestResources.length} 个资源的空闲时间:`);
   for (const resource of fastestResources) {
-    const workingTime = resource.times.find((time) => {
-      const isToday = (0, import_dayjs.default)(time.start_at).isSame(fastestTime, "day");
-      const isStillWorking = (0, import_dayjs.default)(time.end_at).isAfter(fastestTime);
+    // 找到该资源当天且还在工作的时间段
+    const workingTime = resource.times.find(time => {
+      const isToday = (0, _dayjs.default)(time.start_at).isSame(fastestTime, 'day');
+      const isStillWorking = (0, _dayjs.default)(time.end_at).isAfter(fastestTime);
       return isToday && isStillWorking;
     });
-    if (!workingTime)
-      continue;
-    const workEndTime = (0, import_dayjs.default)(workingTime.end_at);
-    let totalIdleTime = workEndTime.diff(fastestTime, "minute");
-    const relevantEvents = ((_c = workingTime.event_list) == null ? void 0 : _c.filter((event) => {
-      const eventStart = (0, import_dayjs.default)(event.start_at);
-      const eventEnd = (0, import_dayjs.default)(event.end_at);
+    if (!workingTime) continue;
+    const workEndTime = (0, _dayjs.default)(workingTime.end_at);
+
+    // 计算从最快可用时间到工作结束时间的空闲时长（分钟）
+    let totalIdleTime = workEndTime.diff(fastestTime, 'minute');
+
+    // 减去已有预约占用的时间
+    const relevantEvents = workingTime.event_list?.filter(event => {
+      const eventStart = (0, _dayjs.default)(event.start_at);
+      const eventEnd = (0, _dayjs.default)(event.end_at);
+      // 只计算在最快可用时间之后的预约
       return eventEnd.isAfter(fastestTime) && eventStart.isAfter(fastestTime);
-    })) || [];
+    }) || [];
     for (const event of relevantEvents) {
-      const eventStart = (0, import_dayjs.default)(event.start_at);
-      const eventEnd = (0, import_dayjs.default)(event.end_at);
-      const eventDuration = eventEnd.diff(eventStart, "minute");
+      const eventStart = (0, _dayjs.default)(event.start_at);
+      const eventEnd = (0, _dayjs.default)(event.end_at);
+      const eventDuration = eventEnd.diff(eventStart, 'minute');
       totalIdleTime -= eventDuration;
     }
-    console.log(`[TimeslotUtils] 资源 ${resource.id}(${resource.main_field}):`, {
-      工作结束时间: workEndTime.format("HH:mm"),
-      总工作时长: workEndTime.diff(fastestTime, "minute") + "分钟",
-      预约占用时长: workEndTime.diff(fastestTime, "minute") - totalIdleTime + "分钟",
-      实际空闲时长: totalIdleTime + "分钟"
-    });
     if (totalIdleTime > maxIdleTime) {
       maxIdleTime = totalIdleTime;
       selectedResource = resource;
-      console.log(`[TimeslotUtils] 更新最佳选择: ${resource.main_field} (空闲${totalIdleTime}分钟)`);
     }
   }
-  console.log(`[TimeslotUtils] 最终选择资源: ${selectedResource.main_field} (最长空闲${maxIdleTime}分钟)`);
   return selectedResource;
 }
+
+/**
+ * 给定一个时间列表，通过开始和结束时间过滤出符合条件的时间段
+ *
+ * @export
+ * @param {TimeSliceItem[]} times
+ * @param {Dayjs} startTime
+ * @param {Dayjs} endTime
+ * @return {*} 
+ */
 function filterConditionTimeSlots(times, startTime, endTime) {
-  return times.filter((n) => {
-    return !(0, import_dayjs.default)(n.start_at).isAfter((0, import_dayjs.default)(startTime)) && !(0, import_dayjs.default)(n.end_at).isBefore((0, import_dayjs.default)(endTime));
+  return times.filter(n => {
+    return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(startTime)) && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(endTime));
   });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  calculateResourceAvailableTime,
-  filterConditionTimeSlots,
-  findFastestAvailableResource
-});
+}