@pisell/pisellos 0.0.106 → 0.0.108

package/dist/modules/Date/index.d.ts

@@ -15,6 +15,7 @@ export declare class DateModule extends BaseModule implements Module, DateModule
     getDateRange(): ITime[];
     getResourceDates(params: IGetAvailableTimeListParams): Promise<ITime[]>;
     getDateList(): ITime[];
+    fetchResourceDates(params: IGetAvailableTimeListParams): Promise<any>;
     getResourceAvailableTimeList(params: IGetAvailableTimeListParams): Promise<ITime[]>;
     clearDateRange(): void;
     storeChange(): void;

package/dist/modules/Date/index.js

@@ -113,32 +113,18 @@ export var DateModule = /*#__PURE__*/function (_BaseModule) {
       return this.store.dateList;
     }
   }, {
-    key: "getResourceAvailableTimeList",
+    key: "fetchResourceDates",
     value: function () {
-      var _getResourceAvailableTimeList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
-        var url, query, rules, type, fetchUrl, _ref, start_date, end_date, resource_ids, dates, _res$data, res;
+      var _fetchResourceDates = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(params) {
+        var url, query, fetchUrl, _ref, start_date, end_date, resource_ids, res;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
-              url = params.url, query = params.query, rules = params.rules, type = params.type;
+              url = params.url, query = params.query;
               fetchUrl = url || '/schedule/resource/list';
               _ref = query || {}, start_date = _ref.start_date, end_date = _ref.end_date, resource_ids = _ref.resource_ids;
-              if (!(!start_date || !end_date)) {
-                _context3.next = 5;
-                break;
-              }
-              return _context3.abrupt("return", []);
-            case 5:
-              // 1.生成当前月份的所有日期，默认都是可用的
-              dates = generateMonthDates(start_date, end_date, type); // 如果没有资源或者结束日期在今天之前，则所有日期均不可用
-              if (resource_ids !== null && resource_ids !== void 0 && resource_ids.length) {
-                _context3.next = 8;
-                break;
-              }
-              return _context3.abrupt("return", disableAllDates(dates));
-            case 8:
-              _context3.prev = 8;
-              _context3.next = 11;
+              _context3.prev = 3;
+              _context3.next = 6;
               return this.request.get(fetchUrl, {
                 start_date: start_date,
                 end_date: end_date,
@@ -147,14 +133,59 @@ export var DateModule = /*#__PURE__*/function (_BaseModule) {
               }, {
                 useCache: true
               });
-            case 11:
+            case 6:
               res = _context3.sent;
+              return _context3.abrupt("return", res);
+            case 10:
+              _context3.prev = 10;
+              _context3.t0 = _context3["catch"](3);
+              console.error(_context3.t0);
+            case 13:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this, [[3, 10]]);
+      }));
+      function fetchResourceDates(_x4) {
+        return _fetchResourceDates.apply(this, arguments);
+      }
+      return fetchResourceDates;
+    }()
+  }, {
+    key: "getResourceAvailableTimeList",
+    value: function () {
+      var _getResourceAvailableTimeList = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(params) {
+        var query, rules, type, _ref2, start_date, end_date, resource_ids, dates, _res$data, res;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              query = params.query, rules = params.rules, type = params.type;
+              _ref2 = query || {}, start_date = _ref2.start_date, end_date = _ref2.end_date, resource_ids = _ref2.resource_ids;
+              if (!(!start_date || !end_date)) {
+                _context4.next = 4;
+                break;
+              }
+              return _context4.abrupt("return", []);
+            case 4:
+              // 1.生成当前月份的所有日期，默认都是可用的
+              dates = generateMonthDates(start_date, end_date, type); // 如果没有资源或者结束日期在今天之前，则所有日期均不可用
+              if (resource_ids !== null && resource_ids !== void 0 && resource_ids.length) {
+                _context4.next = 7;
+                break;
+              }
+              return _context4.abrupt("return", disableAllDates(dates));
+            case 7:
+              _context4.prev = 7;
+              _context4.next = 10;
+              return this.fetchResourceDates(params);
+            case 10:
+              res = _context4.sent;
               if (res !== null && res !== void 0 && (_res$data = res.data) !== null && _res$data !== void 0 && _res$data.length) {
-                _context3.next = 14;
+                _context4.next = 13;
                 break;
               }
-              return _context3.abrupt("return", disableAllDates(dates));
-            case 14:
+              return _context4.abrupt("return", disableAllDates(dates));
+            case 13:
               // 2.根据资源times判定哪些日期内存在可用资源
               dates = handleAvailableDateByResource(res.data, dates);
 
@@ -162,19 +193,19 @@ export var DateModule = /*#__PURE__*/function (_BaseModule) {
               if (rules !== null && rules !== void 0 && rules.length) {
                 dates = handleAvailableDatesByRules(dates, rules);
               }
-              return _context3.abrupt("return", dates);
-            case 19:
-              _context3.prev = 19;
-              _context3.t0 = _context3["catch"](8);
-              console.log('getAvailableTimeList_error', _context3.t0);
-              return _context3.abrupt("return", disableAllDates(dates));
-            case 23:
+              return _context4.abrupt("return", dates);
+            case 18:
+              _context4.prev = 18;
+              _context4.t0 = _context4["catch"](7);
+              console.log('getAvailableTimeList_error', _context4.t0);
+              return _context4.abrupt("return", disableAllDates(dates));
+            case 22:
             case "end":
-              return _context3.stop();
+              return _context4.stop();
           }
-        }, _callee3, this, [[8, 19]]);
+        }, _callee4, this, [[7, 18]]);
       }));
