@pisell/pisellos 0.0.569 → 0.10.2

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

@@ -1,143 +1,107 @@
-"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/resources.ts
+var resources_exports = {};
+__export(resources_exports, {
+  checkSessionProductLeadTime: () => checkSessionProductLeadTime,
+  checkTwoResourcesIntersection: () => checkTwoResourcesIntersection,
+  filterResourcesByFormItem: () => filterResourcesByFormItem,
+  filterScheduleByDateRange: () => filterScheduleByDateRange,
+  formatResources: () => formatResources,
+  getIsUsableByTimeItem: () => getIsUsableByTimeItem,
+  getOthersCartSelectedResources: () => getOthersCartSelectedResources,
+  getOthersSelectedResources: () => getOthersSelectedResources,
+  getResourcesByIds: () => getResourcesByIds,
+  getResourcesByProduct: () => getResourcesByProduct,
+  getResourcesIdsByProduct: () => getResourcesIdsByProduct,
+  getTimeSlicesByResource: () => getTimeSlicesByResource,
+  getTimeSlicesByResources: () => getTimeSlicesByResources,
+  getTimesIntersection: () => getTimesIntersection,
+  isConflict: () => isConflict,
+  mergeSubResourcesTimeSlices: () => mergeSubResourcesTimeSlices,
+  sortCombinedResources: () => sortCombinedResources
 });
