@pisell/pisellos 3.0.31 → 3.0.33

package/dist/solution/BookingByStep/index.js

@@ -27,12 +27,17 @@ function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e
 import { BaseModule } from "../../modules/BaseModule";
 import { BookingByStepHooks, createModule } from "./types";
 import { getAvailableProductResources } from "./utils/products";
-import { getResourcesByProduct, getTimeSlicesByResource, getTimeSlicesByResources, getIsUsableByTimeItem, getOthersSelectedResources, formatDefaultCapacitys, getSumCapacity, checkSubResourcesCapacity, getOthersCartSelectedResources } from "./utils/resources";
+import { getResourcesByProduct, getTimeSlicesByResource, getTimeSlicesByResources, getIsUsableByTimeItem, getOthersSelectedResources, formatDefaultCapacitys, getSumCapacity, checkSubResourcesCapacity, getOthersCartSelectedResources, filterScheduleByDateRange, checkSessionProductLeadTime, getResourcesIdsByProduct, sortCombinedResources } from "./utils/resources";
 import dayjs from 'dayjs';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
+dayjs.extend(isSameOrBefore);
+dayjs.extend(isSameOrAfter);
 import { getResourcesMap } from "../../modules/Resource/utils";
 import { cloneDeep } from 'lodash-es';
 import { calcCalendarDataByScheduleResult, calcMinTimeMaxTimeBySchedules, getAllSortedDateRanges } from "../../modules/Schedule/utils";
-import { disableAllDates, disableDatesBeforeOneDay, generateMonthDates } from "../../modules/Date/utils";
+import { disableAllDates, disableDatesBeforeOneDay, generateMonthDates, handleAvailableDateByResource } from "../../modules/Date/utils";
+import { calculateResourceAvailableTime, findFastestAvailableResource } from "./utils/timeslots";
 export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
   _inherits(BookingByStepImpl, _BaseModule);
   var _super = _createSuper(BookingByStepImpl);
@@ -267,7 +272,8 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
     key: "loadProductByScheduleDate",
     value: function () {
       var _loadProductByScheduleDate = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(_ref2) {
-        var date, product_ids, _ref2$category_ids, category_ids, scheduleList, scheduleIds;
+        var _product_ids;
+        var date, product_ids, _ref2$category_ids, category_ids, scheduleList, scheduleIds, _schedule$product_ids, schedule;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
@@ -288,17 +294,27 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                 return n.date === date;
               }).flatMap(function (n) {
                 return n.schedule_id;
-              });
-              _context3.next = 6;
+              }).filter(function (n) {
+                return n !== null && n !== undefined;
+              }); // 如果外面没传 product_ids，尝试从对应 schedule 里拿 product_ids
+              if (!((_product_ids = product_ids) !== null && _product_ids !== void 0 && _product_ids.length)) {
+                schedule = scheduleList.find(function (n) {
+                  return n.date === date;
+                });
+                if (schedule && (_schedule$product_ids = schedule.product_ids) !== null && _schedule$product_ids !== void 0 && _schedule$product_ids.length) {
+                  product_ids = schedule.product_ids;
+                }
+              }
+              _context3.next = 7;
               return this.loadProducts({
                 schedule_ids: scheduleIds,
                 product_ids: product_ids,
                 category_ids: category_ids,
                 schedule_date: date
               });
-            case 6:
-              return _context3.abrupt("return", _context3.sent);
             case 7:
+              return _context3.abrupt("return", _context3.sent);
+            case 8:
             case "end":
               return _context3.stop();
           }
@@ -321,7 +337,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
               // 更新完商品数据以后，检测当前购物车里是否有商品，如果有，则需要更新购物车里的商品价格
               cartItems = this.store.cart.getItems();
               if (!cartItems.length) {
-                _context5.next = 25;
+                _context5.next = 24;
                 break;
               }
               userPlugin = this.core.getPlugin('user');
