@pisell/pisellos 0.0.568 → 0.10.1

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

@@ -1,27 +1,27 @@
-"use strict";
+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);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/solution/BookingByStep/utils/stock.ts
+var stock_exports = {};
+__export(stock_exports, {
+  checkProductStock: () => checkProductStock
 });
-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 库存检测结果
- */
+module.exports = __toCommonJS(stock_exports);
 function checkProductStock({
   productData,
   product_variant_id,
@@ -29,24 +29,20 @@ 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) => {
-      // 检查是否为相同商品（比较商品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;
+      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;
       if (isSameProduct && isSameVariant) {
         return total + (cartItem.num || 0);
       }
@@ -54,39 +50,25 @@ function checkProductStock({
     }, 0);
     const totalQuantity = existingQuantity + quantity;
     const stockQuantity = mainProductConfig.stock_quantity;
-
-    // 检查主商品库存是否足够
-    if (stockQuantity !== undefined && stockQuantity !== null && totalQuantity > stockQuantity) {
-      return {
-        success: false,
-        errorCode: 'not_enough_stock'
-      };
+    if (stockQuantity !== void 0 && 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 === undefined || bundleStockQuantity === null) continue;
-
-      // 计算购物车中已有的相同子商品数量
+      if (!isBundleTrackingEnabled || !isBundleOverSoldDisabled)
+        continue;
+      if (bundleStockQuantity === void 0 || 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);
           }
@@ -94,17 +76,14 @@ 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
-  };
-}
+  return { success: true };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkProductStock
+});

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

@@ -1,85 +1,79 @@
-"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/solution/BookingByStep/utils/timeslots.ts
+var timeslots_exports = {};
+__export(timeslots_exports, {
+  calculateResourceAvailableTime: () => calculateResourceAvailableTime,
+  filterConditionTimeSlots: () => filterConditionTimeSlots,
+  findFastestAvailableResource: () => findFastestAvailableResource
 });
-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 总可用时间（分钟）
- */
+module.exports = __toCommonJS(timeslots_exports);
+var import_dayjs = __toESM(require("dayjs"));
 function calculateResourceAvailableTime({
   resource,
   timeSlots,
   currentCapacity = 1
 }) {
-  // 过滤出与给定日期相同的资源时间
-  const matchingTimes = resource.times.filter(time => {
-    return (0, _dayjs.default)(time.start_at).isSame((0, _dayjs.default)(timeSlots.start_at), 'day');
+  const matchingTimes = resource.times.filter((time) => {
+    return (0, import_dayjs.default)(time.start_at).isSame((0, import_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, _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);
-
-    // 只有当重叠时间段有效时才添加
+    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);
     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,
@@ -87,140 +81,148 @@ function findFastestAvailableResource({
   targetDate,
   durationMinutes = 30
 }) {
-  const currentTime = (0, _dayjs.default)();
+  var _a, _b, _c;
+  const currentTime = (0, import_dayjs.default)();
   const resolvedDuration = durationMinutes > 0 ? durationMinutes : 30;
-  const targetDay = targetDate ? (0, _dayjs.default)(targetDate) : currentTime;
-  const isTargetDayToday = targetDay.isSame(currentTime, 'day');
+  const targetDay = targetDate ? (0, import_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, _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);
+    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);
     });
     if (targetDayTimes.length === 0) {
+      console.log(`[TimeslotUtils] 资源 ${resource.id}(${resource.main_field}) 今日无可用时间段`);
       continue;
     }
     for (const time of targetDayTimes) {
-      const workStartTime = (0, _dayjs.default)(time.start_at);
-      const workEndTime = (0, _dayjs.default)(time.end_at);
-
-      // 确定检查的起始时间（当前时间 vs 工作开始时间）
+      const workStartTime = (0, import_dayjs.default)(time.start_at);
+      const workEndTime = (0, import_dayjs.default)(time.end_at);
       let nextAvailableTime = isTargetDayToday && currentTime.isAfter(workStartTime) ? currentTime : workStartTime;
-      // 获取所有影响的预约事件（当前时间之后的）
-      const relevantEvents = time.event_list?.filter(event => {
-        const eventEnd = (0, _dayjs.default)(event.end_at);
+      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);
         return eventEnd.isAfter(nextAvailableTime);
-      }) || [];
-
-      // 按开始时间排序
-      relevantEvents.sort((a, b) => (0, _dayjs.default)(a.start_at).diff((0, _dayjs.default)(b.start_at)));
-
-      // 检查从 nextAvailableTime 开始的可用性
+      })) || [];
+      relevantEvents.sort(
+        (a, b) => (0, import_dayjs.default)(a.start_at).diff((0, import_dayjs.default)(b.start_at))
+      );
       let finalAvailableTime = nextAvailableTime;
       for (const event of relevantEvents) {
-        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'))) {
-            // 有冲突，使用事件结束时间
+        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"))) {
             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)) {
+      if (finalAvailableTime.add(resolvedDuration, "minute").isAfter(workEndTime)) {
+        console.log(`[TimeslotUtils] 资源 ${resource.id} 可用时间超出工作时间，跳过`);
         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, _dayjs.default)(time.start_at).isSame(fastestTime, 'day');
-      const isStillWorking = (0, _dayjs.default)(time.end_at).isAfter(fastestTime);
+    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);
       return isToday && isStillWorking;
     });
-    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);
-      // 只计算在最快可用时间之后的预约
+    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);
       return eventEnd.isAfter(fastestTime) && eventStart.isAfter(fastestTime);
-    }) || [];
+    })) || [];
     for (const event of relevantEvents) {
-      const eventStart = (0, _dayjs.default)(event.start_at);
-      const eventEnd = (0, _dayjs.default)(event.end_at);
-      const eventDuration = eventEnd.diff(eventStart, 'minute');
+      const eventStart = (0, import_dayjs.default)(event.start_at);
+      const eventEnd = (0, import_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, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(startTime)) && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(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));
   });
-}
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  calculateResourceAvailableTime,
+  filterConditionTimeSlots,
+  findFastestAvailableResource
+});