-exports.checkSessionProductLeadTime = checkSessionProductLeadTime;
-exports.checkTwoResourcesIntersection = checkTwoResourcesIntersection;
-exports.filterResourcesByFormItem = filterResourcesByFormItem;
-exports.filterScheduleByDateRange = filterScheduleByDateRange;
-exports.getResourcesByProduct = exports.getResourcesByIds = exports.getOthersSelectedResources = exports.getOthersCartSelectedResources = exports.getIsUsableByTimeItem = exports.formatResources = void 0;
-exports.getResourcesIdsByProduct = getResourcesIdsByProduct;
-exports.mergeSubResourcesTimeSlices = exports.isConflict = exports.getTimesIntersection = exports.getTimeSlicesByResources = exports.getTimeSlicesByResource = void 0;
-exports.sortCombinedResources = sortCombinedResources;
-var _dayjs = _interopRequireDefault(require("dayjs"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/**
- * 1. 获取资源列表
- * 2. 根据当前选择的商品过滤出来对应的资源列表  getResourcesByProduct
- * 3. 格式化资源相关 格式化资源列表 --> 格式化资源 --> 获取时间切片列表 --> 判断单个时间切片是否可用 formatResources
- *
- */
-
-/**
- * @title: 获取重叠剩余量
- * @description:
- * @param {any} eventList
- * @param {number} current
- * @return {*}
- * @Author: zhiwei.Wang
- */
-const getUseableEventCount = (eventList, current) => {
+module.exports = __toCommonJS(resources_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var getUseableEventCount = (eventList, current) => {
   return (eventList || []).reduce((pre, event) => {
     return pre - event.pax;
   }, current || 0);
 };
-
-/**
- * @title: 判断两个时间段是否有重叠
- * @description:
- * @param {object} event
- * @param {object} current
- * @return {*}
- * @Author: zhiwei.Wang
- */
-const isConflict = (event, current) => {
-  const eventStart = (0, _dayjs.default)(event.start_at);
-  const eventEnd = (0, _dayjs.default)(event.end_at);
-  const currentStart = (0, _dayjs.default)(current.start_at);
+var isConflict = (event, current) => {
+  const eventStart = (0, import_dayjs.default)(event.start_at);
+  const eventEnd = (0, import_dayjs.default)(event.end_at);
+  const currentStart = (0, import_dayjs.default)(current.start_at);
   const _isBefore = currentStart.isBefore(eventEnd);
   let _isAfter = true;
-
-  // 如果传递结束时间,则比对结束时间
   if (current.end_at) {
-    const currentEnd = (0, _dayjs.default)(current.end_at);
+    const currentEnd = (0, import_dayjs.default)(current.end_at);
     _isAfter = currentEnd.isAfter(eventStart);
   }
-
-  // 检查是否有重叠
   return _isBefore && _isAfter;
 };
-
-/**
- * @title: 判断传入日期是否在当前日期之后
- * @description:
- * @param {any} date
- * @param {any} today
- * @return {*}
- * @Author: zhiwei.Wang
- */
-exports.isConflict = isConflict;
-const checkAfterToDay = (date, today = (0, _dayjs.default)()) => {
-  return (0, _dayjs.default)(date).isAfter((0, _dayjs.default)(today));
+var checkAfterToDay = (date, today = (0, import_dayjs.default)()) => {
+  return (0, import_dayjs.default)(date).isAfter((0, import_dayjs.default)(today));
 };
-
-/**
- * @title: 格式化资源, 添加自定义参数
- * @description:
- * @param {any} resourceItem
- * @return {*}
- * @Author: zhiwei.Wang
- * @Date: 2024-01-09 13:40
- */
-const formatResource = (resourceItem, booking) => {
-  // 当前资源
-  let _resourceItem = {
-    ...resourceItem
-  };
-
-  // 格式化times里面的数据
+var formatResource = (resourceItem, booking) => {
+  let _resourceItem = { ...resourceItem };
   _resourceItem.timeSlices = getTimeSlicesByResource({
     resource: _resourceItem,
     duration: booking.duration,
     split: 10,
-    currentDate: (0, _dayjs.default)().format('YYYY-MM-DD')
+    currentDate: (0, import_dayjs.default)().format("YYYY-MM-DD")
   });
-
-  // 格式化label
   _resourceItem.labelText = _resourceItem.main_field;
   return _resourceItem;
 };
-
-/**
- * @title: 判断资源容量是否可用
- * @description:
- * @param {object} param1
- * @return {*}
- * @Author: zhiwei.Wang
- */
-const checkCapacity = ({
+var checkCapacity = ({
   event_list,
   timeSlice,
   resource,
   currentCount = 1
 }) => {
-  // 单个预约：如果当前资源容量不足以满足需求的容量，且当前资源是没有被占用的，返回资源不可用标记，但在外部运算会通过 reason=capacityOnly 来处理组合资源可用
-  // 多个预约：只需判断容量是否足够
-  const isMultipleBooking = resource.resourceType === 'multiple';
+  const isMultipleBooking = resource.resourceType === "multiple";
   if (currentCount > resource.capacity && (isMultipleBooking || !isMultipleBooking && event_list.length === 0)) {
     return {
       status: false,
       capacity: resource.capacity,
-      reason: 'capacityOnly'
+      reason: "capacityOnly"
     };
   }
-  let conflict = (event_list || []).filter(d => {
-    return isConflict({
-      start_at: d.start_at,
-      end_at: d.end_at
-    }, {
-      start_at: timeSlice.start_at,
-      end_at: timeSlice.end_at
-    });
+  let conflict = (event_list || []).filter((d) => {
+    return isConflict(
+      { start_at: d.start_at, end_at: d.end_at },
+      { start_at: timeSlice.start_at, end_at: timeSlice.end_at }
+    );
   });
-
-  // 减去重叠的总量
   let conflictCount = getUseableEventCount(conflict, resource.capacity);
-
-  // 同一时间段内只能进行一个预约，无论容量是否已满。
-  if (resource.resourceType === 'single') {
-    // 0代表着不重叠,则满足条件
+  if (resource.resourceType === "single") {
     if (conflict.length === 0) {
       return {
         status: true,
@@ -150,7 +114,6 @@ const checkCapacity = ({
       };
     }
   } else {
-    // 当前预约量 <= 总剩余容量
     if (currentCount <= conflictCount) {
       return {
         status: true,
@@ -164,15 +127,7 @@ const checkCapacity = ({
     }
   }
 };
-
-/**
- * @title: 获取时间切片是否可用
- * @description: 根据时间切片、资源、当前预约量判断时间切片是否可用
- * @param {any} param1
- * @return {*}
- * @Author: zhiwei.Wang
- */
-const getIsUsableByTimeItem = ({
+var getIsUsableByTimeItem = ({
   timeSlice,
   time,
   resource,
@@ -180,34 +135,26 @@ const getIsUsableByTimeItem = ({
   resourcesUseableMap = {},
   cut_off_time
 }) => {
+  var _a;
   let status = {
     afterToDay: false,
     capacity: false,
     usable: false,
     remainingCapacity: 0,
     // 剩余容量
-    reason: ''
+    reason: ""
   };
-  // 最早可预约时间为 当前日期之后并且提前量之后
-  let earliest = (0, _dayjs.default)();
+  let earliest = (0, import_dayjs.default)();
   let canBookingForOngoing = false;
-  const {
-    unit,
-    unit_type,
-    type,
-    ongoing
-  } = cut_off_time || {};
-  // 允许购买已开始的活动
-  if (type === 'ongoing' && ongoing?.type === 'after_start') {
-    // 如果timeSlice.start_at 小于当前时间，判断当前时间是否在如果timeSlice.start_at+ongoing.unit之间
-    // 即，如果现在是15:30，timeSlice.start_at是15:00，ongoing.unit是60分钟，则允许预约
-    if ((0, _dayjs.default)(timeSlice.start_at).isBefore((0, _dayjs.default)())) {
-      if (earliest.isBefore((0, _dayjs.default)(timeSlice.start_at).add(ongoing.unit, 'minute'))) {
+  const { unit, unit_type, type, ongoing } = cut_off_time || {};
+  if (type === "ongoing" && (ongoing == null ? void 0 : ongoing.type) === "after_start") {
+    if ((0, import_dayjs.default)(timeSlice.start_at).isBefore((0, import_dayjs.default)())) {
+      if (earliest.isBefore((0, import_dayjs.default)(timeSlice.start_at).add(ongoing.unit, "minute"))) {
         canBookingForOngoing = true;
       }
     }
-  } else if (type === 'ongoing' && ongoing?.type === 'before_end') {
-    if ((0, _dayjs.default)(timeSlice.end_at).isAfter(earliest)) {
+  } else if (type === "ongoing" && (ongoing == null ? void 0 : ongoing.type) === "before_end") {
+    if ((0, import_dayjs.default)(timeSlice.end_at).isAfter(earliest)) {
       canBookingForOngoing = true;
     }
   } else {
@@ -215,28 +162,25 @@ const getIsUsableByTimeItem = ({
       earliest = earliest.add(unit, unit_type);
     }
   }
-  // 不可预约提前量时间之前的
   if (!checkAfterToDay(timeSlice.start_at, earliest) && !canBookingForOngoing) {
     return status;
   }
   status.afterToDay = true;
   const checkCapacityResult = checkCapacity({
-    event_list: time?.event_list,
+    event_list: time == null ? void 0 : time.event_list,
     timeSlice,
     resource,
     currentCount
   });
-  if (resource.combined_resource?.status) {
-    // 组合资源中子资源是否可用
+  if ((_a = resource.combined_resource) == null ? void 0 : _a.status) {
     const resourceIds = resource.combined_resource.resource_ids;
-    resourceIds.forEach(id => {
-      // 只要有一个子资源不可用，整个组合资源都不可用
-      if (resourcesUseableMap?.[id] === false) {
+    resourceIds.forEach((id) => {
+      if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[id]) === false) {
         checkCapacityResult.status = false;
       }
     });
   }
-  status.reason = checkCapacityResult.reason || '';
+  status.reason = checkCapacityResult.reason || "";
   if (!checkCapacityResult.status) {
     return status;
   }
@@ -245,113 +189,116 @@ const getIsUsableByTimeItem = ({
   status.usable = true;
   return status;
 };
-
-/**
- * @title: 获取商品下绑定的资源列表
- * @description:
- * @param {any} resourcesMap
- * @param {any} product
- * @return {*}
- * @Author: zhiwei.Wang
- */
-exports.getIsUsableByTimeItem = getIsUsableByTimeItem;
-const getResourcesByProduct = (resourcesMap, resources, selectedResources, capacity = 1) => {
+var getResourcesByProduct = (resourcesMap, resources, selectedResources, capacity = 1) => {
   return (resources || []).reduce((acc, item) => {
-    if (item?.status == 1) {
+    if ((item == null ? void 0 : item.status) == 1) {
       const form_id = item.id;
-      // 去重 可选资源和必选资源可能会有重复的
-      item.optional_resource = (item.optional_resource || []).filter(d => item.default_resource.indexOf(d) == -1);
-      let optional_resource = item.optional_resource.reduce((childAcc, d) => {
-        // 如果其他资源选择过，并且这个资源是单个预约，则不可以选中此资源
-        // TODO: 如果容量超了这里怎么处理？
-        const isSelectSingleResources = resourcesMap[d]?.resourceType === 'single' && selectedResources.includes(resourcesMap[d].id);
-        if (resourcesMap[d] && !isSelectSingleResources) {
-          // 拼装组合资源的数据
-          const combiningResources = [];
-          if (resourcesMap[d].combined_resource && resourcesMap[d].combined_resource.status === 1) {
-            resourcesMap[d].combined_resource.resource_ids.forEach(id => {
-              if (resourcesMap[id]) {
-                combiningResources.push(resourcesMap[id]);
-                childAcc.push(Object.assign({}, resourcesMap[id], {
-                  form_id: form_id,
-                  resourceType: item.type,
-                  children: combiningResources,
-                  onlyComputed: true,
-                  // 是否是只用来计算用，组合资源里，假设商品只关联了组合资源没关联子资源，需要通过这个计算来在后面从 renderList 里删除这个资源
-                  metadata: {
-                    ...resourcesMap[id].metadata,
-                    combined_resource: resourcesMap[id].combined_resource,
-                    form_name: item.title,
-                    resource_name: resourcesMap[id].main_field
+      item.optional_resource = (item.optional_resource || []).filter(
+        (d) => item.default_resource.indexOf(d) == -1
+      );
+      let optional_resource = item.optional_resource.reduce(
+        (childAcc, d) => {
+          var _a;
+          const isSelectSingleResources = ((_a = resourcesMap[d]) == null ? void 0 : _a.resourceType) === "single" && selectedResources.includes(resourcesMap[d].id);
+          if (resourcesMap[d] && !isSelectSingleResources) {
+            const combiningResources = [];
+            if (resourcesMap[d].combined_resource && resourcesMap[d].combined_resource.status === 1) {
+              resourcesMap[d].combined_resource.resource_ids.forEach(
+                (id) => {
+                  if (resourcesMap[id]) {
+                    combiningResources.push(resourcesMap[id]);
+                    childAcc.push(
+                      Object.assign({}, resourcesMap[id], {
+                        form_id,
+                        resourceType: item.type,
+                        children: combiningResources,
+                        onlyComputed: true,
+                        // 是否是只用来计算用，组合资源里，假设商品只关联了组合资源没关联子资源，需要通过这个计算来在后面从 renderList 里删除这个资源
+                        metadata: {
+                          ...resourcesMap[id].metadata,
+                          combined_resource: resourcesMap[id].combined_resource,
+                          form_name: item.title,
+                          resource_name: resourcesMap[id].main_field
+                        }
+                      })
+                    );
                   }
-                }));
-              }
-            });
-          }
-          childAcc.push(Object.assign({}, resourcesMap[d], {
-            form_id: form_id,
-            resourceType: item.type,
-            children: combiningResources,
-            metadata: {
-              ...resourcesMap[d].metadata,
-              combined_resource: resourcesMap[d].combined_resource,
-              form_name: item.title,
-              resource_name: resourcesMap[d].main_field
+                }
+              );
             }
-          }));
-        }
-        return childAcc;
-      }, []);
-      let default_resource = item.default_resource.reduce((childAcc, d) => {
-        const isSelectSingleResources = resourcesMap[d]?.resourceType === 'single' && selectedResources.includes(resourcesMap[d].id);
-        if (resourcesMap[d] && !isSelectSingleResources) {
-          // 拼装组合资源的数据
-          const combiningResources = [];
-          if (resourcesMap[d].combined_resource && resourcesMap[d].combined_resource.status === 1) {
-            resourcesMap[d].combined_resource.resource_ids.forEach(id => {
-              if (resourcesMap[id]) {
-                combiningResources.push(resourcesMap[id]);
-                childAcc.push(Object.assign({}, resourcesMap[id], {
-                  form_id: form_id,
-                  resourceType: item.type,
-                  children: combiningResources,
-                  onlyComputed: true,
-                  // 是否是只用来计算用，组合资源里，假设商品只关联了组合资源没关联子资源，需要通过这个计算来在后面从 renderList 里删除这个资源
-                  metadata: {
-                    ...resourcesMap[id].metadata,
-                    combined_resource: resourcesMap[id].combined_resource,
-                    form_name: item.title,
-                    resource_name: resourcesMap[id].main_field
-                  }
-                }));
-              }
-            });
+            childAcc.push(
+              Object.assign({}, resourcesMap[d], {
+                form_id,
+                resourceType: item.type,
+                children: combiningResources,
+                metadata: {
+                  ...resourcesMap[d].metadata,
+                  combined_resource: resourcesMap[d].combined_resource,
+                  form_name: item.title,
+                  resource_name: resourcesMap[d].main_field
+                }
+              })
+            );
           }
-          childAcc.push(Object.assign({}, resourcesMap[d], {
-            form_id: form_id,
-            resourceType: item.type,
-            is_default: 1,
-            children: combiningResources,
-            metadata: {
-              ...resourcesMap[d].metadata,
-              combined_resource: resourcesMap[d].combined_resource,
-              form_name: item.title,
-              resource_name: resourcesMap[d].main_field
+          return childAcc;
+        },
+        []
+      );
+      let default_resource = item.default_resource.reduce(
+        (childAcc, d) => {
+          var _a;
+          const isSelectSingleResources = ((_a = resourcesMap[d]) == null ? void 0 : _a.resourceType) === "single" && selectedResources.includes(resourcesMap[d].id);
+          if (resourcesMap[d] && !isSelectSingleResources) {
+            const combiningResources = [];
+            if (resourcesMap[d].combined_resource && resourcesMap[d].combined_resource.status === 1) {
+              resourcesMap[d].combined_resource.resource_ids.forEach(
+                (id) => {
+                  if (resourcesMap[id]) {
+                    combiningResources.push(resourcesMap[id]);
+                    childAcc.push(
+                      Object.assign({}, resourcesMap[id], {
+                        form_id,
+                        resourceType: item.type,
+                        children: combiningResources,
+                        onlyComputed: true,
+                        // 是否是只用来计算用，组合资源里，假设商品只关联了组合资源没关联子资源，需要通过这个计算来在后面从 renderList 里删除这个资源
+                        metadata: {
+                          ...resourcesMap[id].metadata,
+                          combined_resource: resourcesMap[id].combined_resource,
+                          form_name: item.title,
+                          resource_name: resourcesMap[id].main_field
+                        }
+                      })
+                    );
+                  }
+                }
+              );
             }
-          }));
-        }
-        return childAcc;
-      }, []);
-      // 合并渲染
+            childAcc.push(
+              Object.assign({}, resourcesMap[d], {
+                form_id,
+                resourceType: item.type,
+                is_default: 1,
+                children: combiningResources,
+                metadata: {
+                  ...resourcesMap[d].metadata,
+                  combined_resource: resourcesMap[d].combined_resource,
+                  form_name: item.title,
+                  resource_name: resourcesMap[d].main_field
+                }
+              })
+            );
+          }
+          return childAcc;
+        },
+        []
+      );
       item.renderList = optional_resource.concat(default_resource);
-      // renderList里 times 的每一项需要匹配一下当前时间，如果 times 里最小的end_at小于当前时间，则这个资源应该从 renderList 删除
-      item.renderList = item.renderList.filter(d => {
+      item.renderList = item.renderList.filter((d) => {
         const latestTime = d.times.reduce((latest, current) => {
-          return (0, _dayjs.default)(current.end_at).isAfter((0, _dayjs.default)(latest.end_at)) ? current : latest;
+          return (0, import_dayjs.default)(current.end_at).isAfter((0, import_dayjs.default)(latest.end_at)) ? current : latest;
         }, d.times[0]);
-        // TODO,在这拉时间切片出来，如果可用 timeSlots.length > 1 才可以被选择
-        // 当前资源的配置容量需要大于当前需求的 capacity
-        return (0, _dayjs.default)(latestTime.end_at).isAfter((0, _dayjs.default)()) && d.capacity >= capacity;
+        return (0, import_dayjs.default)(latestTime.end_at).isAfter((0, import_dayjs.default)()) && d.capacity >= capacity;
       });
       item.form_id = form_id;
       acc.push(item);
@@ -359,16 +306,7 @@ const getResourcesByProduct = (resourcesMap, resources, selectedResources, capac
     return acc;
   }, []);
 };
-
-/**
- * @title: 获取资源列表
- * @description:
- * @return {*}
- * @Author: zhiwei.Wang
- * @Date: 2024-01-09 13:38
- */
-exports.getResourcesByProduct = getResourcesByProduct;
-const formatResources = ({
+var formatResources = ({
   booking,
   resources
 }) => {
@@ -377,39 +315,30 @@ const formatResources = ({
     let maps = {};
     for (let item of _list) {
       let renderListMaps = {};
-      item.renderList = item.renderList.map(d => {
+      item.renderList = item.renderList.map((d) => {
         let res = formatResource(d, booking);
         renderListMaps[res.id] = res;
         return res;
       });
       maps[item.form_id] = {
         ...item,
-        renderListMaps: renderListMaps
+        renderListMaps
       };
     }
-    return {
-      list: _list,
-      maps: maps
-    };
-  } catch (err) {}
+    return { list: _list, maps };
+  } catch (err) {
+    console.log("formatResourcesErr", err);
+  }
   return {
     list: [],
     maps: {}
   };
 };
-
-/**
- * @title: 获取资源的时间切片列表
- * @description:
- * @return {*}
- * @Author: zhiwei.Wang
- */
-exports.formatResources = formatResources;
-const getTimeSlicesByResource = ({
+var getTimeSlicesByResource = ({
   resource,
   duration,
   split = 10,
-  currentDate = (0, _dayjs.default)(),
+  currentDate = (0, import_dayjs.default)(),
   capacity,
   resourcesUseableMap = {},
   cut_off_time,
@@ -417,45 +346,26 @@ const getTimeSlicesByResource = ({
   operating_day_boundary,
   maxBlockThreshold
 }) => {
-  let {
-    times
-  } = resource;
-
-  // 存储所有时间切片
+  let { times } = resource;
   const timeSlices = [];
-  // times 先以开始时间为准做个排序，时间早的先循环
   times.sort((a, b) => {
-    return (0, _dayjs.default)(a.start_at).diff((0, _dayjs.default)(b.start_at), 'minute');
+    return (0, import_dayjs.default)(a.start_at).diff((0, import_dayjs.default)(b.start_at), "minute");
   });
-
-  // 处理每个时间范围
-  times.forEach(time => {
-    // 创建今天的日期字符串，用于构建完整的日期时间
-    // const today = dayjs(currentDate).format('YYYY-MM-DD');
-
-    // 解析开始和结束时间
-    const startTime = (0, _dayjs.default)(`${time.start_at}`);
-    let endTime = (0, _dayjs.default)(`${time.end_at}`);
-    // 结束时间要做修复，如果time.end_at 是超过了 currentDate 的那一天，则把 end_at 设置为 currentDate 那一天的 23:59:59
-    if (endTime.isAfter((0, _dayjs.default)(currentDate).endOf('day'))) {
-      endTime = (0, _dayjs.default)(currentDate).endOf('day');
+  times.forEach((time) => {
+    const startTime = (0, import_dayjs.default)(`${time.start_at}`);
+    let endTime = (0, import_dayjs.default)(`${time.end_at}`);
+    if (endTime.isAfter((0, import_dayjs.default)(currentDate).endOf("day"))) {
+      endTime = (0, import_dayjs.default)(currentDate).endOf("day");
     }
-
-    // 当前切片的开始时间
     let currentStart = startTime;
-
-    // 生成时间切片
     while (true) {
-      // 计算当前切片的结束时间
-      const currentEnd = currentStart.add(duration, 'minute');
-
-      // 如果结束时间超过了时间范围的结束时间，则停止
+      const currentEnd = currentStart.add(duration, "minute");
       if (currentEnd.isAfter(endTime)) {
         break;
       }
       const timeSlice = {
-        start_time: currentStart.format('HH:mm'),
-        end_time: currentEnd.format('HH:mm'),
+        start_time: currentStart.format("HH:mm"),
+        end_time: currentEnd.format("HH:mm"),
         start_at: currentStart,
         end_at: currentEnd
       };
@@ -464,54 +374,39 @@ const getTimeSlicesByResource = ({
         time,
         resource,
         currentCount: capacity || 1,
-        resourcesUseableMap: resourcesUseableMap,
+        resourcesUseableMap,
         cut_off_time
       });
-      if (resourcesUseableMap?.[resource.id] !== false) {
+      if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[resource.id]) !== false) {
         resourcesUseableMap[resource.id] = _status.usable;
       }
       if (_status.usable) {
-        // 如果有hasFlexibleDuration，且timeSlice.start_at 大于等于operating_day_boundary，则不添加时间切片
-        const operatingBoundaryDateTime = operating_day_boundary?.type === 'start_time' ? '23:59' : operating_day_boundary?.time;
-        if (hasFlexibleDuration && operating_day_boundary && timeSlice.start_time >= (operatingBoundaryDateTime || '23:59')) {
+        const operatingBoundaryDateTime = (operating_day_boundary == null ? void 0 : operating_day_boundary.type) === "start_time" ? "23:59" : operating_day_boundary == null ? void 0 : operating_day_boundary.time;
+        if (hasFlexibleDuration && operating_day_boundary && timeSlice.start_time >= (operatingBoundaryDateTime || "23:59")) {
           break;
         }
-        // 如果有配置了最低禁止购买时长，则需要判断时间切片是否在最低禁止购买时长内
-        // 看一下endTime和operatingBoundaryDateTime哪个早，哪个早用哪个去比较
-        const operatingBoundaryDateTimeObj = (0, _dayjs.default)(`${endTime.format('YYYY-MM-DD')} ${operatingBoundaryDateTime}`);
+        const operatingBoundaryDateTimeObj = (0, import_dayjs.default)(`${endTime.format("YYYY-MM-DD")} ${operatingBoundaryDateTime}`);
         const earlyTime = endTime.isBefore(operatingBoundaryDateTimeObj) ? endTime : operatingBoundaryDateTimeObj;
-        if (hasFlexibleDuration && operating_day_boundary && maxBlockThreshold && timeSlice.start_at.add(maxBlockThreshold || 0, 'minutes').isAfter(earlyTime)) {
+        if (hasFlexibleDuration && operating_day_boundary && maxBlockThreshold && timeSlice.start_at.add(maxBlockThreshold || 0, "minutes").isAfter(earlyTime)) {
           break;
         }
-        // 添加时间切片  09:00 ~ 10:00   09:20 ~ 10:20   09:00 ~ 10:00   09:20 ~ 10:20  11:00 ~ 12:00   11:20 ~ 12:20
         timeSlices.push({
           ...timeSlice,
           // 这里需要补充这个时间段内是否可预约
-          _status: _status
+          _status
         });
       }
-      // 移动到下一个开始时间（增加10分钟）
-      currentStart = currentStart.add(split, 'minute');
+      currentStart = currentStart.add(split, "minute");
     }
   });
   return timeSlices;
 };
-
-/**
- * @title: 获取时间切片列表的交集
- * @description:  注意： 需要将多个时间切片列表合并在一起，然后判断交集
- * @param {TimeSliceItem} times 多个时间切片
- * @param {number} count 交集次数， 符合此次数的会返回
- * @return {*}
- * @Author: zhiwei.Wang
- */
-exports.getTimeSlicesByResource = getTimeSlicesByResource;
-const getTimesIntersection = (times, count) => {
+var getTimesIntersection = (times, count) => {
   let obj = times.reduce((acc, item) => {
     let _key = `${item.start_time}-${item.end_time}`;
     if (!acc[_key]) {
       acc[_key] = {
-        item: item,
+        item,
         count: 1
       };
     } else {
@@ -519,44 +414,24 @@ const getTimesIntersection = (times, count) => {
     }
     return acc;
   }, {});
-
-  // 过滤出符合交集次数的
-  return Object.values(obj).filter(d => d.count >= count).map(d => d.item);
+  return Object.values(obj).filter((d) => d.count >= count).map((d) => d.item);
 };
-
-/**
- * @title: 根据ids筛选资源列表
- * @description:
- * @param {any} resourcesMap
- * @param {any} ids
- * @return {*}
- * @Author: zhiwei.Wang
- * @Date: 2024-09-19 20:23
- */
-exports.getTimesIntersection = getTimesIntersection;
-const getResourcesByIds = (resourcesMap, ids) => {
-  return (ids || []).map(id => resourcesMap[id]);
+var getResourcesByIds = (resourcesMap, ids) => {
+  return (ids || []).map((id) => resourcesMap[id]);
 };
-
-/**
- * @title: 合并子资源的时间切片至组合资源
- * @description:
- * @param {ResourceItem[]} resources
- * @param {Record<string, ResourceItem>} resourcesMap
- * @return {*}
- * @Author: zhiwei.Wang
- */
-exports.getResourcesByIds = getResourcesByIds;
-const mergeSubResourcesTimeSlices = (resources, resourcesMap) => {
-  return resources.forEach(item => {
-    if (item?.combined_resource?.status === 1) {
-      item?.combined_resource?.resource_ids.forEach(id => {
+var mergeSubResourcesTimeSlices = (resources, resourcesMap) => {
+  return resources.forEach((item) => {
+    var _a, _b;
+    if (((_a = item == null ? void 0 : item.combined_resource) == null ? void 0 : _a.status) === 1) {
+      (_b = item == null ? void 0 : item.combined_resource) == null ? void 0 : _b.resource_ids.forEach((id) => {
         const subResource = resourcesMap[id];
         if (subResource) {
-          subResource.times.forEach(time => {
-            const fatherResourcesTime = item.times.find(n => n.start_at === time.start_at && n.end_at === time.end_at);
+          subResource.times.forEach((time) => {
+            const fatherResourcesTime = item.times.find(
+              (n) => n.start_at === time.start_at && n.end_at === time.end_at
+            );
             if (fatherResourcesTime) {
-              fatherResourcesTime.event_list.push(...(time.event_list || []));
+              fatherResourcesTime.event_list.push(...time.event_list || []);
             }
           });
         }
@@ -564,17 +439,7 @@ const mergeSubResourcesTimeSlices = (resources, resourcesMap) => {
     }
   });
 };
-
-/**
- * @title: 根据资源id列表获取时间切片
- * @description:  传入一个技师id列表， 找出技师列表中公共的时间切片
- * @param {ResourceItem} resources
- * @param {CartItem} cart
- * @return {*}
- * @Author: zhiwei.Wang
- */
-exports.mergeSubResourcesTimeSlices = mergeSubResourcesTimeSlices;
-const getTimeSlicesByResources = ({
+var getTimeSlicesByResources = ({
   resourceIds,
   resourcesMap,
   duration,
@@ -587,181 +452,129 @@ const getTimeSlicesByResources = ({
   operating_day_boundary,
   maxBlockThreshold
 }) => {
-  // 获取资源列表
   let resources = getResourcesByIds(resourcesMap, resourceIds);
   mergeSubResourcesTimeSlices(resources, resourcesMap);
-  // 资源排下序，把单个资源靠前，组合资源排在后面
   resources.sort((a, b) => {
-    const aIsCombined = a.metadata?.combined_resource?.status === 1;
-    const bIsCombined = b.metadata?.combined_resource?.status === 1;
-    if (aIsCombined && !bIsCombined) return 1;
-    if (!aIsCombined && bIsCombined) return -1;
+    var _a, _b, _c, _d;
+    const aIsCombined = ((_b = (_a = a.metadata) == null ? void 0 : _a.combined_resource) == null ? void 0 : _b.status) === 1;
+    const bIsCombined = ((_d = (_c = b.metadata) == null ? void 0 : _c.combined_resource) == null ? void 0 : _d.status) === 1;
+    if (aIsCombined && !bIsCombined)
+      return 1;
+    if (!aIsCombined && bIsCombined)
+      return -1;
     return 0;
   });
-
-  // 获取资源列表中所有的时间切片
-  let timeSliceList = resources.reduce((acc, item) => {
-    return acc.concat(getTimeSlicesByResource({
-      resource: item,
-      duration: duration,
-      split: split,
-      currentDate: currentDate,
-      capacity: capacity,
-      resourcesUseableMap: resourcesUseableMap,
-      cut_off_time: cut_off_time,
-      hasFlexibleDuration,
-      operating_day_boundary,
-      maxBlockThreshold
-    }));
-  }, []);
-
-  // 获取时间切片列表的交集
+  let timeSliceList = resources.reduce(
+    (acc, item) => {
+      return acc.concat(
+        getTimeSlicesByResource({
+          resource: item,
+          duration,
+          split,
+          currentDate,
+          capacity,
+          resourcesUseableMap,
+          cut_off_time,
+          hasFlexibleDuration,
+          operating_day_boundary,
+          maxBlockThreshold
+        })
+      );
+    },
+    []
+  );
   let intersection = getTimesIntersection(timeSliceList, resources.length);
   return intersection;
 };
-
-/**
- * @title: 获取其他人的已选资源
- * @description:
- * @param {CartItem[]} cartItems
- * @param {number | string} accountId
- * @return {*}
- * @Author: jinglin.tan
- */
-exports.getTimeSlicesByResources = getTimeSlicesByResources;
-const getOthersSelectedResources = (cartItems, accountId, resourcesMap) => {
+var getOthersSelectedResources = (cartItems, accountId, resourcesMap) => {
   return cartItems.reduce((acc, d) => {
+    var _a;
     if (d.holder_id !== accountId) {
-      if (d._origin?.resources) {
-        d._origin.resources.forEach(n => {
-          // 如果是组合资源，还需要检查组合资源里子资源是否被占用过
+      if ((_a = d._origin) == null ? void 0 : _a.resources) {
+        d._origin.resources.forEach((n) => {
           if (n.metadata.combined_resource && n.metadata.combined_resource.status === 1) {
-            // 如果组合资源里子资源被占用过，则这个资源不可以进待选列表了
-            if (n.metadata.combined_resource.resource_ids.some(m => acc.includes(m))) {
+            if (n.metadata.combined_resource.resource_ids.some(
+              (m) => acc.includes(m)
+            )) {
               return acc;
             }
             acc.push(...n.metadata.combined_resource.resource_ids);
-            // n.metadata.combined_resource.resource_ids.forEach((m: number) => {
-            //   if (resourcesMap[m]) resourcesMap[m].capacity -= d.num || 0;
-            // });
           } else {
-            // 如果当前选中的不是组合资源，但是是别的组合资源里的子资源，则还需要把别的组合资源也加进来
-            // 去 resourcesMap 里找一下 n.id 是不是别的组合资源里的子资源，是的话把别的组合资源也加进来
-            Object.values(resourcesMap).forEach(m => {
+            Object.values(resourcesMap).forEach((m) => {
               if (m.combined_resource && m.combined_resource.status === 1) {
                 if (m.combined_resource.resource_ids.includes(n.id)) {
                   acc.push(m.id);
-                  // if (resourcesMap[m.id]) resourcesMap[m.id].capacity -= d.num || 0;
                 }
               }
             });
           }
           acc.push(n.id);
-          // if (resourcesMap[n.id]) resourcesMap[n.id].capacity -= currentCapacity || 0;
         });
       }
     }
     return acc;
   }, []);
 };
-
-/**
- * @title: 获取其他购物车内商品的已选资源
- * @description:
- * @param {CartItem[]} cartItems
- * @param {number | string} accountId
- * @return {*}
- * @Author: jinglin.tan
- */
-exports.getOthersSelectedResources = getOthersSelectedResources;
-const getOthersCartSelectedResources = (cartItems, cartItemId, resourcesMap) => {
+var getOthersCartSelectedResources = (cartItems, cartItemId, resourcesMap) => {
   return cartItems.reduce((acc, d) => {
+    var _a;
     if (d._id !== cartItemId) {
-      if (d._origin?.resources) {
-        d._origin.resources.forEach(n => {
-          // 如果是组合资源，还需要检查组合资源里子资源是否被占用过
+      if ((_a = d._origin) == null ? void 0 : _a.resources) {
+        d._origin.resources.forEach((n) => {
           if (n.metadata.combined_resource && n.metadata.combined_resource.status === 1) {
-            // 如果组合资源里子资源被占用过，则这个资源不可以进待选列表了
-            if (n.metadata.combined_resource.resource_ids.some(m => acc.includes(m))) {
+            if (n.metadata.combined_resource.resource_ids.some(
+              (m) => acc.includes(m)
+            )) {
               return acc;
             }
             acc.push(...n.metadata.combined_resource.resource_ids);
-            // n.metadata.combined_resource.resource_ids.forEach((m: number) => {
-            //   resourcesMap[m].capacity -= n.num;
-            // });
           } else {
-            // 如果当前选中的不是组合资源，但是是别的组合资源里的子资源，则还需要把别的组合资源也加进来
-            // 去 resourcesMap 里找一下 n.id 是不是别的组合资源里的子资源，是的话把别的组合资源也加进来
-            Object.values(resourcesMap).forEach(m => {
+            Object.values(resourcesMap).forEach((m) => {
               if (m.combined_resource && m.combined_resource.status === 1) {
                 if (m.combined_resource.resource_ids.includes(n.id)) {
                   acc.push(m.id);
-                  // resourcesMap[m.id].capacity -= n.num;
                 }
               }
             });
           }
           acc.push(n.id);
-          // push 完以后，把 resourceMap 的 capacity 减掉当前的商品数量
-          // resourcesMap[n.id].capacity -= currentCapacity || 0;
         });
       }
     }
     return acc;
   }, []);
 };
-exports.getOthersCartSelectedResources = getOthersCartSelectedResources;
-/**
- * @title: 根据日期范围过滤日程
- *
- * @export
- * @param {any[]} schedule
- * @param {string} startDate
- * @param {string} endDate
- * @return {*}
- */
 function filterScheduleByDateRange(schedule, startDate, endDate) {
-  if (!schedule?.length) return [];
+  if (!(schedule == null ? void 0 : schedule.length))
+    return [];
   const start = new Date(startDate);
   const end = new Date(endDate);
-  return schedule.filter(item => {
+  return schedule.filter((item) => {
     const itemDate = new Date(item.date);
     return itemDate >= start && itemDate <= end;
   });
 }
-
-/**
- * 传入商品数据，返回基于商品配置的提前量的最早开始日期和最晚结束日期
- *
- * @export
- * @param {ProductData} product
- * @return {*}
- */
 function checkSessionProductLeadTime(product) {
-  let latestStartDate = ''; // 最晚开始日期
-  let earliestEndDate = ''; // 最早结束日期
-  const {
-    future_day,
-    unit,
-    unit_type
-  } = product.cut_off_time;
-  // 预定天数存在，则开始计算从当前时间开始往后推预定天数作为结束时间
+  let latestStartDate = "";
+  let earliestEndDate = "";
+  const { future_day, unit, unit_type } = product.cut_off_time;
   if (future_day) {
-    const endDate = (0, _dayjs.default)().add(future_day, 'day');
-    if (!earliestEndDate || endDate.isBefore((0, _dayjs.default)(earliestEndDate), 'day')) {
-      earliestEndDate = endDate.format('YYYY-MM-DD');
+    const endDate = (0, import_dayjs.default)().add(future_day, "day");
+    if (!earliestEndDate || endDate.isBefore((0, import_dayjs.default)(earliestEndDate), "day")) {
+      earliestEndDate = endDate.format("YYYY-MM-DD");
     }
   } else if (future_day === 0) {
-    const endDate = (0, _dayjs.default)();
-    if (!earliestEndDate || endDate.isBefore((0, _dayjs.default)(earliestEndDate), 'day')) {
-      earliestEndDate = endDate.format('YYYY-MM-DD');
+    const endDate = (0, import_dayjs.default)();
+    if (!earliestEndDate || endDate.isBefore((0, import_dayjs.default)(earliestEndDate), "day")) {
+      earliestEndDate = endDate.format("YYYY-MM-DD");
     }
   }
-  // 如果存在提前预约时间，则开始计算从当前时间开始往后推提前预约时间作为开始时间
   if (unit && unit_type) {
-    const startDate = (0, _dayjs.default)((0, _dayjs.default)().add(unit, unit_type).format('YYYY-MM-DD'));
-    if (!latestStartDate || startDate.isAfter((0, _dayjs.default)(latestStartDate), 'day')) {
-      latestStartDate = startDate.format('YYYY-MM-DD');
+    const startDate = (0, import_dayjs.default)(
+      (0, import_dayjs.default)().add(unit, unit_type).format("YYYY-MM-DD")
+    );
+    if (!latestStartDate || startDate.isAfter((0, import_dayjs.default)(latestStartDate), "day")) {
+      latestStartDate = startDate.format("YYYY-MM-DD");
     }
   }
   return {
@@ -769,75 +582,65 @@ function checkSessionProductLeadTime(product) {
     earliestEndDate
   };
 }
-
-/**
- * 基于商品的 resources 配置，返回可选择的资源的 id 列表
- *
- * @export
- * @param {ProductData} product
- * @return {*}
- */
 function getResourcesIdsByProduct(product) {
+  var _a, _b, _c;
   const tempResourceIds = [];
-  product?.product_resource?.resources?.forEach?.(resource => {
-    if (resource?.status == 1) {
-      if (resource?.default_resource?.length) {
-        tempResourceIds.push(...resource?.default_resource);
-      } else if (resource?.optional_resource?.length) {
-        tempResourceIds.push(...resource?.optional_resource);
+  (_c = (_b = (_a = product == null ? void 0 : product.product_resource) == null ? void 0 : _a.resources) == null ? void 0 : _b.forEach) == null ? void 0 : _c.call(_b, (resource) => {
+    var _a2, _b2;
+    if ((resource == null ? void 0 : resource.status) == 1) {
+      if ((_a2 = resource == null ? void 0 : resource.default_resource) == null ? void 0 : _a2.length) {
+        tempResourceIds.push(...resource == null ? void 0 : resource.default_resource);
+      } else if ((_b2 = resource == null ? void 0 : resource.optional_resource) == null ? void 0 : _b2.length) {
+        tempResourceIds.push(...resource == null ? void 0 : resource.optional_resource);
       }
     }
   });
   return tempResourceIds;
 }
-
-/**
- * 资源排序，把单个资源靠前，组合资源排在后面
- *
- * @export
- * @param {ResourceItem[]} resourcesList
- * @return {*}
- */
 function sortCombinedResources(resourcesList) {
   const newResourcesList = [...resourcesList];
   newResourcesList.sort((a, b) => {
-    const aIsCombined = a.metadata?.combined_resource?.status === 1;
-    const bIsCombined = b.metadata?.combined_resource?.status === 1;
+    var _a, _b, _c, _d;
+    const aIsCombined = ((_b = (_a = a.metadata) == null ? void 0 : _a.combined_resource) == null ? void 0 : _b.status) === 1;
+    const bIsCombined = ((_d = (_c = b.metadata) == null ? void 0 : _c.combined_resource) == null ? void 0 : _d.status) === 1;
     return aIsCombined === bIsCombined ? 0 : aIsCombined ? 1 : -1;
   });
   return newResourcesList;
 }
-
-/**
- * 传入一个资源组，根据 formid筛出相同类型的资源
- *
- * @export
- * @param {ResourceItem[]} resources
- * @param {string} form_id
- * @return {*}
- */
 function filterResourcesByFormItem(resources, form_id) {
-  return resources.filter(n => n.form_id === form_id);
+  return resources.filter((n) => n.form_id === form_id);
 }
-
-/**
- * 传入两个资源，确认这两个资源是否有交集（包括组合资源）
- *
- * @export
- * @param {ResourceItem} resource1
- * @param {ResourceItem} resource2
- * @return {*} 
- */
 function checkTwoResourcesIntersection(resource1, resource2) {
-  // 检查主资源ID是否匹配
-  if (resource1.id === resource2.id) return true;
-  // 检查组合资源的情况
-  if (resource1.metadata.combined_resource?.status === 1 && (
-  // 如果现在选择的是组合资源，需要判断
+  var _a, _b;
+  if (resource1.id === resource2.id)
+    return true;
+  if (((_a = resource1.metadata.combined_resource) == null ? void 0 : _a.status) === 1 && // 如果现在选择的是组合资源，需要判断
   // 1、当前其他购物车里是否选了当前组合资源的子资源
   // 2、如果其他购物车里的商品也是组合资源，出了组合资源本身的 id 需要判断，还需要判断子资源的 id 是否有交集
-  resource1.metadata.combined_resource.resource_ids.includes(resource2.id) || resource1.metadata.combined_resource.resource_ids.some(n => {
+  (resource1.metadata.combined_resource.resource_ids.includes(resource2.id) || resource1.metadata.combined_resource.resource_ids.some((n) => {
     return resource2.metadata.combined_resource.resource_ids.includes(n);
-  }))) return true;
-  if (resource2.metadata.combined_resource?.status === 1 && resource2.metadata.combined_resource.resource_ids.includes(resource2.id)) return true;
-}
+  })))
+    return true;
+  if (((_b = resource2.metadata.combined_resource) == null ? void 0 : _b.status) === 1 && resource2.metadata.combined_resource.resource_ids.includes(resource2.id))
+    return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkSessionProductLeadTime,
+  checkTwoResourcesIntersection,
+  filterResourcesByFormItem,
+  filterScheduleByDateRange,
+  formatResources,
+  getIsUsableByTimeItem,
+  getOthersCartSelectedResources,
+  getOthersSelectedResources,
+  getResourcesByIds,
+  getResourcesByProduct,
+  getResourcesIdsByProduct,
+  getTimeSlicesByResource,
+  getTimeSlicesByResources,
+  getTimesIntersection,
+  isConflict,
+  mergeSubResourcesTimeSlices,
+  sortCombinedResources
+});