@@ -413,8 +429,6 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
               _iterator.f();
               return _context5.finish(21);
             case 24:
-              ;
-            case 25:
             case "end":
               return _context5.stop();
           }
@@ -1793,6 +1807,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
         //   .format("HH:mm");
         // 根据 start_time 和 end_time 去匹配资源
         var targetResource = null;
+        var targetResourceTime = 0;
         var _iterator3 = _createForOfIteratorHelper(resources),
           _step3;
         try {
@@ -1835,8 +1850,14 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                 }
                 return res.usable;
               });
-              if (canUseTime && !n.onlyComputed) {
+              var currentResourceIdleTime = calculateResourceAvailableTime({
+                resource: n,
+                timeSlots: timeSlots,
+                currentCapacity: totalCapacity + (capacity || 0)
+              });
+              if (canUseTime && !n.onlyComputed && currentResourceIdleTime > targetResourceTime) {
                 targetResource = n;
+                targetResourceTime = currentResourceIdleTime;
                 return 1; // break
               }
             },
@@ -2034,7 +2055,12 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
               })) {
                 return;
               }
-              var targetResource = targetRenderList[0];
+              var fastestResource = findFastestAvailableResource({
+                resources: targetRenderList,
+                currentCapacity: currentCapacity,
+                countMap: selectResourcesMap
+              });
+              var targetResource = fastestResource || targetRenderList[0];
               targetResource.capacity = currentCapacity;
               // 在这里处理 children 的数据
               checkSubResourcesCapacity(targetResource);
@@ -2330,7 +2356,6 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
       var productResources = getResourcesByProduct(resourcesMap, resources || ((_this$store$currentPr2 = this.store.currentProduct) === null || _this$store$currentPr2 === void 0 || (_this$store$currentPr2 = _this$store$currentPr2.getData()) === null || _this$store$currentPr2 === void 0 || (_this$store$currentPr2 = _this$store$currentPr2.product_resource) === null || _this$store$currentPr2 === void 0 ? void 0 : _this$store$currentPr2.resources) || [], selectedResources, 1);
       var minTimeMaxTime = calcMinTimeMaxTimeBySchedules(targetSchedules, {}, date);
       var scheduleTimeSlots = getAllSortedDateRanges(minTimeMaxTime);
-      console.log('scheduleTimeSlots:', scheduleTimeSlots, productResources);
       // 当前所有待选择资源的集合，先提出来，提升性能
       var allProductResources = productResources.flatMap(function (n) {
         return n.renderList;
@@ -2501,7 +2526,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
      *
      * @param {string} cartItemId
      * @param {string} resourceCode
-     * @return {*} 
+     * @return {*}
      * @memberof BookingByStepImpl
      */
   }, {
@@ -2604,25 +2629,78 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
       }
       return targetResource.renderList;
     }