-      function getResourceAvailableTimeList(_x4) {
+      function getResourceAvailableTimeList(_x5) {
         return _getResourceAvailableTimeList.apply(this, arguments);
       }
       return getResourceAvailableTimeList;

package/dist/modules/Order/index.js

@@ -76,7 +76,6 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
       var is_deposit = 0; // 是否存在定金，0 不存在，1 存在
       if (params.cartItems.length > 0) {
         params.cartItems.forEach(function (item) {
-          var _item$_productOrigin;
           if (!item._origin.duration) {
             var _generateDuration = generateDuration(item),
               duration = _generateDuration.duration,
@@ -84,8 +83,8 @@ export var OrderModule = /*#__PURE__*/function (_BaseModule) {
             item._origin.duration = duration;
             item._origin.sub_type = durationType;
           }
-          // 如果 item.extension_type === normal，视为普通商品
-          if (((_item$_productOrigin = item._productOrigin) === null || _item$_productOrigin === void 0 ? void 0 : _item$_productOrigin.extension_type) === 'normal') {
+          // 零售都视为普通商品
+          if (order.type === 'virtual') {
             var _order$relation_forms;
             order.relation_products.push(item._origin.product);
             var relationForms = item._origin.relation_forms || [];

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

@@ -5,7 +5,7 @@ import { BookingByStepState } from './types';
 import { CartItem, IUpdateItemParams, ProductData, ProductResourceItem, ECartItemInfoType, ECartItemCheckType } from '../../modules';
 import { Account } from '../../modules/Account/types';
 import { IStep } from '../../modules/Step/tyeps';
-import { TimeSliceItem } from './utils/resources';
+import { TimeSliceItem, ResourceItem } from './utils/resources';
 import { ITime } from '../../modules/Date/types';
 import dayjs from 'dayjs';
 import { IHolder, IFetchHolderAccountsParams } from '../../modules/AccountList/types';
@@ -153,7 +153,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         id: number | undefined;
         _id: string;
         product: ProductData | undefined;
-        resources: import("./utils/resources").ResourceItem[];
+        resources: ResourceItem[];
         holder_id: string | number | undefined;
         holder_name: string | undefined;
     } | undefined;
@@ -189,7 +189,7 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
     private getScheduleDataByIds;
     openProductDetail(productId: number): Promise<void>;
     closeProductDetail(): void;
-    getTimeslotBySchedule({ date, scheduleIds, resources, product }: {
+    getTimeslotBySchedule({ date, scheduleIds, resources, product, }: {
         date: string;
         scheduleIds?: number[];
         resources?: ProductResourceItem[];
@@ -221,9 +221,11 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
      * @memberof BookingByStepImpl
      */
     getResourcesByCartItemAndCode(cartItemId: string, resourceCode: string): any;
-    getAvailableDateForSession(params?: {
+    getAvailableDateForSessionOptimize(params?: {
         startDate?: string;
         endDate?: string;
-        type?: 'month';
-    }): Promise<ITime[]>;
+    }): Promise<{
+        dateList: any;
+        firstAvailableDate: any;
+    }>;
 }

package/dist/solution/BookingByStep/index.js

@@ -27,8 +27,12 @@ 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";
@@ -321,7 +325,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 +417,6 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
               _iterator.f();
               return _context5.finish(21);
             case 24:
-              ;
-            case 25:
             case "end":
               return _context5.stop();
           }
@@ -2330,7 +2332,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 +2502,7 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
      *
      * @param {string} cartItemId
      * @param {string} resourceCode
-     * @return {*} 
+     * @return {*}
      * @memberof BookingByStepImpl
      */
   }, {
@@ -2605,63 +2606,222 @@ export var BookingByStepImpl = /*#__PURE__*/function (_BaseModule) {
       return targetResource.renderList;
     }
   }, {
-    key: "getAvailableDateForSession",
+    key: "getAvailableDateForSessionOptimize",
     value: function () {
-      var _getAvailableDateForSession = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28() {
+      var _getAvailableDateForSessionOptimize = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee28() {
+        var _this$store$currentPr3, _this$store$currentPr4, _this$store$currentPr5, _tempProducts, _this$store$currentPr6;
         var params,
+          cache,
           startDate,
           endDate,
-          type,
           tempProducts,
-          _ref15,
-          resourceIds,
-          rules,
-          resourcesMap,
+          schedule,
+          filteredSchedule,
+          tempResourceIds,
           res,
-          _args29 = arguments;
-        return _regeneratorRuntime().wrap(function _callee28$(_context29) {
-          while (1) switch (_context29.prev = _context29.next) {
+          dates,
+          currentDate,
+          firstAvailableDate,
+          openResources,
+          allProductResources,
+          targetSchedules,
+          _loop3,
+          _args30 = arguments;
+        return _regeneratorRuntime().wrap(function _callee28$(_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] : {};
+              // 先去读缓存结果，因为正常 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) {
+                _context30.next = 5;
+                break;
+              }
+              if (!(dayjs(params.startDate).isSameOrAfter(dayjs(cache.startDate), 'day') && dayjs(params.endDate).isSameOrBefore(dayjs(cache.endDate), 'day'))) {
+                _context30.next = 5;
+                break;
+              }
+              return _context30.abrupt("return", {
+                dateList: cache.dateList,
+                firstAvailableDate: cache.firstAvailableDate
+              });
+            case 5:
               // 开始日期如果小于今天，直接以今天当做开始日期
-              startDate = params.startDate, endDate = params.endDate, type = params.type; // 前端传递的 startDate，可能是今天之前的，如果 startDate 小于今天 且 endDate 小于或等于今天，需要把 startDate 置为今天
+              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 = []; // 如果当前打开了某个的商品详情弹窗，则应该默认用这个商品
-              if (this.store.currentProduct) {
-                tempProducts = [_objectSpread(_objectSpread({}, this.store.currentProduct.getData()), {}, {
-                  _schedule: this.store.currentProduct.getOtherParams()['schedule']
-                })];
-              }
-              // 在这里需要把能收集到的数据都收集上来，拼装好给 date 模块去查询
-              _ref15 = getAvailableProductResources(tempProducts) || {}, resourceIds = _ref15.resourceIds, rules = _ref15.rules, resourcesMap = _ref15.resourcesMap;
-              this.otherParams.currentResourcesMap = resourcesMap;
-              _context29.next = 10;
-              return this.store.date.getResourceDates({
+              // 如果当前打开了某个的商品详情弹窗，则应该默认用这个商品
+              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);
+              _context30.next = 14;
+              return this.store.date.fetchResourceDates({
                 query: {
                   start_date: startDate || '',
                   end_date: endDate || '',
-                  resource_ids: resourceIds
-                },
-                rules: rules,
-                type: type
+                  resource_ids: tempResourceIds
+                }
               });
-            case 10:
-              res = _context29.sent;
-              return _context29.abrupt("return", res);
-            case 12:
+            case 14:
+              res = _context30.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$(_context29) {
+                  while (1) switch (_context29.prev = _context29.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)) {
+                        _context29.next = 9;
+                        break;
+                      }
+                      return _context29.abrupt("return", 1);
+                    case 9:
+                      currentDate = dayjs(currentDate).add(1, 'day');
+                    case 10:
+                    case "end":
+                      return _context29.stop();
+                  }
+                }, _loop3);
+              });
+            case 22:
+              if (!(dayjs(currentDate).isBefore(dayjs(endDate), 'day') || dayjs(currentDate).isSame(dayjs(endDate), 'day'))) {
+                _context30.next = 28;
+                break;
+              }
+              return _context30.delegateYield(_loop3(), "t0", 24);
+            case 24:
+              if (!_context30.t0) {
+                _context30.next = 26;
+                break;
+              }
+              return _context30.abrupt("break", 28);
+            case 26:
+              _context30.next = 22;
+              break;
+            case 28:
+              // 缓存这次结果，以防后面他小幅度范围内去修改天数
+              (_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 _context30.abrupt("return", {
+                dateList: dates,
+                firstAvailableDate: firstAvailableDate
+              });
+            case 30:
             case "end":
-              return _context29.stop();
+              return _context30.stop();
           }
         }, _callee28, this);
       }));
-      function getAvailableDateForSession() {
-        return _getAvailableDateForSession.apply(this, arguments);
+      function getAvailableDateForSessionOptimize() {
+        return _getAvailableDateForSessionOptimize.apply(this, arguments);
       }
-      return getAvailableDateForSession;
+      return getAvailableDateForSessionOptimize;
     }()
   }]);
   return BookingByStepImpl;

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 {};