+
+    /**
+     * 根据日期范围批量获取时间槽
+     * @param params 参数对象
+     * @returns Promise<Record<string, TimeSliceItem[]>> 返回日期到时间槽的映射
+     */
+  }, {
+    key: "getTimeslotsScheduleByDateRange",
+    value: (function () {
+      var _getTimeslotsScheduleByDateRange = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28(_ref15) {
+        var startDate, endDate, scheduleIds, resources, dates, currentDate, end, results, _i, _dates, date;
+        return _regeneratorRuntime().wrap(function _callee28$(_context29) {
+          while (1) switch (_context29.prev = _context29.next) {
+            case 0:
+              startDate = _ref15.startDate, endDate = _ref15.endDate, scheduleIds = _ref15.scheduleIds, resources = _ref15.resources;
+              console.log('appoimentBooking-session-date-getTimeslotsScheduleByDateRange', {
+                startDate: startDate,
+                endDate: endDate,
+                scheduleIds: scheduleIds,
+                resources: resources
+              });
+              // 生成日期范围内的所有日期
+              dates = [];
+              currentDate = dayjs(startDate);
+              end = dayjs(endDate);
+              while (currentDate.isSameOrBefore(end)) {
+                dates.push(currentDate.format('YYYY-MM-DD'));
+                currentDate = currentDate.add(1, 'day');
+              }
+              // 如果不支持 Web Worker，使用同步方式处理
+              results = {};
+              for (_i = 0, _dates = dates; _i < _dates.length; _i++) {
+                date = _dates[_i];
+                results[date] = this.getTimeslotBySchedule({
+                  date: date,
+                  scheduleIds: scheduleIds,
+                  resources: resources
+                });
+              }
+              return _context29.abrupt("return", results);
+            case 9:
+            case "end":
+              return _context29.stop();
+          }
+        }, _callee28, this);
+      }));
+      function getTimeslotsScheduleByDateRange(_x21) {
+        return _getTimeslotsScheduleByDateRange.apply(this, arguments);
+      }
+      return getTimeslotsScheduleByDateRange;
+    }())
   }, {
     key: "getAvailableDateForSession",
     value: function () {
-      var _getAvailableDateForSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28() {
+      var _getAvailableDateForSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee29() {
         var params,
           startDate,
           endDate,
           type,
           tempProducts,
-          _ref15,
+          _ref16,
           resourceIds,
           rules,
           resourcesMap,
           res,
-          _args29 = arguments;
-        return _regeneratorRuntime().wrap(function _callee28$(_context29) {
-          while (1) switch (_context29.prev = _context29.next) {
+          dateListWithTimeSlots,
+          firstAvailableDate,
+          _args30 = arguments;
+        return _regeneratorRuntime().wrap(function _callee29$(_context30) {
+          while (1) switch (_context30.prev = _context30.next) {
             case 0:
-              params = _args29.length > 0 && _args29[0] !== undefined ? _args29[0] : {};
+              params = _args30.length > 0 && _args30[0] !== undefined ? _args30[0] : {};
               // 开始日期如果小于今天，直接以今天当做开始日期
               startDate = params.startDate, endDate = params.endDate, type = params.type; // 前端传递的 startDate，可能是今天之前的，如果 startDate 小于今天 且 endDate 小于或等于今天，需要把 startDate 置为今天
               if (dayjs(startDate).isBefore(dayjs(), 'day') && (dayjs(endDate).isAfter(dayjs(), 'day') || dayjs(endDate).isSame(dayjs(), 'day'))) {
@@ -2637,9 +2715,9 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                 })];
               }
               // 在这里需要把能收集到的数据都收集上来，拼装好给 date 模块去查询
-              _ref15 = getAvailableProductResources(tempProducts) || {}, resourceIds = _ref15.resourceIds, rules = _ref15.rules, resourcesMap = _ref15.resourcesMap;
+              _ref16 = getAvailableProductResources(tempProducts) || {}, resourceIds = _ref16.resourceIds, rules = _ref16.rules, resourcesMap = _ref16.resourcesMap;
               this.otherParams.currentResourcesMap = resourcesMap;
-              _context29.next = 10;
+              _context30.next = 10;
               return this.store.date.getResourceDates({
                 query: {
                   start_date: startDate || '',
@@ -2650,19 +2728,272 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
                 type: type
               });
             case 10:
-              res = _context29.sent;
-              return _context29.abrupt("return", res);
-            case 12:
+              res = _context30.sent;
+              if (!this.store.currentProduct) {
+                _context30.next = 16;
+                break;
+              }
+              _context30.next = 14;
+              return this.getTimeslotsScheduleByDateRange({
+                startDate: startDate || '',
+                endDate: endDate || ''
+              });
+            case 14:
+              dateListWithTimeSlots = _context30.sent;
+              res.forEach(function (n) {
+                if (!dateListWithTimeSlots[n.date]) {
+                  n.status = 'unavailable';
+                } else {
+                  var allTimeSlotsCanUse = dateListWithTimeSlots[n.date].every(function (d) {
+                    return d.count;
+                  });
+                  if (!allTimeSlotsCanUse) {
+                    n.status = 'unavailable';
+                  }
+                }
+              });
+            case 16:
+              // 找到第一个可用的日期返回给 UI
+              firstAvailableDate = res.find(function (n) {
+                return n.status === 'available';
+              });
+              return _context30.abrupt("return", {
+                dateList: res,
+                firstAvailableDate: firstAvailableDate
+              });
+            case 18:
             case "end":
-              return _context29.stop();
+              return _context30.stop();
           }
-        }, _callee28, this);
+        }, _callee29, this);
       }));
       function getAvailableDateForSession() {
         return _getAvailableDateForSession.apply(this, arguments);
       }
       return getAvailableDateForSession;
     }()
+  }, {
+    key: "getAvailableDateForSessionOptimize",
+    value: function () {
+      var _getAvailableDateForSessionOptimize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee30() {
+        var _this$store$currentPr3, _this$store$currentPr4, _this$store$currentPr5, _tempProducts, _this$store$currentPr6;
+        var params,
+          cache,
+          startDate,
+          endDate,
+          tempProducts,
+          schedule,
+          filteredSchedule,
+          tempResourceIds,
+          res,
+          dates,
+          currentDate,
+          firstAvailableDate,
+          openResources,
+          allProductResources,
+          targetSchedules,
+          _loop3,
+          _args32 = arguments;
+        return _regeneratorRuntime().wrap(function _callee30$(_context32) {
+          while (1) switch (_context32.prev = _context32.next) {
+            case 0:
+              params = _args32.length > 0 && _args32[0] !== undefined ? _args32[0] : {};
+              // 先去读缓存结果，因为正常 UI 调用的是 7 天，而下面我会直接计算 30 天（最少也是 14 天），所以先去读缓存结果，如果缓存结果存在，则直接返回
+              cache = (_this$store$currentPr3 = this.store.currentProduct) === null || _this$store$currentPr3 === void 0 ? void 0 : _this$store$currentPr3.getOtherParams()['timeSlotBySchedule'];
+              if (!cache) {
+                _context32.next = 5;
+                break;
+              }
+              if (!(dayjs(params.startDate).isSameOrAfter(dayjs(cache.startDate), 'day') && dayjs(params.endDate).isSameOrBefore(dayjs(cache.endDate), 'day'))) {
+                _context32.next = 5;
+                break;
+              }
+              return _context32.abrupt("return", {
+                dateList: cache.dateList,
+                firstAvailableDate: cache.firstAvailableDate
+              });
+            case 5:
+              // 开始日期如果小于今天，直接以今天当做开始日期
+              startDate = params.startDate, endDate = params.endDate; // 前端传递的 startDate，可能是今天之前的，如果 startDate 小于今天 且 endDate 小于或等于今天，需要把 startDate 置为今天
+              if (dayjs(startDate).isBefore(dayjs(), 'day') && (dayjs(endDate).isAfter(dayjs(), 'day') || dayjs(endDate).isSame(dayjs(), 'day'))) {
+                startDate = dayjs().format('YYYY-MM-DD');
+              }
+              // 不管前端传什么 endDate 默认查一个月的，以今天为开始日期。用于找到一个月内最近可用的日期
+              endDate = dayjs().add(1, 'month').format('YYYY-MM-DD');
+              // 如果当前打开了某个的商品详情弹窗，则应该默认用这个商品
+              tempProducts = (_this$store$currentPr4 = this.store.currentProduct) === null || _this$store$currentPr4 === void 0 ? void 0 : _this$store$currentPr4.getData();
+              schedule = (_this$store$currentPr5 = this.store.currentProduct) === null || _this$store$currentPr5 === void 0 ? void 0 : _this$store$currentPr5.getOtherParams()['schedule'];
+              filteredSchedule = filterScheduleByDateRange(schedule, startDate || '', endDate || ''); // 1.后端返回的数据，确定资源在每一天的可用和使用情况
+              tempResourceIds = getResourcesIdsByProduct(tempProducts);
+              _context32.next = 14;
+              return this.store.date.fetchResourceDates({
+                query: {
+                  start_date: startDate || '',
+                  end_date: endDate || '',
+                  resource_ids: tempResourceIds
+                }
+              });
+            case 14:
+              res = _context32.sent;
+              // 2. 商品 schedule 数据，确定日程在每一天的时间片
+              // 3. 把后端返回的和 schedule 的数据进行合并，确定每一天的可用和使用情况
+              dates = [];
+              currentDate = dayjs(startDate);
+              firstAvailableDate = ''; // 预处理，获取商品下启用的资源类型，后面只需要遍历这些资源的资源列表即可
+              openResources = ((_tempProducts = tempProducts) === null || _tempProducts === void 0 || (_tempProducts = _tempProducts.product_resource) === null || _tempProducts === void 0 || (_tempProducts = _tempProducts.resources) === null || _tempProducts === void 0 ? void 0 : _tempProducts.filter(function (m) {
+                return m.status === 1;
+              })) || []; // res.data 返回的一定是启用商品的资源列表，不需要再过滤了
+              allProductResources = sortCombinedResources(res.data);
+              targetSchedules = this.store.schedule.getScheduleListByIds(tempProducts['schedule.ids']);
+              _loop3 = /*#__PURE__*/_regeneratorRuntime().mark(function _loop3() {
+                var currentDateStr, status, _checkSessionProductL, latestStartDate, earliestEndDate, scheduleByDate, minTimeMaxTime, scheduleTimeSlots, timesSlotCanUse;
+                return _regeneratorRuntime().wrap(function _loop3$(_context31) {
+                  while (1) switch (_context31.prev = _context31.next) {
+                    case 0:
+                      currentDateStr = currentDate.format('YYYY-MM-DD');
+                      status = 'available'; // 1. 检查商品的提前量等情况是否满足
+                      _checkSessionProductL = checkSessionProductLeadTime(tempProducts), latestStartDate = _checkSessionProductL.latestStartDate, earliestEndDate = _checkSessionProductL.earliestEndDate;
+                      if (latestStartDate || earliestEndDate) {
+                        // 如果时间在最早开始时间之前，则设置为不可用
+                        if (latestStartDate && dayjs(currentDate).isBefore(latestStartDate, 'day')) {
+                          status = 'unavailable';
+                        }
+                        // 如果时间在最早结束时间之后，则设置为不可用
+                        if (earliestEndDate && dayjs(currentDate).isAfter(earliestEndDate, 'day')) {
+                          status = 'unavailable';
+                        }
+                      }
+                      // 2. 检查 schedule 数据，确定 schedule 里没有这一天，或者这一天的isExcluded: true ，则不可用
+                      if (status === 'available') {
+                        scheduleByDate = filteredSchedule.find(function (n) {
+                          return n.date === currentDateStr;
+                        });
+                        if (!scheduleByDate || scheduleByDate !== null && scheduleByDate !== void 0 && scheduleByDate.isExcluded) {
+                          status = 'unavailable';
+                        }
+                      }
+
+                      // 3. 检查这一天的 schedule 时间片里资源是否有可用的，每个时间片下每种资源只需找到第一个可用的即可
+                      if (status === 'available') {
+                        minTimeMaxTime = calcMinTimeMaxTimeBySchedules(targetSchedules, {}, currentDateStr);
+                        scheduleTimeSlots = getAllSortedDateRanges(minTimeMaxTime); // 同一天内多个时间片下 只要有一个可用则视为可用
+                        timesSlotCanUse = scheduleTimeSlots.some(function (item) {
+                          // 用来计算资源的可使用情况，针对单个schedule 时间片
+                          var resourcesUseableMap = {};
+                          // 遍历产品下启用的资源
+                          // 必须要保证每种类型的资源都至少有一个能够在对应时间点被选择
+                          return openResources.every(function (resource) {
+                            // 获取当前资源类型的资源列表
+                            var currentResourcesList = allProductResources.filter(function (n) {
+                              return n.form_id === resource.resource_type_id;
+                            });
+                            return currentResourcesList === null || currentResourcesList === void 0 ? void 0 : currentResourcesList.some(function (m) {
+                              // 遍历所有资源的上工时间片
+                              // m.times 需要做个过滤，假设 timeSlice.start_at 是 09:30 timeSlice.end_at 是 11:30
+                              // time 是 time.start_at = 2025-05-26 10:30, time.end_at = 2025-05-26 12:30
+                              // 需要判断 time 的开始结束时间 是否包含timeSlice的开始结束时间
+                              var mTimes = m.times.filter(function (n) {
+                                return !dayjs(n.start_at).isAfter(dayjs(item.start), 'minute') && !dayjs(n.end_at).isBefore(dayjs(item.end), 'minute');
+                              });
+                              // 如果在这个区间的时间一个都没有，可以直接认为这个资源不可用
+                              if (mTimes.length === 0) {
+                                return;
+                              }
+                              var targetCanUseTimes = mTimes.some(function (childTiem) {
+                                var _tempProducts2;
+                                // 挨个去匹配某个工作时间段结合当前日程时间，资源能不能用，有多少容量能用
+                                var res = getIsUsableByTimeItem({
+                                  timeSlice: {
+                                    start_time: item.start,
+                                    end_time: item.end,
+                                    start_at: dayjs(item.start),
+                                    end_at: dayjs(item.end)
+                                  },
+                                  time: childTiem,
+                                  resource: m,
+                                  currentCount: 1,
+                                  resourcesUseableMap: resourcesUseableMap,
+                                  cut_off_time: (_tempProducts2 = tempProducts) === null || _tempProducts2 === void 0 ? void 0 : _tempProducts2.cut_off_time
+                                });
+                                if ((resourcesUseableMap === null || resourcesUseableMap === void 0 ? void 0 : resourcesUseableMap[m.id]) !== false && res.reason !== 'capacityOnly') {
+                                  resourcesUseableMap[m.id] = res.usable;
+                                }
+                                return res.usable && !m.onlyComputed;
+                              });
+                              return targetCanUseTimes;
+                            });
+                          });
+                        });
+                        if (!timesSlotCanUse) {
+                          status = 'unavailable';
+                        }
+                        if (status === 'available' && !firstAvailableDate) {
+                          firstAvailableDate = currentDateStr;
+                        }
+                      }
+                      dates.push({
+                        date: dayjs(currentDate).format('YYYY-MM-DD'),
+                        week: dayjs(currentDate).format('ddd'),
+                        weekNum: dayjs(currentDate).day(),
+                        status: status
+                      });
+
+                      // 如果 firstAvailableDate 距离 startDate 大于 14 天了，则后面就不需要再找了，也是一种性能保护
+                      if (!(firstAvailableDate && dayjs(currentDate).diff(dayjs(startDate), 'day') > 14)) {
+                        _context31.next = 9;
+                        break;
+                      }
+                      return _context31.abrupt("return", 1);
+                    case 9:
+                      currentDate = dayjs(currentDate).add(1, 'day');
+                    case 10:
+                    case "end":
+                      return _context31.stop();
+                  }
+                }, _loop3);
+              });
+            case 22:
+              if (!(dayjs(currentDate).isBefore(dayjs(endDate), 'day') || dayjs(currentDate).isSame(dayjs(endDate), 'day'))) {
+                _context32.next = 28;
+                break;
+              }
+              return _context32.delegateYield(_loop3(), "t0", 24);
+            case 24:
+              if (!_context32.t0) {
+                _context32.next = 26;
+                break;
+              }
+              return _context32.abrupt("break", 28);
+            case 26:
+              _context32.next = 22;
+              break;
+            case 28:
+              // 最终把资源数据也加到日期内
+              dates = handleAvailableDateByResource(res.data, dates);
+              this.store.date.setDateList(dates);
+
+              // 缓存这次结果，以防后面他小幅度范围内去修改天数
+              (_this$store$currentPr6 = this.store.currentProduct) === null || _this$store$currentPr6 === void 0 || _this$store$currentPr6.setOtherParams('timeSlotBySchedule', {
+                dateList: dates,
+                firstAvailableDate: firstAvailableDate,
+                startDate: startDate,
+                endDate: endDate
+              });
+              return _context32.abrupt("return", {
+                dateList: dates,
+                firstAvailableDate: firstAvailableDate
+              });
+            case 32:
+            case "end":
+              return _context32.stop();
+          }
+        }, _callee30, this);
+      }));
+      function getAvailableDateForSessionOptimize() {
+        return _getAvailableDateForSessionOptimize.apply(this, arguments);
+      }
+      return getAvailableDateForSessionOptimize;
+    }()
   }]);
   return BookingByStepImpl;
 }(BaseModule);

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

@@ -1,5 +1,5 @@
 import { Dayjs } from 'dayjs';
-import { CartItem } from '../../../modules';
+import { CartItem, ProductData } from '../../../modules';
 /**
  * 1. 获取资源列表
  * 2. 根据当前选择的商品过滤出来对应的资源列表  getResourcesByProduct
@@ -79,7 +79,7 @@ export declare const formatResources: ({ booking, resources, }: {
  * @return {*}
  * @Author: zhiwei.Wang
  */
-export declare const getTimeSlicesByResource: ({ resource, duration, split, currentDate, capacity, resourcesUseableMap, cut_off_time }: {
+export declare const getTimeSlicesByResource: ({ resource, duration, split, currentDate, capacity, resourcesUseableMap, cut_off_time, }: {
     resource: ResourceItem;
     duration: number;
     split: number;
@@ -133,7 +133,7 @@ export declare const mergeSubResourcesTimeSlices: (resources: ResourceItem[], re
  * @return {*}
  * @Author: zhiwei.Wang
  */
-export declare const getTimeSlicesByResources: ({ resourceIds, resourcesMap, duration, currentDate, split, capacity, resourcesUseableMap, cut_off_time }: {
+export declare const getTimeSlicesByResources: ({ resourceIds, resourcesMap, duration, currentDate, split, capacity, resourcesUseableMap, cut_off_time, }: {
     resourceIds: number[];
     resourcesMap: any;
     duration: number;
@@ -201,4 +201,41 @@ export declare const getSumCapacity: ({ capacity }: {
  * @Author: jinglin.tan
  */
 export declare const checkSubResourcesCapacity: (resource: ResourceItem) => void;
+/**
+ * @title: 根据日期范围过滤日程
+ *
+ * @export
+ * @param {any[]} schedule
+ * @param {string} startDate
+ * @param {string} endDate
+ * @return {*}
+ */
+export declare function filterScheduleByDateRange(schedule: any[], startDate: string, endDate: string): any[];
+/**
+ * 传入商品数据，返回基于商品配置的提前量的最早开始日期和最晚结束日期
+ *
+ * @export
+ * @param {ProductData} product
+ * @return {*}
+ */
+export declare function checkSessionProductLeadTime(product: ProductData): {
+    latestStartDate: string;
+    earliestEndDate: string;
+};
+/**
+ * 基于商品的 resources 配置，返回可选择的资源的 id 列表
+ *
+ * @export
+ * @param {ProductData} product
+ * @return {*}
+ */
+export declare function getResourcesIdsByProduct(product: ProductData): number[];
+/**
+ * 资源排序，把单个资源靠前，组合资源排在后面
+ *
+ * @export
+ * @param {ResourceItem[]} resourcesList
+ * @return {*}
+ */
+export declare function sortCombinedResources(resourcesList: ResourceItem[]): ResourceItem[];
 export {};