@pisell/pisellos 0.0.569 → 0.10.2

package/lib/solution/BookingByStep/index.js

@@ -1,84 +1,115 @@
-"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/index.ts
+var BookingByStep_exports = {};
+__export(BookingByStep_exports, {
+  BookingByStepImpl: () => BookingByStepImpl
 });
-exports.BookingByStepImpl = void 0;
-var _BaseModule = require("../../modules/BaseModule");
-var _types = require("./types");
-var _utils = require("../../modules/Cart/utils");
-var _products = require("./utils/products");
-var _resources = require("./utils/resources");
-var _dayjs = _interopRequireDefault(require("dayjs"));
-var _isSameOrBefore = _interopRequireDefault(require("dayjs/plugin/isSameOrBefore"));
-var _isSameOrAfter = _interopRequireDefault(require("dayjs/plugin/isSameOrAfter"));
-var _utils2 = require("../../modules/Resource/utils");
-var _lodashEs = require("lodash-es");
-var _utils3 = require("../../modules/Schedule/utils");
-var _utils4 = require("../../modules/Date/utils");
-var _utils5 = require("../../modules/Product/utils");
-var _timeslots = require("./utils/timeslots");
-var _changePrice = require("../../modules/Cart/utils/changePrice");
-var _capacity = require("./utils/capacity");
-var _stock = require("./utils/stock");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-_dayjs.default.extend(_isSameOrBefore.default);
-_dayjs.default.extend(_isSameOrAfter.default);
-class BookingByStepImpl extends _BaseModule.BaseModule {
-  defaultName = 'bookingByStep';
-  defaultVersion = '1.0.0';
-  isSolution = true;
-  request;
-  window;
-  shopStore;
-  store;
-  otherParams = {};
-  cacheId;
-  otherData = {}; // 提供给 UI 层的临时数据存储，会进缓存
-  platform; // 平台类型，用于判断是 PC / H5
-
+module.exports = __toCommonJS(BookingByStep_exports);
+var import_BaseModule = require("../../modules/BaseModule");
+var import_types = require("./types");
+var import_utils = require("../../modules/Cart/utils");
+var import_products = require("./utils/products");
+var import_resources = require("./utils/resources");
+var import_dayjs = __toESM(require("dayjs"));
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
+var import_utils2 = require("../../modules/Resource/utils");
+var import_lodash_es = require("lodash-es");
+var import_utils3 = require("../../modules/Schedule/utils");
+var import_utils4 = require("../../modules/Date/utils");
+var import_utils5 = require("../../modules/Product/utils");
+var import_timeslots = require("./utils/timeslots");
+var import_changePrice = require("../../modules/Cart/utils/changePrice");
+var import_capacity = require("./utils/capacity");
+var import_stock = require("./utils/stock");
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+var BookingByStepImpl = class extends import_BaseModule.BaseModule {
+  constructor() {
+    super(...arguments);
+    this.defaultName = "bookingByStep";
+    this.defaultVersion = "1.0.0";
+    this.isSolution = true;
+    this.otherParams = {};
+    this.otherData = {};
+  }
+  // 平台类型，用于判断是 PC / H5
   async initialize(core, options) {
+    var _a, _b, _c, _d, _e;
     this.core = core;
     this.store = options.store || {};
     this.otherParams = options.otherParams || {};
-    // 获取依赖的插件
-    this.request = core.getPlugin('request');
-    this.window = core.getPlugin('window');
-    this.shopStore = core.getPlugin('shopStore');
+    console.log("[BookingByStep] 初始化完成");
+    this.request = core.getPlugin("request");
+    this.window = core.getPlugin("window");
+    this.shopStore = core.getPlugin("shopStore");
     if (!this.request) {
-      throw new Error('bookingByStep解决方案需要 request 插件支持');
+      throw new Error("bookingByStep解决方案需要 request 插件支持");
     }
     if (!this.shopStore) {
-      throw new Error('SummaryModule 需要 shopStore 插件支持');
+      throw new Error("SummaryModule 需要 shopStore 插件支持");
     }
-
-    // 如果有传 cacheid，默认需要收集上面这些模块里用户操作选中的数据
-    // 并且在上面 registerModule 的时候，读取 sessionStroage 里的数据，塞进默认值
     let targetCacheData = {};
-    this.cacheId = this.otherParams?.cacheId;
-    this.platform = this.otherParams?.platform;
-    if (this.otherParams?.cacheId) {
+    this.cacheId = (_a = this.otherParams) == null ? void 0 : _a.cacheId;
+    this.platform = (_b = this.otherParams) == null ? void 0 : _b.platform;
+    if ((_c = this.otherParams) == null ? void 0 : _c.cacheId) {
       const sessionData = this.window.sessionStorage.getItem(this.name);
       if (sessionData) {
         const data = JSON.parse(sessionData);
-        // 匹配 cacheid，如果匹配不到，直接把 sessionData 清掉即可
-        // 如果匹配到了，则把 sessionData 里的数据按模块塞到 store 里去
         targetCacheData = data[this.otherParams.cacheId];
-        this.otherData = data[this.otherParams.cacheId]?.[this.name]?.['otherData'] || {};
+        this.otherData = ((_e = (_d = data[this.otherParams.cacheId]) == null ? void 0 : _d[this.name]) == null ? void 0 : _e["otherData"]) || {};
       }
     }
-    const moduleArr = ['accountList', 'holder', 'cart', 'schedule', 'summary', 'step', 'products', 'date', 'order'];
-    moduleArr.forEach(step => {
-      const targetModule = (0, _types.createModule)(step, this.name);
+    const moduleArr = [
+      "accountList",
+      "holder",
+      "cart",
+      "schedule",
+      "summary",
+      "step",
+      "products",
+      "date",
+      "order"
+    ];
+    moduleArr.forEach((step) => {
+      var _a2, _b2;
+      const targetModule = (0, import_types.createModule)(step, this.name);
       if (targetModule) {
         this.store[step] = targetModule;
         this.core.registerModule(targetModule, {
-          initialState: targetCacheData?.[targetModule.name],
+          initialState: targetCacheData == null ? void 0 : targetCacheData[targetModule.name],
           otherParams: {
             ...this.otherParams,
             fatherModule: this.name,
-            openCache: this.otherParams?.cacheId ? true : false,
-            cacheId: this.otherParams?.cacheId
+            openCache: ((_a2 = this.otherParams) == null ? void 0 : _a2.cacheId) ? true : false,
+            cacheId: (_b2 = this.otherParams) == null ? void 0 : _b2.cacheId
           }
         });
       } else {
@@ -98,7 +129,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       step: this.store.step.getCurrentStep()
     };
   }
-
   // step: 下一个
   next() {
     this.store.step.nextStep();
@@ -107,38 +137,32 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
   back() {
     this.store.step.prevStep();
   }
-
   // 跳转到指定步骤
   gotoStep(index) {
     this.store.step.gotoStep(index);
   }
-
   // 获取所有step
   getStepList() {
     return this.store.step.getStepList();
   }
-
   /**
    * 添加step
    */
   addStep(step, key) {
     this.store.step.addStep(step, key);
   }
-
   /**
    * 删除step
    */
   removeStep(key) {
     this.store.step.removeStep(key);
   }
-
   /**
    * 更新step
    */
   updateStep(key, step) {
     this.store.step.updateStep(key, step);
   }
-
   /**
    *
    * 加载商品，然后导到商品列表里去
@@ -169,15 +193,13 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       schedule_date,
       cacheId: this.cacheId
     });
-    // 预拉取当天的资源数据
     this.getAvailableDate({
-      startDate: schedule_date || (0, _dayjs.default)().format('YYYY-MM-DD'),
-      endDate: schedule_date || (0, _dayjs.default)().format('YYYY-MM-DD'),
+      startDate: schedule_date || (0, import_dayjs.default)().format("YYYY-MM-DD"),
+      endDate: schedule_date || (0, import_dayjs.default)().format("YYYY-MM-DD"),
       products: [...res]
     });
     return res;
   }
-
   /**
    * 通过 schedule 来读取商品，适用于 session 类商品
    *
@@ -198,40 +220,21 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     product_ids = [],
     category_ids = []
   }) {
+    var _a;
     const scheduleList = this.store.schedule.getAvailabilityScheduleDateList();
-    // 缓存下这次选择的结果，如果是先选日期再选 duration 类商品，后面用得到
-    this.setDateRange([{
-      date,
-      status: 'available',
-      week: '',
-      weekNum: 0
-    }, {
-      date,
-      status: 'available',
-      week: '',
-      weekNum: 0
-    }]);
+    this.setDateRange([
+      { date, status: "available", week: "", weekNum: 0 },
+      { date, status: "available", week: "", weekNum: 0 }
+    ]);
     let newProductIds = [];
-    // const scheduleIds = scheduleList
-    //   .filter((n) => n.date === date)
-    //   .flatMap((n) => n.schedule_id)
-    //   .filter((n) => n !== null && n !== undefined);
-
-    // 如果外面没传 product_ids，尝试从对应 schedule 里拿 product_ids
-    // if (!product_ids?.length) {
-    //   const schedule = scheduleList.find((n) => n.date === date);
-    //   if (schedule && schedule.product_ids?.length) {
-    //     product_ids = schedule.product_ids;
-    //   }
-    // }
-    // V2接口修改后，只能从schedule 接口里拿数据，不可以从外面拿，外面给的是装修数据
-    const schedule = scheduleList.find(n => n.date === date);
-    if (schedule && schedule.product_ids?.length) {
+    const schedule = scheduleList.find((n) => n.date === date);
+    if (schedule && ((_a = schedule.product_ids) == null ? void 0 : _a.length)) {
       newProductIds = schedule.product_ids;
     }
-    // 尝试去拿schedule 里的 other_product_ids 和 product_ids 拼在一起去重
     const otherProductsIds = this.store.schedule.getOtherProductsIds() || [];
-    const allProductIds = [...newProductIds, ...otherProductsIds].filter((n, index, self) => self.indexOf(n) === index);
+    const allProductIds = [...newProductIds, ...otherProductsIds].filter(
+      (n, index, self) => self.indexOf(n) === index
+    );
     const res = await this.loadProducts({
       product_ids: allProductIds,
       category_ids,
@@ -239,7 +242,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     });
     return res;
   }
-
   /**
    * 更新完商品数据、切换日期、或者在较后的流程里登录了，检测当前购物车里是否有商品，如果有，则需要更新购物车里的商品价格
    *
@@ -247,25 +249,34 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    * @memberof BookingByStepImpl
    */
   async updateQuotationPriceAndCart(date) {
+    var _a;
     const cartItems = this.store.cart.getItems();
     if (cartItems.length) {
-      let userPlugin = this.core.getPlugin('user');
-      let customer_id = undefined;
+      let userPlugin = this.core.getPlugin("user");
+      let customer_id = void 0;
       try {
-        customer_id = userPlugin?.get()?.id;
+        customer_id = (_a = userPlugin == null ? void 0 : userPlugin.get()) == null ? void 0 : _a.id;
       } catch (error) {
         console.error(error);
       }
       const res = await this.store.products.loadProductsPrice({
-        ids: cartItems.map(n => n.id),
+        ids: cartItems.map((n) => n.id),
         schedule_date: date,
         customer_id
       });
-      await (0, _changePrice.updateAllCartItemPrice)(cartItems, res, id => this.store.products.getProduct(id), params => this.store.cart.updateItem(params), params => this.store.cart.updateItemInitInfo(params));
-      this.core.effects.emit(`${this.store.cart.name}:onUpdateQuotationPrice`, {});
+      await (0, import_changePrice.updateAllCartItemPrice)(
+        cartItems,
+        res,
+        (id) => this.store.products.getProduct(id),
+        (params) => this.store.cart.updateItem(params),
+        (params) => this.store.cart.updateItemInitInfo(params)
+      );
+      this.core.effects.emit(
+        `${this.store.cart.name}:onUpdateQuotationPrice`,
+        {}
+      );
     }
   }
-
   /**
    * ui 层提供日期的起始范围，返回一个起始范围内日期的可用情况
    * 适用于先选日期的流程，确定日期是否可用
@@ -292,36 +303,36 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       channel
     });
   }
-
   // 添加单个账户或者 guest
   async addAccount(account, extra) {
-    // 如果是holder类型的需要先做数据转换
-    if (extra?.type === 'holder') {
+    if ((extra == null ? void 0 : extra.type) === "holder") {
       const accountModules = await this.store.accountList.addHolderAccounts({
         holders: [account],
         customerId: extra.customerId,
-        type: 'unshift'
+        type: "unshift"
       });
       return accountModules[0].getAccount();
     }
-    const newAccount = await this.store.accountList.addAccount(account);
+    const newAccount = await this.store.accountList.addAccount(
+      account
+    );
     return newAccount.getAccount();
   }
-
   // 添加账户或者 guest
   async addAccounts(accounts, extra) {
-    // 如果是holder类型的需要先做数据转换
-    if (extra?.type === 'holder') {
+    if ((extra == null ? void 0 : extra.type) === "holder") {
       this.store.accountList.addHolderAccounts({
         holders: accounts,
         customerId: extra.customerId,
-        type: 'unshift'
+        type: "unshift"
       });
       return;
     }
     const res = [];
     for (const account of accounts) {
-      const accountModule = await this.store.accountList.addAccount(account);
+      const accountModule = await this.store.accountList.addAccount(
+        account
+      );
       const accountData = accountModule.getAccount();
       if (accountData) {
         res.push(accountData);
@@ -329,77 +340,70 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     }
     return res;
   }
-
   // 获取所有账户
   async getAccounts() {
     const accounts = this.store.accountList.getAccounts();
-    return accounts.map(account => account.getAccount());
+    return accounts.map((account) => account.getAccount());
   }
   checkHasLoginAccount() {
     const accounts = this.store.accountList.getAccounts();
-    return accounts.some(account => account.getLoginStatus());
+    return accounts.some((account) => account.getLoginStatus());
   }
   setActiveAccount(id) {
     this.store.accountList.setActiveAccount(id);
   }
   getActiveAccount() {
     const activeAccount = this.store.accountList.getActiveAccount();
-    const account = activeAccount?.getAccount();
-    return account === null ? undefined : account;
+    const account = activeAccount == null ? void 0 : activeAccount.getAccount();
+    return account === null ? void 0 : account;
   }
   removeAccount(id) {
     this.store.accountList.removeAccount(id);
-    // 还需要把对应账号的商品给她删了
     this.clearCartByAccount(id);
   }
-
   /**
    * 获取holder类型账户列表
    * @param params
    */
   async fetchHolderAccountsAsync(params) {
+    var _a, _b;
     const cartItems = this.store.cart.getItems();
     if (cartItems.length) {
-      let date = this.store.date.getDateRange()?.[0]?.date;
+      let date = (_b = (_a = this.store.date.getDateRange()) == null ? void 0 : _a[0]) == null ? void 0 : _b.date;
       if (!date) {
-        // 如果没有日期，则应该是 session 类先选商品的流程，直接从购物车里拿 start_date
-        // 不能从购物车里第一个找时间，而是找到购物车里第一个有 start_date 的时间
-        const normalProductCartItem = cartItems.find(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-        date = normalProductCartItem?.start_date || '';
+        const normalProductCartItem = cartItems.find(
+          (n) => !(0, import_utils5.isNormalProduct)(n._productOrigin)
+        );
+        date = (normalProductCartItem == null ? void 0 : normalProductCartItem.start_date) || "";
       }
       this.updateQuotationPriceAndCart(date);
     }
     return this.store.accountList.fetchHolderAccounts(params);
   }
-
   /**
    * 获取 holder 表单 map
    */
   getHolderFormMap() {
     return this.store.holder.getHolderFormMap();
   }
-
   /**
    * 登录后或外部触发时，按当前 holderMap 批量刷新所有表单的 records
    */
   async refreshAllHolderFormRecords(params) {
     return this.store.holder.refreshAllFormRecords({
-      customer_id: params?.customer_id,
+      customer_id: params == null ? void 0 : params.customer_id,
       useCache: false
     });
   }
-
   /**
    * 添加表单记录
    */
   appendFormRecord(params) {
     return this.store.holder.appendFormRecord(params);
   }
-
   // 设置日期范围,注入到日期模块中
   async setDateRange(dateRange) {
     this.store.date.setDateRange(dateRange);
-    // 日期数据变更后，如果购物车里有数据，需要更新购物车里的报价单的价格
     if (dateRange.length && this.store.cart.getItems().length) {
       this.updateQuotationPriceAndCart(dateRange[0].date);
     }
@@ -407,7 +411,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
   clearDateRange() {
     this.store.date.clearDateRange();
   }
-
   // 获取日期模块里选中的日期
   async getDateRange() {
     return this.store.date.getDateRange();
@@ -415,50 +418,37 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
   getCart() {
     return this.store.cart.getItems();
   }
-
   // 获取商品/服务的可用日期
   async getAvailableDate(params = {}) {
-    // 开始日期如果小于今天，直接以今天当做开始日期
-    let {
-      products,
-      startDate,
-      endDate,
-      type,
-      useCache = true
-    } = params;
-    // 前端传递的 startDate，可能是今天之前的，如果 startDate 小于今天 且 endDate 小于或等于今天，需要把 startDate 置为今天
-    if ((0, _dayjs.default)(startDate).isBefore((0, _dayjs.default)(), 'day') && ((0, _dayjs.default)(endDate).isAfter((0, _dayjs.default)(), 'day') || (0, _dayjs.default)(endDate).isSame((0, _dayjs.default)(), 'day'))) {
-      startDate = (0, _dayjs.default)().format('YYYY-MM-DD');
+    var _a, _b, _c, _d;
+    let { products, startDate, endDate, type, useCache = true } = params;
+    if ((0, import_dayjs.default)(startDate).isBefore((0, import_dayjs.default)(), "day") && ((0, import_dayjs.default)(endDate).isAfter((0, import_dayjs.default)(), "day") || (0, import_dayjs.default)(endDate).isSame((0, import_dayjs.default)(), "day"))) {
+      startDate = (0, import_dayjs.default)().format("YYYY-MM-DD");
     }
-    let tempProducts = products || this.store.cart.getItems().map(p => p._productOrigin);
+    let tempProducts = products || this.store.cart.getItems().map((p) => p._productOrigin);
     if (tempProducts.length) {
-      tempProducts.forEach(p => {
-        if (p?.['schedule.ids']) {
-          const scheduleData = this.getScheduleDataByIds(p['schedule.ids']);
-          p['_schedule'] = scheduleData;
+      tempProducts.forEach((p) => {
+        if (p == null ? void 0 : p["schedule.ids"]) {
+          const scheduleData = this.getScheduleDataByIds(p["schedule.ids"]);
+          p["_schedule"] = scheduleData;
         }
       });
     }
-    // 如果当前打开了某个的商品详情弹窗，则应该默认用这个商品
     if (this.store.currentProduct) {
-      tempProducts = [{
-        ...this.store.currentProduct,
-        _schedule: this.store.currentProductMeta?.['schedule']
-      }];
+      tempProducts = [
+        {
+          ...this.store.currentProduct,
+          _schedule: (_a = this.store.currentProductMeta) == null ? void 0 : _a["schedule"]
+        }
+      ];
     }
     let dateRange = this.store.date.getDateRange();
-    const tempStartDate = startDate || dateRange?.[0]?.date;
-    const tempEndDate = endDate || dateRange?.[1]?.date || dateRange?.[0]?.date;
+    const tempStartDate = startDate || ((_b = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _b.date);
+    const tempEndDate = endDate || ((_c = dateRange == null ? void 0 : dateRange[1]) == null ? void 0 : _c.date) || ((_d = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _d.date);
     if (!tempProducts.length) {
       return [];
     }
-
-    // 在这里需要把能收集到的数据都收集上来，拼装好给 date 模块去查询
-    const {
-      resourceIds,
-      rules,
-      resourcesMap
-    } = (0, _products.getAvailableProductResources)(tempProducts) || {};
+    const { resourceIds, rules, resourcesMap } = (0, import_products.getAvailableProductResources)(tempProducts) || {};
     this.otherParams.currentResourcesMap = resourcesMap;
     const res = await this.store.date.getResourceDates({
       url: params.url,
@@ -473,7 +463,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     });
     return res;
   }
-
   /**
    * 获取购物车汇总信息
    */
@@ -482,29 +471,26 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     const summary = await this.store.summary.getSummary(cartItems);
     return summary;
   }
-
   /**
    * 获取协议
    */
   async getProtocol(protocolId) {
     return this.store.summary.getProtocol(protocolId);
   }
-
   // 获取可选择的商品、服务列表
   async getProducts() {
     return this.store.products.getProducts();
   }
-
   // 如果用户登录
   async setLoginAccount(accountId, accountInfo) {
+    var _a, _b;
     const account = this.store.accountList.getAccount(accountId);
     if (account) {
       let stateAccountId = account.getId();
       accountInfo.isLogin = true;
       account.setAccountInfo(accountInfo);
-      // 然后去购物车，把原先关联了 holder_id 为 accountId 的商品，替换为 holder_id = accountInfo.id
       const cartItems = this.store.cart.getItems();
-      cartItems.forEach(item => {
+      cartItems.forEach((item) => {
         if (item.holder_id === accountId) {
           this.store.cart.updateItem({
             _id: item._id,
@@ -514,39 +500,35 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       });
       this.store.accountList.updateAccountListById(stateAccountId, accountInfo);
       if (cartItems.length) {
-        let date = this.store.date.getDateRange()?.[0]?.date;
+        let date = (_b = (_a = this.store.date.getDateRange()) == null ? void 0 : _a[0]) == null ? void 0 : _b.date;
         if (!date) {
-          // 如果没有日期，则应该是 session 类先选商品的流程，直接从购物车里拿 start_date
-          // 不能从购物车里第一个找时间，而是找到购物车里第一个有 start_date 的时间
-          const normalProductCartItem = cartItems.find(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-          date = normalProductCartItem?.start_date || '';
+          const normalProductCartItem = cartItems.find(
+            (n) => !(0, import_utils5.isNormalProduct)(n._productOrigin)
+          );
+          date = (normalProductCartItem == null ? void 0 : normalProductCartItem.start_date) || "";
         }
         this.updateQuotationPriceAndCart(date);
-
-        // 登录后刷新 holder 表单
         try {
           const customerId = Number(accountInfo.id);
           await this.refreshAllHolderFormRecords({
             customer_id: customerId
           });
         } catch (error) {
-          console.error('[BookingByStep] 登录后刷新 holder 表单失败', error);
+          console.error("[BookingByStep] 登录后刷新 holder 表单失败", error);
         }
       }
     } else {
       throw new Error(`没有找到${accountId}账户`);
     }
   }
-
   // 生成购物车的正规数据
-  async generateCartData() {}
-
+  async generateCartData() {
+  }
   // 免费领取商品相关逻辑，上线了来不及加了，先放在这，后面要做到 payment 里面的
   async getFreeProduct(id) {
     const res = await this.request.post(`/pay/order/free-pay/${id}`);
     return res;
   }
-
   /**
    * 检查购物车提交订单前是否符合条件
    * @param type 类型 "holder" | "account"
@@ -558,71 +540,61 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       cartItems: this.store.cart.getItems()
     });
   }
-
   // 购物车提交订单
   async submitOrder(extraData) {
+    var _a;
     const cartItems = this.store.cart.getItems();
-    const newCartItems = (0, _lodashEs.cloneDeep)(cartItems);
-    // 先整个临时的逻辑，把购物车里所有商品的资源给他格式化一下
-    newCartItems.forEach(item => {
+    const newCartItems = (0, import_lodash_es.cloneDeep)(cartItems);
+    newCartItems.forEach((item) => {
+      var _a2;
       if (item._origin.resources && item._origin.resources.length) {
-        item._origin.resources = item._origin.resources.map(n => {
-          const newResourcesItem = (0, _lodashEs.cloneDeep)(n);
+        item._origin.resources = item._origin.resources.map((n) => {
+          const newResourcesItem = (0, import_lodash_es.cloneDeep)(n);
           delete newResourcesItem.id;
           delete newResourcesItem.main_field;
           delete newResourcesItem.resourceType;
-          return {
-            ...newResourcesItem
-          };
+          return { ...newResourcesItem };
         });
-        const {
-          currentCapacity,
-          formatCapacity
-        } = (0, _capacity.getCapacityInfoByCartItem)(item);
-        if (!item._origin?.metadata) {
+        const { currentCapacity, formatCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(item);
+        if (!((_a2 = item._origin) == null ? void 0 : _a2.metadata)) {
           item._origin.metadata = {};
         }
         item._origin.metadata.capacity = formatCapacity;
         item._origin.number = currentCapacity;
       }
     });
-    let type = this.otherParams.isRetailTemplate ? 'virtual' : 'appointment_booking';
-    // 如果购物车里全都是普通商品，type 也应该为 virtual
-    if ((0, _utils5.areAllNormalProducts)(newCartItems.map(n => n._productOrigin))) {
-      type = 'virtual';
+    let type = this.otherParams.isRetailTemplate ? "virtual" : "appointment_booking";
+    if ((0, import_utils5.areAllNormalProducts)(
+      newCartItems.map((n) => n._productOrigin)
+    )) {
+      type = "virtual";
     }
     return this.store.order.submitOrder({
       query: {
         cartItems: newCartItems,
         type,
         platform: this.platform,
-        business_code: this.otherParams?.business_code,
+        business_code: (_a = this.otherParams) == null ? void 0 : _a.business_code,
         extraData
       }
     });
   }
-
   // 拉起支付模块
-  async pay() {}
-
+  async pay() {
+  }
   // 获取支付信息
-  async getPayInfo() {}
-  async setOtherParams(params, {
-    cover = false
-  } = {}) {
+  async getPayInfo() {
+  }
+  async setOtherParams(params, { cover = false } = {}) {
     if (cover) {
       this.otherParams = params;
     } else {
-      this.otherParams = {
-        ...this.otherParams,
-        ...params
-      };
+      this.otherParams = { ...this.otherParams, ...params };
     }
   }
   async getOtherParams() {
     return this.otherParams;
   }
-
   /**
    * 往购物车加商品数据(duration 类、普通商品)
    * 老接口，先不删，怕 UI 有问题，直接桥接到新接口addProductToCart上
@@ -631,15 +603,12 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    * @memberof BookingByStepImpl
    */
   storeProduct(productData) {
-    // 往购物车加商品数据的时候，默认用当前 activeAccount 填充到 product 的 account 里面
     const activeAccount = this.getActiveAccount();
-    // 直接调用 addProductToCart，不传递 date 参数以避免日期检查逻辑
     return this.addProductToCart({
       product: productData,
       account: activeAccount
     });
   }
-
   /**
    * 往购物车加商品数据
    *
@@ -668,31 +637,20 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       rowKey,
       quantity = 1
     } = product || {};
-    const productData = {
-      ...origin,
-      product_variant_id
-    };
-    // 保护，如果进来的是 session 商品，则必须要有 date 和时间片，否则不允许添加
-    if ((0, _products.isSessionProduct)(productData)) {
+    const productData = { ...origin, product_variant_id };
+    if ((0, import_products.isSessionProduct)(productData)) {
       if (!date || !date.startTime || !date.endTime) {
-        return {
-          success: false,
-          errorCode: 'date_or_time_required'
-        };
+        return { success: false, errorCode: "date_or_time_required" };
       }
     }
-
-    // 库存检测
     const currentCartItems = this.store.cart.getItems();
-    const stockCheckResult = (0, _stock.checkProductStock)({
+    const stockCheckResult = (0, import_stock.checkProductStock)({
       productData,
       product_variant_id,
       quantity,
       bundle,
       currentCartItems
     });
-
-    // 如果库存检测失败，直接返回
     if (!stockCheckResult.success) {
       return stockCheckResult;
     }
@@ -705,21 +663,19 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     try {
       this.store.holder.ensureFormByProduct({
         product: productData,
-        shop_id: productData?.shop_id || '',
+        shop_id: (productData == null ? void 0 : productData.shop_id) || "",
         useCache: true
       });
     } catch (error) {
-      console.error('[BookingByStep] 加载 holder 表单失败', error);
+      console.error("[BookingByStep] 加载 holder 表单失败", error);
     }
     const flag = this.store.cart.mergeCartItemByRowKey({
       rowKey,
       quantity,
-      account: account || undefined
+      account: account || void 0
     });
     if (flag) {
-      return {
-        success: true
-      };
+      return { success: true };
     }
     const addItemParams = {
       product: productData,
@@ -733,24 +689,18 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     if (account) {
       addItemParams.account = account;
     }
-    this.addProductCheck({
-      date
-    });
-    // 如果 quantity 大于 1，且是预约商品，则进入购物车拆散成多条数据
-    if (addItemParams.quantity > 1 && !(0, _utils5.isNormalProduct)(productData)) {
+    this.addProductCheck({ date });
+    if (addItemParams.quantity > 1 && !(0, import_utils5.isNormalProduct)(productData)) {
       for (let i = 0; i < addItemParams.quantity; i++) {
-        const newAddItemParams = (0, _lodashEs.cloneDeep)(addItemParams);
+        const newAddItemParams = (0, import_lodash_es.cloneDeep)(addItemParams);
         newAddItemParams.quantity = 1;
         this.store.cart.addItem(newAddItemParams);
       }
     } else {
       this.store.cart.addItem(addItemParams);
     }
-    return {
-      success: true
-    };
+    return { success: true };
   }
-
   /**
    * 添加完购物车以后做的一些检测，比如日期是否在同一天
    *
@@ -760,38 +710,28 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
   addProductCheck({
     date
   }) {
-    // 检测，有传递 date，检查购物车里其他商品的 date 是否在同一天，如果不在，清空那些不在同一天的商品
     if (date) {
-      const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-      const cartItemsByDate = cartItems.filter(n => !(0, _dayjs.default)(n.start_date).isSame((0, _dayjs.default)(date.startTime), 'day'));
+      const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
+      const cartItemsByDate = cartItems.filter(
+        (n) => !(0, import_dayjs.default)(n.start_date).isSame((0, import_dayjs.default)(date.startTime), "day")
+      );
       if (cartItemsByDate.length) {
-        cartItemsByDate.forEach(n => {
+        cartItemsByDate.forEach((n) => {
           this.store.cart.removeItem(n._id);
         });
       }
-      // // 如果 date.startTime 和 dateRange 里的 startTime 不一样，需要修正 dateRange
-      // const dateRange = this.store.date.getDateRange()
-      // if (dateRange?.[0] && !dayjs(dateRange[0].date).isSame(dayjs(date.startTime), 'day')) {
-      //   this.setDateRange([
-      //     { date: dayjs(date.startTime).format('YYYY-MM-DD'), status: 'available', week: '', weekNum: 0 },
-      //     { date: dayjs(date.endTime).format('YYYY-MM-DD'), status: 'available', week: '', weekNum: 0 },
-      //   ]);
-      // }
     }
   }
   beforeUpdateCart(params, targetCartItem) {
     if (params.resources) {
-      const {
-        currentCapacity
-      } = (0, _capacity.getCapacityInfoByCartItem)(targetCartItem);
-      params.resources = params.resources.map(n => {
+      const { currentCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(targetCartItem);
+      params.resources = params.resources.map((n) => {
         n.capacity = currentCapacity || 1;
-        (0, _capacity.checkSubResourcesCapacity)(n);
+        (0, import_capacity.checkSubResourcesCapacity)(n);
         return n;
       });
     }
   }
-
   // 更新购物车
   updateCart(params) {
     const targetCartItem = this.store.cart.getItem(params._id);
@@ -802,7 +742,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     this.store.cart.updateItem(params);
     this.updateCartCheck(params, targetCartItem);
   }
-
   /**
    * 更新购物车以后的一些操作，比如检测资源是否重复，检测资源容量是否足够
    *
@@ -812,59 +751,63 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    * @memberof BookingByStepImpl
    */
   updateCartCheck(params, targetCartItem) {
-    // 零售模板不需要检测
+    var _a;
     if (this.otherParams.isRetailTemplate) {
       return;
     }
     let currentResourcesCapacityMap = {};
-    params.resources?.forEach(n => {
+    (_a = params.resources) == null ? void 0 : _a.forEach((n) => {
       currentResourcesCapacityMap[n.id] = n.capacity;
     });
     const allOriginResources = [];
     const dateRange = this.store.date.getDateRange();
-    if (dateRange?.length) {
-      dateRange.forEach(n => {
-        if (n.resource) allOriginResources.push(...n.resource);
+    if (dateRange == null ? void 0 : dateRange.length) {
+      dateRange.forEach((n) => {
+        if (n.resource)
+          allOriginResources.push(...n.resource);
       });
     }
-    // 如果此时 resources 为空，视作购物车里已经有了 dateRange 数据，此时 dateList 里明确就是那一天的数据
     if (!allOriginResources.length) {
       const dateList = this.store.date.getDateList();
-      dateList?.forEach(n => {
-        if (n.resource) allOriginResources.push(...n.resource);
+      dateList == null ? void 0 : dateList.forEach((n) => {
+        if (n.resource)
+          allOriginResources.push(...n.resource);
       });
     }
-    // 只有在更新资源的时候做这个判断，其他情况下不做处理
     if (params.resources) {
-      // 更新购物车后，需要判定购物车里是否存在多个账号选择了相同资源的情况，如果是，且资源是单个预约，则要把选择了相同资源的 product._origin.resources 给去除
       const cartItems = this.store.cart.getItems();
-      cartItems.forEach(item => {
+      cartItems.forEach((item) => {
+        var _a2;
         if (item._id !== targetCartItem._id) {
-          const {
-            currentCapacity
-          } = (0, _capacity.getCapacityInfoByCartItem)(item);
-          const resources = item._origin.resources?.filter(m => {
-            // 检查当前资源是否与目标资源的任何资源匹配
-            // 目标资源，应该只取跟当前 m.form_id 相同的资源
-            const sameFormIdResources = (0, _resources.filterResourcesByFormItem)(targetCartItem._origin.resources, m.form_id);
-            if (!sameFormIdResources?.length) {
+          const { currentCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(item);
+          const resources = (_a2 = item._origin.resources) == null ? void 0 : _a2.filter((m) => {
+            const sameFormIdResources = (0, import_resources.filterResourcesByFormItem)(
+              targetCartItem._origin.resources,
+              m.form_id
+            );
+            if (!(sameFormIdResources == null ? void 0 : sameFormIdResources.length)) {
               return true;
             }
-            return !sameFormIdResources.some(targetRes => {
-              // 如果新更新进来的资源不是单个预约，其实就不需要检测了资源重叠了，但是需要检测资源 capacity 是否足够
-              if (targetRes.resourceType !== 'single') {
-                const originResource = allOriginResources.find(n => n.id === targetRes.id);
-                const canUse = (0, _capacity.checkResourceCanUseByCapacity)(currentResourcesCapacityMap[m.id] || 0, currentCapacity, originResource?.capacity);
-                if (canUse) currentResourcesCapacityMap[m.id] += currentCapacity;
+            return !sameFormIdResources.some((targetRes) => {
+              if (targetRes.resourceType !== "single") {
+                const originResource = allOriginResources.find(
+                  (n) => n.id === targetRes.id
+                );
+                const canUse = (0, import_capacity.checkResourceCanUseByCapacity)(
+                  currentResourcesCapacityMap[m.id] || 0,
+                  currentCapacity,
+                  originResource == null ? void 0 : originResource.capacity
+                );
+                if (canUse)
+                  currentResourcesCapacityMap[m.id] += currentCapacity;
                 return !canUse;
               }
-              if (item.holder_id !== targetCartItem?.holder_id) {
-                return (0, _resources.checkTwoResourcesIntersection)(targetRes, m);
+              if (item.holder_id !== (targetCartItem == null ? void 0 : targetCartItem.holder_id)) {
+                return (0, import_resources.checkTwoResourcesIntersection)(targetRes, m);
               }
               return false;
             });
           });
-          // session 类商品应该只调用清空 resource 的方法
           if (item.start_time) {
             const start_time = item.start_time;
             const end_time = item.end_time;
@@ -874,8 +817,12 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
               _id: item._id,
               resources,
               date: {
-                startTime: (0, _dayjs.default)(`${start_date} ${start_time}`).format('YYYY-MM-DD HH:mm'),
-                endTime: (0, _dayjs.default)(`${end_date} ${end_time}`).format('YYYY-MM-DD HH:mm')
+                startTime: (0, import_dayjs.default)(`${start_date} ${start_time}`).format(
+                  "YYYY-MM-DD HH:mm"
+                ),
+                endTime: (0, import_dayjs.default)(`${end_date} ${end_time}`).format(
+                  "YYYY-MM-DD HH:mm"
+                )
               }
             });
           } else {
@@ -888,34 +835,29 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       });
     }
   }
-
   // 删除购物车里某个商品
   deleteCart(cartItemId) {
     this.store.cart.removeItem(cartItemId);
   }
-
   // 清空购物车
   clearCart() {
     this.store.cart.clear();
   }
-
   // 基于账户清空购物车
   clearCartByAccount(account_id) {
     this.store.cart.clearCartByAccount(account_id);
   }
-
   /**
    * 批量更新购物车
    */
   batchUpdateCart(paramsList) {
     const cartItems = [];
-    paramsList.forEach(params => {
+    paramsList.forEach((params) => {
       const cartItem = this.store.cart.formatCartItem(params);
       cartItems.push(cartItem);
     });
     this.store.cart.batchSetItems(cartItems);
   }
-
   /**
    * 从购物车中按类别删除信息
    */
@@ -925,17 +867,15 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
   checkCartItemByType(cartItem, type) {
     return this.store.cart.checkCartItemByType(cartItem, type);
   }
-
   /**
    * 检查购物车商品是否符合条件
    * @param type 类型
    * @returns 不符合条件的购物车商品ID列表
    */
   checkCartItems(type) {
-    // 预约流程中普通商品无需检测这些东西
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
     const errorCartItemIds = [];
-    cartItems.forEach(cartItem => {
+    cartItems.forEach((cartItem) => {
       const result = this.store.cart.checkCartItemByType(cartItem, type);
       if (!result) {
         errorCartItemIds.push(cartItem._id);
@@ -944,120 +884,129 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     return errorCartItemIds;
   }
   destroy() {
-    this.store.cart?.destroy();
-    this.store.step?.destroy();
-    this.store.products?.destroy();
-    this.store.guests?.destroy();
-    this.store.date?.destroy();
-    this.store.accountList?.destroy();
-    this.store.schedule?.destroy();
-    this.store.summary?.destroy();
-    this.store.order?.destroy();
+    var _a, _b, _c, _d, _e, _f;
+    (_a = this.store.cart) == null ? void 0 : _a.destroy();
+    (_b = this.store.step) == null ? void 0 : _b.destroy();
+    (_c = this.store.products) == null ? void 0 : _c.destroy();
+    (_d = this.store.guests) == null ? void 0 : _d.destroy();
+    (_e = this.store.date) == null ? void 0 : _e.destroy();
+    (_f = this.store.accountList) == null ? void 0 : _f.destroy();
     this.core.effects.offByModuleDestroy(this.name);
     this.core.unregisterModule(this);
   }
-
   // 获取当前购物车内所有关联的资源列表，拼装数据格式
   getResourcesList() {
     const dateRange = this.store.date.getDateRange();
     const resources = [];
-    if (dateRange?.length) {
-      dateRange.forEach(n => {
-        if (n.resource) resources.push(...n.resource);
+    if (dateRange == null ? void 0 : dateRange.length) {
+      dateRange.forEach((n) => {
+        if (n.resource)
+          resources.push(...n.resource);
       });
     }
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-
-    // 如果此时 resources 为空，视作购物车里已经有了 dateRange 数据，此时 dateList 里明确就是那一天的数据
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
     if (!resources.length) {
-      // 如果此时购物车里已经有了开始时间，则直接取那天的数据即可
-      const firstDateCartItem = cartItems?.find(n => n.start_date);
-      if (firstDateCartItem?.start_date) {
-        const dateResources = this.store.date.getResourcesListByDate(firstDateCartItem.start_date);
-        resources.push(...(dateResources || []));
+      const firstDateCartItem = cartItems == null ? void 0 : cartItems.find((n) => n.start_date);
+      if (firstDateCartItem == null ? void 0 : firstDateCartItem.start_date) {
+        const dateResources = this.store.date.getResourcesListByDate(
+          firstDateCartItem.start_date
+        );
+        resources.push(...dateResources || []);
       } else {
         const dateList = this.store.date.getDateList();
-        dateList?.forEach(n => {
-          if (n.resource) resources.push(...n.resource);
+        dateList == null ? void 0 : dateList.forEach((n) => {
+          if (n.resource)
+            resources.push(...n.resource);
         });
       }
     }
-    const resourcesMap = (0, _utils2.getResourcesMap)((0, _lodashEs.cloneDeep)(resources));
+    const resourcesMap = (0, import_utils2.getResourcesMap)((0, import_lodash_es.cloneDeep)(resources));
     const arr = [];
-    cartItems.forEach(cartItem => {
+    cartItems.forEach((cartItem) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
       let selectedResources = [];
-      const {
-        currentCapacity,
-        formatCapacity
-      } = (0, _capacity.getCapacityInfoByCartItem)(cartItem);
+      const { currentCapacity, formatCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(cartItem);
       cartItem._origin.metadata.capacity = formatCapacity;
       if (cartItem.holder_id) {
-        selectedResources = (0, _resources.getOthersSelectedResources)(cartItems, cartItem.holder_id, resourcesMap);
+        selectedResources = (0, import_resources.getOthersSelectedResources)(
+          cartItems,
+          cartItem.holder_id,
+          resourcesMap
+        );
       } else {
-        selectedResources = (0, _resources.getOthersCartSelectedResources)(cartItems, cartItem._id, resourcesMap);
+        selectedResources = (0, import_resources.getOthersCartSelectedResources)(
+          cartItems,
+          cartItem._id,
+          resourcesMap
+        );
       }
-      // TODO:下面这一坨要放到 resources 模块去
-      const productResources = (0, _resources.getResourcesByProduct)(resourcesMap, cartItem._productOrigin?.product_resource?.resources || [], selectedResources, currentCapacity);
-      // 如果购物车里已经有了时间片，则需要按照时间片过滤
+      const productResources = (0, import_resources.getResourcesByProduct)(
+        resourcesMap,
+        ((_b = (_a = cartItem._productOrigin) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) || [],
+        selectedResources,
+        currentCapacity
+      );
       if (cartItem._origin.start_time) {
-        const startTime = (0, _dayjs.default)(`${cartItem._origin.start_date} ${cartItem._origin.start_time}`);
-        const endTime = (0, _dayjs.default)(`${cartItem._origin.end_date} ${cartItem._origin.end_time}`);
+        const startTime = (0, import_dayjs.default)(
+          `${cartItem._origin.start_date} ${cartItem._origin.start_time}`
+        );
+        const endTime = (0, import_dayjs.default)(
+          `${cartItem._origin.end_date} ${cartItem._origin.end_time}`
+        );
         const resourcesUseableMap = {};
-        productResources.forEach(n => {
-          // 资源排下序，把单个资源靠前，组合资源排在后面
-          n.renderList = (0, _resources.sortCombinedResources)(n.renderList);
-          n.renderList = n.renderList.filter(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的开始结束时间
-            const mTimes = (0, _timeslots.filterConditionTimeSlots)(m.times, startTime, endTime);
-            // 如果在这个区间的时间一个都没有，可以直接认为这个资源不可用
+        productResources.forEach((n) => {
+          n.renderList = (0, import_resources.sortCombinedResources)(n.renderList);
+          n.renderList = n.renderList.filter((m) => {
+            const mTimes = (0, import_timeslots.filterConditionTimeSlots)(
+              m.times,
+              startTime,
+              endTime
+            );
             if (mTimes.length === 0) {
               return false;
             }
-            const canUseArr = mTimes.map(item => {
-              const res = (0, _resources.getIsUsableByTimeItem)({
+            const canUseArr = mTimes.map((item) => {
+              var _a2;
+              const res = (0, import_resources.getIsUsableByTimeItem)({
                 timeSlice: {
-                  start_time: startTime.format('HH:mm'),
-                  end_time: endTime.format('HH:mm'),
+                  start_time: startTime.format("HH:mm"),
+                  end_time: endTime.format("HH:mm"),
                   start_at: startTime,
                   end_at: endTime
                 },
                 time: item,
                 resource: m,
                 currentCount: currentCapacity || 0,
-                resourcesUseableMap: resourcesUseableMap,
-                cut_off_time: cartItem._productOrigin?.cut_off_time
+                resourcesUseableMap,
+                cut_off_time: (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.cut_off_time
               });
-              // 如果仅仅是因为子资源容量不够，不应该标记子资源是被占用的情况(因为组合资源还需要判断子资源够不够)
-              if (resourcesUseableMap?.[m.id] !== false && res.reason !== 'capacityOnly') {
+              if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[m.id]) !== false && res.reason !== "capacityOnly") {
                 resourcesUseableMap[m.id] = res.usable;
               }
               return res.usable;
             });
-            if (m.onlyComputed) return false;
-            // 在已经选定时间的情况下，只要canUseTime 里有一个 false，那就代表不可用
-            return !canUseArr.some(n => n === false);
+            if (m.onlyComputed)
+              return false;
+            return !canUseArr.some((n2) => n2 === false);
           });
         });
       } else {
-        const hasFlexibleDuration = cartItem._productOrigin?.duration?.type === 'flexible';
-        const operating_day_boundary = this.shopStore.get('core')?.core?.operating_day_boundary;
-        const maxBlockThreshold = cartItem._productOrigin?.duration?.flexible_config?.is_enable_minimum_duration ? cartItem._productOrigin?.duration?.flexible_config?.block_threshold || 0 : 0;
-        productResources.forEach(item => {
-          // 如果资源的 capacity 已经小于了当前需要的 capacity ，则需要把资源给过滤掉
-          // 同时，在这一步尝试去拉一下时间片，基于商品的时长，看每个资源是否还有空余时间能对这个商品做服务，如果没有则过滤
-          item.renderList = item.renderList.filter(n => {
+        const hasFlexibleDuration = ((_d = (_c = cartItem._productOrigin) == null ? void 0 : _c.duration) == null ? void 0 : _d.type) === "flexible";
+        const operating_day_boundary = (_f = (_e = this.shopStore.get("core")) == null ? void 0 : _e.core) == null ? void 0 : _f.operating_day_boundary;
+        const maxBlockThreshold = ((_i = (_h = (_g = cartItem._productOrigin) == null ? void 0 : _g.duration) == null ? void 0 : _h.flexible_config) == null ? void 0 : _i.is_enable_minimum_duration) ? ((_l = (_k = (_j = cartItem._productOrigin) == null ? void 0 : _j.duration) == null ? void 0 : _k.flexible_config) == null ? void 0 : _l.block_threshold) || 0 : 0;
+        productResources.forEach((item) => {
+          item.renderList = item.renderList.filter((n) => {
+            var _a2, _b2, _c2;
             const recordCount = n.capacity || 0;
-            if (n.onlyComputed) return false;
-            // 查一下这个资源基于商品的可用时间片
-            const timeSlots = (0, _resources.getTimeSlicesByResource)({
+            if (n.onlyComputed)
+              return false;
+            const timeSlots = (0, import_resources.getTimeSlicesByResource)({
               resource: n,
-              duration: cartItem._productOrigin?.duration?.value || 10,
+              duration: ((_b2 = (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.value) || 10,
               split: 10,
               currentDate: dateRange[0].date,
               hasFlexibleDuration,
-              cut_off_time: cartItem._productOrigin?.cut_off_time,
+              cut_off_time: (_c2 = cartItem._productOrigin) == null ? void 0 : _c2.cut_off_time,
               operating_day_boundary,
               maxBlockThreshold
             });
@@ -1078,7 +1027,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     });
     return arr;
   }
-
   /**
    * 在日期那边点击下一步的时候，检查这一天购物车里的商品是不是都有资源可以用
    *
@@ -1087,12 +1035,11 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    */
   checkResourceListForDate() {
     const resourcesList = this.getResourcesList();
-
-    // 检查每一项资源的 renderList 里是否都有数据
-    const hasResource = resourcesList.every(item => item.resources.every(resource => resource.renderList.length > 0));
+    const hasResource = resourcesList.every(
+      (item) => item.resources.every((resource) => resource.renderList.length > 0)
+    );
     return hasResource;
   }
-
   /**
    * 给单个购物车里的商品获取资源列表，给 UI 用的
    *
@@ -1101,32 +1048,45 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    * @memberof BookingByStepImpl
    */
   getResourcesListByCartItem(id) {
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
+    var _a, _b;
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
     const dateRange = this.store.date.getDateRange();
     const resources = [];
-    dateRange.forEach(n => {
-      if (n.resource) resources.push(...n.resource);
+    dateRange.forEach((n) => {
+      if (n.resource)
+        resources.push(...n.resource);
     });
-    // 用于确保后续分配的容量不会超出
-    const resourcesMap = (0, _utils2.getResourcesMap)(resources);
-    const targetCartItem = cartItems.find(n => n._id === id);
+    const resourcesMap = (0, import_utils2.getResourcesMap)(resources);
+    const targetCartItem = cartItems.find((n) => n._id === id);
     if (!targetCartItem) {
       throw new Error(`没有找到${id}购物车商品`);
     }
     let selectedResources = [];
-    const {
-      currentCapacity
-    } = (0, _capacity.getCapacityInfoByCartItem)(targetCartItem);
+    const { currentCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(targetCartItem);
     if (targetCartItem.holder_id) {
-      selectedResources = (0, _resources.getOthersSelectedResources)(cartItems, targetCartItem.holder_id, resourcesMap);
+      selectedResources = (0, import_resources.getOthersSelectedResources)(
+        cartItems,
+        targetCartItem.holder_id,
+        resourcesMap
+      );
     } else {
-      selectedResources = (0, _resources.getOthersCartSelectedResources)(cartItems, targetCartItem._id, resourcesMap);
+      selectedResources = (0, import_resources.getOthersCartSelectedResources)(
+        cartItems,
+        targetCartItem._id,
+        resourcesMap
+      );
     }
-    const productResources = (0, _resources.getResourcesByProduct)(resourcesMap, targetCartItem._productOrigin?.product_resource?.resources || [], selectedResources, currentCapacity);
-    productResources.forEach(item => {
-      item.renderList = item.renderList.filter(n => {
+    const productResources = (0, import_resources.getResourcesByProduct)(
+      resourcesMap,
+      ((_b = (_a = targetCartItem._productOrigin) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) || [],
+      selectedResources,
+      currentCapacity
+    );
+    productResources.forEach((item) => {
+      item.renderList = item.renderList.filter((n) => {
         const recordCount = n.capacity || 0;
-        if (n.onlyComputed) return false;
+        if (n.onlyComputed)
+          return false;
         return recordCount >= currentCapacity;
       });
     });
@@ -1143,7 +1103,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       };
     }
   }
-
   // 自动分派可用资源-pro 版，ui 传递某个账号，自动给某个账号下所有商品分配第一种资源
   autoSelectAccountResources({
     cartItem,
@@ -1153,111 +1112,109 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     countMap,
     capacity
   }) {
-    if ((0, _utils5.isNormalProduct)(cartItem._productOrigin)) {
+    var _a, _b, _c;
+    if ((0, import_utils5.isNormalProduct)(cartItem._productOrigin)) {
       return {};
     }
     const dateRange = this.store.date.getDateRange();
-    const cartItems = (0, _lodashEs.cloneDeep)(this.store.cart.getItems());
-    // 取到账号下所有的商品，然后根据商品的 duration 和资源列表，获取所有可用的资源
-    let accountCartItems = cartItems.filter(n => n.holder_id === holder_id) || [];
-    // 账号下没商品则处理所有购物车
+    const cartItems = (0, import_lodash_es.cloneDeep)(this.store.cart.getItems());
+    let accountCartItems = cartItems.filter((n) => n.holder_id === holder_id) || [];
     if (!accountCartItems.length) {
       accountCartItems = cartItems;
     }
-    // duration=所有商品时间的集合，如果是灵活时长，当做占用 10 分钟处理
     let duration = accountCartItems.reduce((acc, n) => {
-      return acc + (n._productOrigin?.duration?.value || 10);
+      var _a2, _b2;
+      return acc + (((_b2 = (_a2 = n._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.value) || 10);
     }, 0);
     let AllResources = [];
-    if (dateRange?.length) {
-      dateRange.forEach(n => {
-        if (n.resource) AllResources.push(...n.resource);
+    if (dateRange == null ? void 0 : dateRange.length) {
+      dateRange.forEach((n) => {
+        if (n.resource)
+          AllResources.push(...n.resource);
       });
     }
-    // 如果此时 resources 为空，视作购物车里已经有了 dateRange 数据，此时 dateList 里明确就是那一天的数据
     if (!AllResources.length) {
-      const firstDateCartItem = cartItems?.find(n => n.start_date);
-      if (firstDateCartItem?.start_date) {
-        const dateResources = this.store.date.getResourcesListByDate(firstDateCartItem.start_date);
-        AllResources.push(...(dateResources || []));
+      const firstDateCartItem = cartItems == null ? void 0 : cartItems.find((n) => n.start_date);
+      if (firstDateCartItem == null ? void 0 : firstDateCartItem.start_date) {
+        const dateResources = this.store.date.getResourcesListByDate(
+          firstDateCartItem.start_date
+        );
+        AllResources.push(...dateResources || []);
       } else {
         const dateList = this.store.date.getDateList();
-        dateList.forEach(n => {
-          if (n.resource) AllResources.push(...n.resource);
+        dateList.forEach((n) => {
+          if (n.resource)
+            AllResources.push(...n.resource);
         });
       }
     }
-    const resourcesMap = (0, _utils2.getResourcesMap)((0, _lodashEs.cloneDeep)(AllResources));
-    const allCartItems = (0, _lodashEs.cloneDeep)(this.store.cart.getItems());
-    const selectedResources = (0, _resources.getOthersSelectedResources)(allCartItems, holder_id, resourcesMap);
-    let allProductResources = (0, _resources.getResourcesByProduct)(resourcesMap, cartItem._productOrigin?.product_resource?.resources || [], selectedResources, 1);
-    const resources = allProductResources.find(n => n.code === resources_code)?.renderList || [];
-    // 资源排下序，把单个资源靠前，组合资源排在后面
+    const resourcesMap = (0, import_utils2.getResourcesMap)((0, import_lodash_es.cloneDeep)(AllResources));
+    const allCartItems = (0, import_lodash_es.cloneDeep)(this.store.cart.getItems());
+    const selectedResources = (0, import_resources.getOthersSelectedResources)(
+      allCartItems,
+      holder_id,
+      resourcesMap
+    );
+    let allProductResources = (0, import_resources.getResourcesByProduct)(
+      resourcesMap,
+      ((_b = (_a = cartItem._productOrigin) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) || [],
+      selectedResources,
+      1
+    );
+    const resources = ((_c = allProductResources.find((n) => n.code === resources_code)) == null ? void 0 : _c.renderList) || [];
     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 _a2, _b2, _c2, _d;
+      const aIsCombined = ((_b2 = (_a2 = a.metadata) == null ? void 0 : _a2.combined_resource) == null ? void 0 : _b2.status) === 1;
+      const bIsCombined = ((_d = (_c2 = b.metadata) == null ? void 0 : _c2.combined_resource) == null ? void 0 : _d.status) === 1;
+      if (aIsCombined && !bIsCombined)
+        return 1;
+      if (!aIsCombined && bIsCombined)
+        return -1;
       return 0;
     });
-    const resourcesUseableMap = [...selectedResources].reduce((acc, n) => {
-      acc[n] = resourcesMap[n]?.resourceType === 'single' ? false : true;
+    const resourcesUseableMap = [
+      ...selectedResources
+    ].reduce((acc, n) => {
+      var _a2;
+      acc[n] = ((_a2 = resourcesMap[n]) == null ? void 0 : _a2.resourceType) === "single" ? false : true;
       return acc;
     }, {});
-
-    // 如果有选择时间了，则代表不是第一种资源了，则需要根据开始时间去匹配
-    // 每个商品
     if (timeSlots) {
-      // const start_time = timeSlots.start_at.format("YYYY-MM-DD HH:mm");
-      // const end_time = dayjs(`${dateRange[0].date} ${timeSlots.start_time}`)
-      //   .add(duration, durationType as dayjs.ManipulateType)
-      //   .format("HH:mm");
-      // 根据 start_time 和 end_time 去匹配资源
       let targetResource = null;
       let targetResourceTime = 0;
       for (const n of resources) {
-        // 如果资源是独占的，并且 countMap 里选择过这个资源，则直接跳过
-        // if (n.resourceType === 'single' && countMap[n.id]) {
-        //   resourcesUseableMap[n.id] = false;
-        //   continue
-        // }
-        // const recordCount = countMap[n.id] || 0;
-        // n.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的开始结束时间
-        const mTimes = n.times.filter(n => {
-          return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(timeSlots.start_at)) && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(timeSlots.end_at));
+        const mTimes = n.times.filter((n2) => {
+          return !(0, import_dayjs.default)(n2.start_at).isAfter((0, import_dayjs.default)(timeSlots.start_at)) && !(0, import_dayjs.default)(n2.end_at).isBefore((0, import_dayjs.default)(timeSlots.end_at));
         });
-        // 如果在这个区间的时间一个都没有，可以直接认为这个资源不可用
         if (mTimes.length === 0) {
           continue;
         }
-        // 计算在时间片内有交集的预约容量总和
-        const totalCapacity = (countMap[n.id] || []).reduce((sum, item) => {
-          const hasOverlap = (0, _dayjs.default)(item.time.start_at).isBefore((0, _dayjs.default)(timeSlots.end_at)) && (0, _dayjs.default)(item.time.end_at).isAfter((0, _dayjs.default)(timeSlots.start_at));
-          return hasOverlap ? sum + item.pax : sum;
-        }, 0);
-
-        // 如果资源是单个预约，并且有 totalCapacity，则认为在当前 timeSlots 资源已经被选择过，就不可用了
-        if (n.resourceType === 'single' && totalCapacity > 0) {
+        const totalCapacity = (countMap[n.id] || []).reduce(
+          (sum, item) => {
+            const hasOverlap = (0, import_dayjs.default)(item.time.start_at).isBefore((0, import_dayjs.default)(timeSlots.end_at)) && (0, import_dayjs.default)(item.time.end_at).isAfter((0, import_dayjs.default)(timeSlots.start_at));
+            return hasOverlap ? sum + item.pax : sum;
+          },
+          0
+        );
+        if (n.resourceType === "single" && totalCapacity > 0) {
           continue;
         }
-        const canUseTime = mTimes.find(item => {
-          const res = (0, _resources.getIsUsableByTimeItem)({
+        const canUseTime = mTimes.find((item) => {
+          var _a2;
+          const res = (0, import_resources.getIsUsableByTimeItem)({
             timeSlice: timeSlots,
             time: item,
             resource: n,
             currentCount: totalCapacity + (capacity || 0),
             resourcesUseableMap,
-            cut_off_time: cartItem._productOrigin?.cut_off_time
+            cut_off_time: (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.cut_off_time
           });
-          // 如果只是因为子资源容量不够，而不是子资源被预约导致没时间片，不应该标记子资源为不可用，从而影响组合资源的情况
-          if (resourcesUseableMap?.[n.id] !== false && res.reason !== 'capacityOnly') {
+          if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[n.id]) !== false && res.reason !== "capacityOnly") {
             resourcesUseableMap[n.id] = res.usable;
           }
           return res.usable;
         });
-        const currentResourceIdleTime = (0, _timeslots.calculateResourceAvailableTime)({
+        const currentResourceIdleTime = (0, import_timeslots.calculateResourceAvailableTime)({
           resource: n,
           timeSlots,
           currentCapacity: totalCapacity + (capacity || 0)
@@ -1272,82 +1229,79 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
         selectedResource: targetResource
       };
     } else {
-      const resourcesMap = (0, _utils2.getResourcesMap)(resources);
-      const resourceIds = resources.map(n => n.id);
-      const timeSlots = (0, _resources.getTimeSlicesByResources)({
+      const resourcesMap2 = (0, import_utils2.getResourcesMap)(resources);
+      const resourceIds = resources.map((n) => n.id);
+      const timeSlots2 = (0, import_resources.getTimeSlicesByResources)({
         resourceIds,
-        resourcesMap,
+        resourcesMap: resourcesMap2,
         duration,
         currentDate: dateRange[0].date,
         split: 10,
         capacity,
         resourcesUseableMap
       });
-      // 如果timeSlots返回了 空数组，代表没有可用的资源了
-      if (!timeSlots) {
-        return; // 给一个提示？
+      if (!timeSlots2) {
+        return;
       }
       return {
-        timeSlots,
+        timeSlots: timeSlots2,
         selectedResource: resources[0]
       };
     }
   }
-
   // 给所有购物车里的商品先分配一个资源
   autoSelectAllProductResources(resources_code, timeSlots) {
+    var _a;
     const dateRange = this.store.date.getDateRange();
     const resources = [];
-    if (dateRange?.[0]?.date) {
-      dateRange.forEach(n => {
-        if (n.resource) resources.push(...n.resource);
+    if ((_a = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _a.date) {
+      dateRange.forEach((n) => {
+        if (n.resource)
+          resources.push(...n.resource);
       });
     }
-    // 一个账号一个账号处理
     const errorList = [];
-    // 资源使用情况-单个预约
     const selectResourcesMap = {};
-    // 资源使用情况-多个预约
     const selectResourcesWithTimeSlots = {};
     const accountList = this.store.accountList.getAccounts();
-    const selectForCartResources = cartItems => {
-      let recordTimeSlots = (0, _lodashEs.cloneDeep)(timeSlots);
-      // timeSlots 传进来的只是用户选中的时间片，但是实际上需要根据多个商品时间进行累加
-      // 假设 timeSlots.start_time 是15:40 duration 是 30min
-      // 第一个商品分配完以后，第二个商品分配的start_time应该是第一个商品的 end_time ,然后 end_time 应该是 start_time+duration
-      // 判断购物车里是否有 flexible 类型的商品，如果有则不累加时间
-      const hasFlexibleProduct = cartItems.some(item => item._productOrigin?.duration?.type === 'flexible');
-      cartItems.forEach((item, index) => {
-        const {
-          currentCapacity
-        } = (0, _capacity.getCapacityInfoByCartItem)(item);
-        const hasOriginTimeSlot = Boolean(item._origin.start_time) && Boolean(item._origin.end_time) && !timeSlots?.start_time;
-        // 如果商品已经有时间数据了，意味着是通过先选日期再选商品流程进来的，相当于时间切片已经选中了
+    const selectForCartResources = (cartItems2) => {
+      let recordTimeSlots = (0, import_lodash_es.cloneDeep)(timeSlots);
+      const hasFlexibleProduct = cartItems2.some(
+        (item) => {
+          var _a2, _b;
+          return ((_b = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b.type) === "flexible";
+        }
+      );
+      cartItems2.forEach((item, index) => {
+        var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+        const { currentCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(item);
+        const hasOriginTimeSlot = Boolean(item._origin.start_time) && Boolean(item._origin.end_time) && !(timeSlots == null ? void 0 : timeSlots.start_time);
         if (hasOriginTimeSlot) {
           recordTimeSlots = {
             start_time: item._origin.start_time,
             end_time: item._origin.end_time,
-            start_at: (0, _dayjs.default)(`${item.start_date} ${item._origin.start_time}`),
-            end_at: (0, _dayjs.default)(`${item.end_date} ${item._origin.end_time}`)
+            start_at: (0, import_dayjs.default)(`${item.start_date} ${item._origin.start_time}`),
+            end_at: (0, import_dayjs.default)(`${item.end_date} ${item._origin.end_time}`)
           };
         }
         if (recordTimeSlots) {
-          // 同一账号下，如果当前商品不是第一个，则需要根据上一个商品的 end_time 和 duration 计算出当前商品的 start_time 和 end_time
-          // 前提：当前资源是单个预约才需要这么做
-          const currentResourceConfig = item._productOrigin?.product_resource?.resources?.find(n => n.code === resources_code);
-          // 只有 duration 类商品且不含有灵活时间的商品需要这个操作
-          if (index !== 0 && recordTimeSlots && currentResourceConfig?.type === 'single' && item._productOrigin?.duration && !hasFlexibleProduct && !hasOriginTimeSlot) {
-            const recordEndAt = recordTimeSlots.end_at ? (0, _dayjs.default)(recordTimeSlots.end_at) : (0, _dayjs.default)(`${item.start_date} ${recordTimeSlots.end_time}`);
+          const currentResourceConfig = (_c = (_b = (_a2 = item._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b.resources) == null ? void 0 : _c.find(
+            (n) => n.code === resources_code
+          );
+          if (index !== 0 && recordTimeSlots && (currentResourceConfig == null ? void 0 : currentResourceConfig.type) === "single" && ((_d = item._productOrigin) == null ? void 0 : _d.duration) && !hasFlexibleProduct && !hasOriginTimeSlot) {
+            const recordEndAt = recordTimeSlots.end_at ? (0, import_dayjs.default)(recordTimeSlots.end_at) : (0, import_dayjs.default)(`${item.start_date} ${recordTimeSlots.end_time}`);
             let start_at = recordEndAt;
-            let end_at = start_at.add(item._productOrigin?.duration?.value || 10, 'minutes');
+            let end_at = start_at.add(
+              ((_f = (_e = item._productOrigin) == null ? void 0 : _e.duration) == null ? void 0 : _f.value) || 10,
+              "minutes"
+            );
             recordTimeSlots = {
-              start_time: start_at.format('HH:mm'),
-              end_time: end_at.format('HH:mm'),
+              start_time: start_at.format("HH:mm"),
+              end_time: end_at.format("HH:mm"),
               start_at,
               end_at
             };
           }
-          // 如果传递了 timeSlots，代表是第二种资源，则直接拿 timeSlots 去匹配
           const res = this.autoSelectAccountResources({
             cartItem: item,
             holder_id: item.holder_id,
@@ -1356,12 +1310,14 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
             countMap: selectResourcesWithTimeSlots,
             capacity: currentCapacity
           });
-          if (res?.selectedResource) {
+          if (res == null ? void 0 : res.selectedResource) {
             if (!selectResourcesWithTimeSlots[res.selectedResource.id]) {
-              selectResourcesWithTimeSlots[res.selectedResource.id] = [{
-                pax: currentCapacity,
-                time: recordTimeSlots
-              }];
+              selectResourcesWithTimeSlots[res.selectedResource.id] = [
+                {
+                  pax: currentCapacity,
+                  time: recordTimeSlots
+                }
+              ];
             } else {
               selectResourcesWithTimeSlots[res.selectedResource.id].push({
                 pax: currentCapacity,
@@ -1369,73 +1325,94 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
               });
             }
             res.selectedResource.capacity = currentCapacity;
-            (0, _capacity.checkSubResourcesCapacity)(res.selectedResource);
+            (0, import_capacity.checkSubResourcesCapacity)(res.selectedResource);
             this.store.cart.updateItem({
               _id: item._id,
               // 这里要做去重，避免出现同样类型的资源被塞进同一个商品
-              resources: [...(item._origin.resources || []).filter(existingRes => existingRes.form_id !== res.selectedResource?.form_id), res.selectedResource]
+              resources: [
+                ...(item._origin.resources || []).filter(
+                  (existingRes) => {
+                    var _a3;
+                    return existingRes.form_id !== ((_a3 = res.selectedResource) == null ? void 0 : _a3.form_id);
+                  }
+                ),
+                res.selectedResource
+              ]
             });
           } else {
-            // 如果没有可用的技师了，推到错误列表里让 UI 去提示
             errorList.push(item._id);
           }
         } else {
-          // 这里必须每次循环重新读，避免前一次循环操作了购物车，导致数据变更
-          // 能进到这种逻辑，说明是 duration 类商品或者灵活时长商品，且是第一种资源，还没有确定时间
-          const allCartItems = (0, _lodashEs.cloneDeep)(this.store.cart.getItems());
-          // 如果没有传递 timeSlots，代表是第一种资源，则直接拿商品的 duration，到资源列表里找一个公共可用的
+          const allCartItems = (0, import_lodash_es.cloneDeep)(this.store.cart.getItems());
           let selectedResources = [];
-          const resources = (0, _lodashEs.cloneDeep)(item._productOrigin?.product_resource?.resources || []);
+          const resources2 = (0, import_lodash_es.cloneDeep)(
+            ((_h = (_g = item._productOrigin) == null ? void 0 : _g.product_resource) == null ? void 0 : _h.resources) || []
+          );
           const currentResourcesRenderList = [];
-          resources.forEach(n => {
-            if (n.renderList?.length) {
-              // 过滤掉 capacity 小于 currentCapacity 的资源
-              n.renderList = n.renderList.filter(m => {
-                // 同时 还需要减去 selectResourcesMap 里已经选中的资源的数量
+          resources2.forEach((n) => {
+            var _a3;
+            if ((_a3 = n.renderList) == null ? void 0 : _a3.length) {
+              n.renderList = n.renderList.filter((m) => {
+                var _a4;
                 const recordCount = (m.capacity || 0) - (selectResourcesMap[m.id] || 0);
-                const timeSlots = (0, _resources.getTimeSlicesByResource)({
+                const timeSlots2 = (0, import_resources.getTimeSlicesByResource)({
                   resource: m,
-                  duration: item?.duration?.value || 10,
+                  duration: ((_a4 = item == null ? void 0 : item.duration) == null ? void 0 : _a4.value) || 10,
                   split: 10,
                   currentDate: dateRange[0].date
                 });
-                return recordCount >= currentCapacity && timeSlots.length > 0;
+                return recordCount >= currentCapacity && timeSlots2.length > 0;
               });
-              currentResourcesRenderList.push(...(n.renderList || []));
+              currentResourcesRenderList.push(...n.renderList || []);
             }
           });
-          const resourcesMap = (0, _utils2.getResourcesMap)(currentResourcesRenderList);
+          const resourcesMap = (0, import_utils2.getResourcesMap)(currentResourcesRenderList);
           if (item.holder_id) {
-            selectedResources = (0, _resources.getOthersSelectedResources)(allCartItems, item.holder_id, resourcesMap);
+            selectedResources = (0, import_resources.getOthersSelectedResources)(
+              allCartItems,
+              item.holder_id,
+              resourcesMap
+            );
           } else {
-            selectedResources = (0, _resources.getOthersCartSelectedResources)(allCartItems, item._id, resourcesMap);
+            selectedResources = (0, import_resources.getOthersCartSelectedResources)(
+              allCartItems,
+              item._id,
+              resourcesMap
+            );
           }
-          const productResources = (0, _resources.getResourcesByProduct)(resourcesMap, (0, _lodashEs.cloneDeep)(resources), selectedResources, currentCapacity);
-          productResources.forEach(item => {
-            item.renderList = item.renderList.filter(n => {
+          const productResources = (0, import_resources.getResourcesByProduct)(
+            resourcesMap,
+            (0, import_lodash_es.cloneDeep)(resources2),
+            selectedResources,
+            currentCapacity
+          );
+          productResources.forEach((item2) => {
+            item2.renderList = item2.renderList.filter((n) => {
               const recordCount = (n.capacity || 0) - (selectResourcesMap[n.id] || 0);
-              if (n.onlyComputed) return false;
+              if (n.onlyComputed)
+                return false;
               return recordCount >= currentCapacity;
             });
           });
-          // 自动选择 productResources 中对应 resources_code 的资源
-          const targetRenderList = productResources.find(n => n.code === resources_code)?.renderList;
+          const targetRenderList = (_i = productResources.find(
+            (n) => n.code === resources_code
+          )) == null ? void 0 : _i.renderList;
           if (targetRenderList && targetRenderList.length > 0) {
-            // 如果购物车里已经有同类型的 form_id 的资源了，则不处理
-            if (item._origin.resources?.some(n => n.form_id === targetRenderList[0].form_id)) {
+            if ((_j = item._origin.resources) == null ? void 0 : _j.some(
+              (n) => n.form_id === targetRenderList[0].form_id
+            )) {
               return;
             }
-            const fastestResource = (0, _timeslots.findFastestAvailableResource)({
+            const fastestResource = (0, import_timeslots.findFastestAvailableResource)({
               resources: targetRenderList,
-              currentCapacity: currentCapacity,
+              currentCapacity,
               countMap: selectResourcesMap,
-              targetDate: dateRange?.[0]?.date,
-              durationMinutes: item?.duration?.value || item?._productOrigin?.duration?.value || 10
+              targetDate: (_k = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _k.date,
+              durationMinutes: ((_l = item == null ? void 0 : item.duration) == null ? void 0 : _l.value) || ((_n = (_m = item == null ? void 0 : item._productOrigin) == null ? void 0 : _m.duration) == null ? void 0 : _n.value) || 10
             });
             const targetResource = fastestResource || targetRenderList[0];
             targetResource.capacity = currentCapacity;
-            // 在这里处理 children 的数据
-            (0, _capacity.checkSubResourcesCapacity)(targetResource);
+            (0, import_capacity.checkSubResourcesCapacity)(targetResource);
             if (!selectResourcesMap[targetResource.id]) {
               selectResourcesMap[targetResource.id] = currentCapacity;
             } else {
@@ -1443,107 +1420,101 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
             }
             this.store.cart.updateItem({
               _id: item._id,
-              resources: [...(item._origin.resources || []).filter(existingRes => existingRes.resourceType !== targetRenderList[0].resourceType), targetResource]
+              resources: [
+                ...(item._origin.resources || []).filter(
+                  (existingRes) => existingRes.resourceType !== targetRenderList[0].resourceType
+                ),
+                targetResource
+              ]
             });
           } else {
-            // 如果没有可用的技师了，推到错误列表里让 UI 去提示
             errorList.push(item._id);
           }
         }
       });
     };
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-
-    // 如果购物车里没有 holderid数据，证明不按 holder 类流程预约走，给所有购物车一次性分派即可，不做账号下资源互斥逻辑
-    if (cartItems?.[0].holder_id) {
-      accountList.forEach(account => {
-        const cartItems = this.store.cart.getCartByAccount(account.getId());
-        selectForCartResources(cartItems);
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
+    if (cartItems == null ? void 0 : cartItems[0].holder_id) {
+      accountList.forEach((account) => {
+        const cartItems2 = this.store.cart.getCartByAccount(account.getId());
+        selectForCartResources(cartItems2);
       });
     } else {
       selectForCartResources(cartItems);
     }
-    return {
-      errorList
-    };
+    return { errorList };
   }
   // 从购物车中获取已经分配好第一步资源的所有时间片
   getTimeSlotByAllResources(resources_code, split = 10) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     let dateRange = this.store.date.getDateRange();
-    // 取出购物车中所有一已选择的第一步资源
     const resources = [];
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-    // if (cartItems?.[0].start_date) return [];
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
     const resourceIds = [];
-    let resourcesTypeId = undefined;
+    let resourcesTypeId = void 0;
     let isSingleResource = false;
-
-    // 找出购物车里最大的 cut_off_time
-    let maxCutOffTime = undefined;
-    let maxCutOffTimeValue = (0, _dayjs.default)();
-    cartItems.forEach(item => {
-      item._productOrigin?.product_resource?.resources?.forEach(n => {
-        // TODO： 少了个 status 的判断
+    let maxCutOffTime = void 0;
+    let maxCutOffTimeValue = (0, import_dayjs.default)();
+    cartItems.forEach((item) => {
+      var _a2, _b2, _c2, _d2, _e2, _f2, _g2, _h2, _i2;
+      (_c2 = (_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b2.resources) == null ? void 0 : _c2.forEach((n) => {
         if (n.code === resources_code) {
-          resources.push(...(n.renderList || []));
-          isSingleResource = n.type === 'single';
+          resources.push(...n.renderList || []);
+          isSingleResource = n.type === "single";
         }
       });
-      // item._origin.resources?.forEach((n: any) => {
-      //   resourceIds.push(n.relation_id);
-      // });
       if (item.resource_id && !resourceIds.includes(item.resource_id)) {
         resourceIds.push(item.resource_id);
       }
-      resourcesTypeId = item?._productOrigin?.product_resource?.resources?.find(n => n.code === resources_code)?.id;
-      if (item._productOrigin?.cut_off_time && item._productOrigin?.cut_off_time.type === 'advance') {
-        const currentCutOffTime = (0, _dayjs.default)().add(item._productOrigin.cut_off_time.unit, item._productOrigin.cut_off_time.unit_type);
-        if (currentCutOffTime.isAfter(maxCutOffTimeValue, 'minute')) {
+      resourcesTypeId = (_g2 = (_f2 = (_e2 = (_d2 = item == null ? void 0 : item._productOrigin) == null ? void 0 : _d2.product_resource) == null ? void 0 : _e2.resources) == null ? void 0 : _f2.find(
+        (n) => n.code === resources_code
+      )) == null ? void 0 : _g2.id;
+      if (((_h2 = item._productOrigin) == null ? void 0 : _h2.cut_off_time) && ((_i2 = item._productOrigin) == null ? void 0 : _i2.cut_off_time.type) === "advance") {
+        const currentCutOffTime = (0, import_dayjs.default)().add(
+          item._productOrigin.cut_off_time.unit,
+          item._productOrigin.cut_off_time.unit_type
+        );
+        if (currentCutOffTime.isAfter(maxCutOffTimeValue, "minute")) {
           maxCutOffTimeValue = currentCutOffTime;
           maxCutOffTime = item._productOrigin.cut_off_time;
         }
       }
     });
-    // 保险起见，在这里如果 dateRange 里也有 resources 的话，也 push 进去
-    if (dateRange?.[0]?.resource?.length) {
-      // resources.push(...dateRange[0].resource);
-      dateRange[0].resource.forEach(n => {
-        if (n.form_id === resourcesTypeId && !resources.find(m => m.id === n.id)) {
+    if ((_b = (_a = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _a.resource) == null ? void 0 : _b.length) {
+      dateRange[0].resource.forEach((n) => {
+        if (n.form_id === resourcesTypeId && !resources.find((m) => m.id === n.id)) {
           resources.push(n);
         }
       });
     }
-    // 检查通过购物车 renderList 加入的资源数据里 times 的正确性，如果不对则需要修正
-    if (dateRange?.[0]?.date && resources.length) {
-      const currentDate = dateRange?.[0]?.date;
+    if (((_c = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _c.date) && resources.length) {
+      const currentDate = (_d = dateRange == null ? void 0 : dateRange[0]) == null ? void 0 : _d.date;
       const theDateResources = this.store.date.getResourcesListByDate(currentDate);
-      resources.forEach(item => {
-        const noCurrentDateTimes = item.times.some(n => {
-          return (0, _dayjs.default)(n.start_at).isSame((0, _dayjs.default)(currentDate), 'day');
+      resources.forEach((item) => {
+        var _a2;
+        const noCurrentDateTimes = item.times.some((n) => {
+          return (0, import_dayjs.default)(n.start_at).isSame((0, import_dayjs.default)(currentDate), "day");
         });
         if (!noCurrentDateTimes) {
-          item.times = theDateResources?.find(n => n.id === item.id)?.times || [];
+          item.times = ((_a2 = theDateResources == null ? void 0 : theDateResources.find((n) => n.id === item.id)) == null ? void 0 : _a2.times) || [];
         }
       });
     }
-
-    // 如果依然 resources 空的，则证明他是切换日期了，此时直接从 date 模块里取
     if (resources.length === 0) {
-      resources.push(...(this.store.date.getResourcesListByDate(dateRange[0].date) || []));
+      resources.push(...this.store.date.getResourcesListByDate(dateRange[0].date) || []);
     }
-    const resourcesMap = (0, _utils2.getResourcesMap)(resources);
+    const resourcesMap = (0, import_utils2.getResourcesMap)(resources);
     let duration = 0;
-    // duration = 不同账号的最长时间
     const accountList = this.store.accountList.getAccounts();
-    const checkDuration = cartItems => {
+    const checkDuration = (cartItems2) => {
       let accountDuration = 0;
-      cartItems.forEach(item => {
-        // 单个预约累加账号 多个预约取最大值
+      cartItems2.forEach((item) => {
+        var _a2, _b2, _c2, _d2, _e2, _f2;
         if (isSingleResource) {
-          accountDuration += item._productOrigin?.duration?.value || 10;
+          accountDuration += ((_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.value) || 10;
         } else {
-          if (accountDuration < (item._productOrigin?.duration?.value || 10)) {
-            accountDuration = item._productOrigin?.duration?.value || 10;
+          if (accountDuration < (((_d2 = (_c2 = item._productOrigin) == null ? void 0 : _c2.duration) == null ? void 0 : _d2.value) || 10)) {
+            accountDuration = ((_f2 = (_e2 = item._productOrigin) == null ? void 0 : _e2.duration) == null ? void 0 : _f2.value) || 10;
           }
         }
       });
@@ -1551,68 +1522,74 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
         duration = accountDuration;
       }
     };
-    if (cartItems?.[0].holder_id) {
-      accountList.forEach(account => {
-        const cartItems = this.store.cart.getCartByAccount(account.getId());
-        checkDuration(cartItems);
+    if (cartItems == null ? void 0 : cartItems[0].holder_id) {
+      accountList.forEach((account) => {
+        const cartItems2 = this.store.cart.getCartByAccount(account.getId());
+        checkDuration(cartItems2);
       });
     } else {
       checkDuration(cartItems);
     }
-    // 如果 cartItem 上既没有时间，也没有资源，认为外部属于异常调用，直接丢一个空数组出去
-    // 同时 session 类商品的流程也不应该调用这个方法
-    if (!cartItems?.[0]?.start_date && !cartItems?.[0]?.resource_id || !cartItems?.[0].duration) {
+    if (!((_e = cartItems == null ? void 0 : cartItems[0]) == null ? void 0 : _e.start_date) && !((_f = cartItems == null ? void 0 : cartItems[0]) == null ? void 0 : _f.resource_id) || !(cartItems == null ? void 0 : cartItems[0].duration)) {
       return [];
     }
-    if (cartItems?.[0].start_date && !dateRange) {
-      dateRange = [{
-        date: cartItems?.[0].start_date,
-        status: 'available',
-        week: '',
-        weekNum: 0
-      }, {
-        date: cartItems?.[0]?.end_date || cartItems?.[0]?.start_date || '',
-        status: 'available',
-        week: '',
-        weekNum: 0
-      }];
+    if ((cartItems == null ? void 0 : cartItems[0].start_date) && !dateRange) {
+      dateRange = [
+        {
+          date: cartItems == null ? void 0 : cartItems[0].start_date,
+          status: "available",
+          week: "",
+          weekNum: 0
+        },
+        {
+          date: ((_g = cartItems == null ? void 0 : cartItems[0]) == null ? void 0 : _g.end_date) || ((_h = cartItems == null ? void 0 : cartItems[0]) == null ? void 0 : _h.start_date) || "",
+          status: "available",
+          week: "",
+          weekNum: 0
+        }
+      ];
     }
     const resourcesUseableMap = {};
-    const hasFlexibleDuration = cartItems.some(item => item._productOrigin?.duration?.type === 'flexible');
-    let operating_day_boundary = this.shopStore.get('core')?.core?.operating_day_boundary;
-
-    // 如果有 hasFlexibleDuration，需要把动态时长商品（可能是多个，取最长的那个最低禁止购买时长）的最低禁止购买时长作为 split 的值
+    const hasFlexibleDuration = cartItems.some(
+      (item) => {
+        var _a2, _b2;
+        return ((_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.type) === "flexible";
+      }
+    );
+    let operating_day_boundary = (_j = (_i = this.shopStore.get("core")) == null ? void 0 : _i.core) == null ? void 0 : _j.operating_day_boundary;
     let maxBlockThreshold = 0;
     if (hasFlexibleDuration) {
       maxBlockThreshold = cartItems.reduce((max, item) => {
-        // 如果开启了灵活时长商品配置，则取 block_threshold 的值
-        if (item._productOrigin?.duration?.flexible_config?.is_enable_minimum_duration) {
-          return Math.max(max, item._productOrigin?.duration?.flexible_config?.block_threshold || 0);
+        var _a2, _b2, _c2, _d2, _e2, _f2;
+        if ((_c2 = (_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.flexible_config) == null ? void 0 : _c2.is_enable_minimum_duration) {
+          return Math.max(
+            max,
+            ((_f2 = (_e2 = (_d2 = item._productOrigin) == null ? void 0 : _d2.duration) == null ? void 0 : _e2.flexible_config) == null ? void 0 : _f2.block_threshold) || 0
+          );
         }
         return 0;
       }, 0);
     }
-    // 计算容量的辅助函数
-    const calculateCapacityFromCartItems = items => {
-      if (items.length === 0) return 0;
-      // 还需要增加一个判断，maxCapacity 必须是我单个人里选择的资源只有同一种的情况下才可以累加，否则单个账号都是 1
-      const firstResource = items[0]._resourceOrigin?.[0].id;
-      const sameResourceLength = items.filter(item => item._resourceOrigin?.[0].id === firstResource).length;
+    const calculateCapacityFromCartItems = (items) => {
+      var _a2;
+      if (items.length === 0)
+        return 0;
+      const firstResource = (_a2 = items[0]._resourceOrigin) == null ? void 0 : _a2[0].id;
+      const sameResourceLength = items.filter((item) => {
+        var _a3;
+        return ((_a3 = item._resourceOrigin) == null ? void 0 : _a3[0].id) === firstResource;
+      }).length;
       if (sameResourceLength === items.length) {
         return 1;
       }
-      // 找出单个购物车里最大的需求 capacity 即可
-      return Math.max(...items.map(item => (0, _capacity.getCapacityInfoByCartItem)(item).currentCapacity || 1));
-      // return items.reduce((total, item) => {
-      //   return total + (getCapacityInfoByCartItem(item).currentCapacity || 0);
-      // }, 0);
+      return Math.max(...items.map((item) => (0, import_capacity.getCapacityInfoByCartItem)(item).currentCapacity || 1));
     };
-
-    // 如果是多个人预约，去要求出几个 holder 下最大的商品需求容量capacity
     let maxCapacity = 1;
-    if (cartItems?.[0].holder_id) {
-      accountList.forEach(account => {
-        const accountCartItems = this.store.cart.getCartByAccount(account.getId());
+    if (cartItems == null ? void 0 : cartItems[0].holder_id) {
+      accountList.forEach((account) => {
+        const accountCartItems = this.store.cart.getCartByAccount(
+          account.getId()
+        );
         const currentCapacity = calculateCapacityFromCartItems(accountCartItems);
         if (currentCapacity > maxCapacity) {
           maxCapacity = currentCapacity;
@@ -1621,13 +1598,13 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     } else {
       maxCapacity = calculateCapacityFromCartItems(cartItems);
     }
-    const timeSlots = (0, _resources.getTimeSlicesByResources)({
+    const timeSlots = (0, import_resources.getTimeSlicesByResources)({
       resourceIds,
       resourcesMap,
       duration,
       currentDate: dateRange[0].date,
-      split: split,
-      resourcesUseableMap: resourcesUseableMap,
+      split,
+      resourcesUseableMap,
       capacity: maxCapacity,
       cut_off_time: maxCutOffTime,
       hasFlexibleDuration,
@@ -1637,70 +1614,61 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     return timeSlots;
   }
   // 从购物车中获取已经分配好第一步资源的所有时间片，批量版本，用于给日期提供能否高亮的判断
-  async getTimeSlotByAllResourcesForDate({
-    resources_code,
-    startDate,
-    endDate
-  }) {
-    // 如果 end_date 距离start_date小于 30 天，自动追加 end_date 为今天往后的 30 天
-    if ((0, _dayjs.default)(endDate).diff((0, _dayjs.default)(startDate), 'day') < 30) {
-      endDate = (0, _dayjs.default)(startDate).add(30, 'day').format('YYYY-MM-DD');
+  async getTimeSlotByAllResourcesForDate({ resources_code, startDate, endDate }) {
+    var _a, _b, _c, _d;
+    if ((0, import_dayjs.default)(endDate).diff((0, import_dayjs.default)(startDate), "day") < 30) {
+      endDate = (0, import_dayjs.default)(startDate).add(30, "day").format("YYYY-MM-DD");
     }
-    // 预请求资源数据，防止日期超过之前选择的范围
     await this.getAvailableDate({
-      startDate: startDate,
-      endDate: endDate,
+      startDate,
+      endDate,
       useCache: true
     });
-    // 取出购物车中所有一已选择的第一步资源
     const resources = [];
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-    // if (cartItems?.[0].start_date) return [];
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
     const resourceIds = [];
-    let resourcesTypeId = undefined;
+    let resourcesTypeId = void 0;
     let isSingleResource = false;
-
-    // 找出购物车里最大的 cut_off_time
-    let maxCutOffTime = undefined;
-    let maxCutOffTimeValue = (0, _dayjs.default)();
-    cartItems.forEach(item => {
-      item._productOrigin?.product_resource?.resources?.forEach(n => {
-        // TODO： 少了个 status 的判断
+    let maxCutOffTime = void 0;
+    let maxCutOffTimeValue = (0, import_dayjs.default)();
+    cartItems.forEach((item) => {
+      var _a2, _b2, _c2, _d2, _e, _f, _g, _h, _i;
+      (_c2 = (_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b2.resources) == null ? void 0 : _c2.forEach((n) => {
         if (n.code === resources_code) {
-          resources.push(...(n.renderList || []));
-          isSingleResource = n.type === 'single';
+          resources.push(...n.renderList || []);
+          isSingleResource = n.type === "single";
         }
       });
-      // item._origin.resources?.forEach((n: any) => {
-      //   resourceIds.push(n.relation_id);
-      // });
       if (item.resource_id && !resourceIds.includes(item.resource_id)) {
         resourceIds.push(item.resource_id);
       }
-      resourcesTypeId = item?._productOrigin?.product_resource?.resources?.find(n => n.code === resources_code)?.id;
-      if (item._productOrigin?.cut_off_time && item._productOrigin?.cut_off_time.type === 'advance') {
-        const currentCutOffTime = (0, _dayjs.default)().add(item._productOrigin.cut_off_time.unit, item._productOrigin.cut_off_time.unit_type);
-        if (currentCutOffTime.isAfter(maxCutOffTimeValue, 'minute')) {
+      resourcesTypeId = (_g = (_f = (_e = (_d2 = item == null ? void 0 : item._productOrigin) == null ? void 0 : _d2.product_resource) == null ? void 0 : _e.resources) == null ? void 0 : _f.find(
+        (n) => n.code === resources_code
+      )) == null ? void 0 : _g.id;
+      if (((_h = item._productOrigin) == null ? void 0 : _h.cut_off_time) && ((_i = item._productOrigin) == null ? void 0 : _i.cut_off_time.type) === "advance") {
+        const currentCutOffTime = (0, import_dayjs.default)().add(
+          item._productOrigin.cut_off_time.unit,
+          item._productOrigin.cut_off_time.unit_type
+        );
+        if (currentCutOffTime.isAfter(maxCutOffTimeValue, "minute")) {
           maxCutOffTimeValue = currentCutOffTime;
           maxCutOffTime = item._productOrigin.cut_off_time;
         }
       }
     });
-
-    // 保护： 如果 resources 为空则直接 return
-    if (!resources.length) return [];
+    if (!resources.length)
+      return [];
     let duration = 0;
-    // duration = 不同账号的最长时间
     const accountList = this.store.accountList.getAccounts();
-    const checkDuration = cartItems => {
+    const checkDuration = (cartItems2) => {
       let accountDuration = 0;
-      cartItems.forEach(item => {
-        // 单个预约累加账号 多个预约取最大值
+      cartItems2.forEach((item) => {
+        var _a2, _b2, _c2, _d2, _e, _f;
         if (isSingleResource) {
-          accountDuration += item._productOrigin?.duration?.value || 10;
+          accountDuration += ((_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.value) || 10;
         } else {
-          if (accountDuration < (item._productOrigin?.duration?.value || 10)) {
-            accountDuration = item._productOrigin?.duration?.value || 10;
+          if (accountDuration < (((_d2 = (_c2 = item._productOrigin) == null ? void 0 : _c2.duration) == null ? void 0 : _d2.value) || 10)) {
+            accountDuration = ((_f = (_e = item._productOrigin) == null ? void 0 : _e.duration) == null ? void 0 : _f.value) || 10;
           }
         }
       });
@@ -1708,50 +1676,52 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
         duration = accountDuration;
       }
     };
-    if (cartItems?.[0].holder_id) {
-      accountList.forEach(account => {
-        const cartItems = this.store.cart.getCartByAccount(account.getId());
-        checkDuration(cartItems);
+    if (cartItems == null ? void 0 : cartItems[0].holder_id) {
+      accountList.forEach((account) => {
+        const cartItems2 = this.store.cart.getCartByAccount(account.getId());
+        checkDuration(cartItems2);
       });
     } else {
       checkDuration(cartItems);
     }
-    // 如果 cartItem 上既没有时间，也没有资源，认为外部属于异常调用，直接丢一个空数组出去
-    // 同时 session 类商品的流程也不应该调用这个方法
-    if (!cartItems?.[0]?.start_date && !cartItems?.[0]?.resource_id || !cartItems?.[0].duration) {
+    if (!((_a = cartItems == null ? void 0 : cartItems[0]) == null ? void 0 : _a.start_date) && !((_b = cartItems == null ? void 0 : cartItems[0]) == null ? void 0 : _b.resource_id) || !(cartItems == null ? void 0 : cartItems[0].duration)) {
       return [];
     }
     const resourcesUseableMap = {};
-    const hasFlexibleDuration = cartItems.some(item => item._productOrigin?.duration?.type === 'flexible');
-    let operating_day_boundary = this.shopStore.get('core')?.core?.operating_day_boundary;
-
-    // 如果有 hasFlexibleDuration，需要把动态时长商品（可能是多个，取最长的那个最低禁止购买时长）的最低禁止购买时长作为 split 的值
+    const hasFlexibleDuration = cartItems.some(
+      (item) => {
+        var _a2, _b2;
+        return ((_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.type) === "flexible";
+      }
+    );
+    let operating_day_boundary = (_d = (_c = this.shopStore.get("core")) == null ? void 0 : _c.core) == null ? void 0 : _d.operating_day_boundary;
     let maxBlockThreshold = 0;
     if (hasFlexibleDuration) {
       maxBlockThreshold = cartItems.reduce((max, item) => {
-        // 如果开启了灵活时长商品配置，则取 block_threshold 的值
-        if (item._productOrigin?.duration?.flexible_config?.is_enable_minimum_duration) {
-          return Math.max(max, item._productOrigin?.duration?.flexible_config?.block_threshold || 0);
+        var _a2, _b2, _c2, _d2, _e, _f;
+        if ((_c2 = (_b2 = (_a2 = item._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.flexible_config) == null ? void 0 : _c2.is_enable_minimum_duration) {
+          return Math.max(max, ((_f = (_e = (_d2 = item._productOrigin) == null ? void 0 : _d2.duration) == null ? void 0 : _e.flexible_config) == null ? void 0 : _f.block_threshold) || 0);
         }
         return 0;
       }, 0);
     }
-    // 计算容量的辅助函数
-    const calculateCapacityFromCartItems = items => {
-      if (items.length === 0) return 0;
-      // 还需要增加一个判断，maxCapacity 必须是我单个人里选择的资源只有同一种的情况下才可以累加，否则单个账号都是 1
-      const firstResource = items[0]._resourceOrigin?.[0].id;
-      const sameResourceLength = items.filter(item => item._resourceOrigin?.[0].id === firstResource).length;
+    const calculateCapacityFromCartItems = (items) => {
+      var _a2;
+      if (items.length === 0)
+        return 0;
+      const firstResource = (_a2 = items[0]._resourceOrigin) == null ? void 0 : _a2[0].id;
+      const sameResourceLength = items.filter((item) => {
+        var _a3;
+        return ((_a3 = item._resourceOrigin) == null ? void 0 : _a3[0].id) === firstResource;
+      }).length;
       if (sameResourceLength !== items.length) {
         return 1;
       }
-      // 找出单个购物车里最大的需求 capacity 即可
-      return Math.max(...items.map(item => (0, _capacity.getCapacityInfoByCartItem)(item).currentCapacity || 1));
+      return Math.max(...items.map((item) => (0, import_capacity.getCapacityInfoByCartItem)(item).currentCapacity || 1));
     };
-    // 如果是多个预约，去要求出几个 holder 下最大的需求容量capacity
     let maxCapacity = 1;
-    if (cartItems?.[0].holder_id) {
-      accountList.forEach(account => {
+    if (cartItems == null ? void 0 : cartItems[0].holder_id) {
+      accountList.forEach((account) => {
         const accountCartItems = this.store.cart.getCartByAccount(account.getId());
         const currentCapacity = calculateCapacityFromCartItems(accountCartItems);
         if (currentCapacity > maxCapacity) {
@@ -1762,33 +1732,31 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       maxCapacity = calculateCapacityFromCartItems(cartItems);
     }
     const arr = [];
-    const today = (0, _dayjs.default)().startOf('day');
-    // 计算 start_date 到 end_date 之间的所有日期，遍历他们并且计算每一天的可用
-    for (let i = (0, _dayjs.default)(startDate); i.isBefore((0, _dayjs.default)(endDate)); i = i.add(1, 'day')) {
-      const currentDate = i.format('YYYY-MM-DD');
+    const today = (0, import_dayjs.default)().startOf("day");
+    for (let i = (0, import_dayjs.default)(startDate); i.isBefore((0, import_dayjs.default)(endDate)); i = i.add(1, "day")) {
+      const currentDate = i.format("YYYY-MM-DD");
       const theDateResources = this.store.date.getResourcesListByDate(currentDate);
-      resources.forEach(item => {
-        item.times = theDateResources?.find(n => n.id === item.id)?.times || [];
+      resources.forEach((item) => {
+        var _a2;
+        item.times = ((_a2 = theDateResources == null ? void 0 : theDateResources.find((n) => n.id === item.id)) == null ? void 0 : _a2.times) || [];
       });
-      const resourcesMap = (0, _utils2.getResourcesMap)(resources);
-
-      // 如果日期已经过期则直接标记为不可用
+      const resourcesMap = (0, import_utils2.getResourcesMap)(resources);
       if (i.isBefore(today)) {
         arr.push({
           date: currentDate,
-          status: 'unavailable',
-          week: i.format('ddd'),
+          status: "unavailable",
+          week: i.format("ddd"),
           weekNum: i.day()
         });
         continue;
       }
-      const timeSlots = (0, _resources.getTimeSlicesByResources)({
+      const timeSlots = (0, import_resources.getTimeSlicesByResources)({
         resourceIds,
         resourcesMap,
         duration,
-        currentDate: currentDate,
+        currentDate,
         split: 10,
-        resourcesUseableMap: resourcesUseableMap,
+        resourcesUseableMap,
         capacity: maxCapacity,
         cut_off_time: maxCutOffTime,
         hasFlexibleDuration,
@@ -1798,74 +1766,63 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       if (timeSlots.length > 0) {
         arr.push({
           date: currentDate,
-          status: 'available',
-          week: i.format('ddd'),
+          status: "available",
+          week: i.format("ddd"),
           weekNum: i.day()
         });
       } else {
         arr.push({
           date: currentDate,
-          status: 'unavailable',
-          week: i.format('ddd'),
+          status: "unavailable",
+          week: i.format("ddd"),
           weekNum: i.day()
         });
       }
     }
     return arr;
   }
-
   // 提交时间切片，绑定到对应购物车的商品上，更新购物车---只有 duration 商品
   submitTimeSlot(timeSlots) {
-    // 以账号为维度处理数据。购物车里每一项的 startTime应该是前一个商品的 endTime，如果是第一个商品则用 timeSlots.start_at
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-
-    // 取出所有资源列表
-    const allResources = this.store.date.getResourcesListByDate(timeSlots.start_at.format('YYYY-MM-DD'));
-
-    // 按账号分组
-    const itemsByAccount = cartItems.reduce((acc, item) => {
-      const holderId = item.holder_id;
-      if (!acc[holderId]) {
-        acc[holderId] = [];
-      }
-      acc[holderId].push(item);
-      return acc;
-    }, {});
-
-    // 店铺营业结束时间
-    const operating_day_boundary = this.shopStore.get('core')?.core?.operating_day_boundary;
-
-    // 处理每个账号的商品
-    Object.values(itemsByAccount).forEach(accountItems => {
-      let currentStartTime = timeSlots.start_at.format('YYYY-MM-DD HH:mm');
+    var _a, _b;
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
+    const allResources = this.store.date.getResourcesListByDate(
+      timeSlots.start_at.format("YYYY-MM-DD")
+    );
+    const itemsByAccount = cartItems.reduce(
+      (acc, item) => {
+        const holderId = item.holder_id;
+        if (!acc[holderId]) {
+          acc[holderId] = [];
+        }
+        acc[holderId].push(item);
+        return acc;
+      },
+      {}
+    );
+    const operating_day_boundary = (_b = (_a = this.shopStore.get("core")) == null ? void 0 : _a.core) == null ? void 0 : _b.operating_day_boundary;
+    Object.values(itemsByAccount).forEach((accountItems) => {
+      let currentStartTime = timeSlots.start_at.format("YYYY-MM-DD HH:mm");
       accountItems.forEach((item, index) => {
+        var _a2;
         const osWarnTips = [];
-        const newResources = (0, _lodashEs.cloneDeep)(item._origin.resources);
-        newResources.forEach(resource => {
-          // 如果商品配置的是灵活时长，开始时间设置为提交的时间，结束时间从资源的可用最晚时间和店铺营业结束时间里取一个最早的
-          if (item._productOrigin?.duration?.type === 'flexible') {
-            item.duration = {
-              type: 'minutes',
-              value: 10
-            };
-            resource.startTime = timeSlots.start_at.format('YYYY-MM-DD HH:mm');
-            // 找到resource.times里最晚的end_at
-            const targetResourceTimes = allResources?.find(n => n.id === resource.id)?.times;
-            // 找到最晚的 end_at 还没用，因为可能存在资源工作时间是 10:00-19:00，但是资源的 times 里有 16:30-19:00 被 block 的情况
-            // 所以还需要排除掉 block 时间
-            function getEarliestBlockedStartTime({
-              currentStartTime,
+        const newResources = (0, import_lodash_es.cloneDeep)(item._origin.resources);
+        newResources.forEach((resource) => {
+          var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+          if (((_b2 = (_a3 = item._productOrigin) == null ? void 0 : _a3.duration) == null ? void 0 : _b2.type) === "flexible") {
+            let getEarliestBlockedStartTime = function({
+              currentStartTime: currentStartTime2,
               times
             }) {
-              const currentStart = (0, _dayjs.default)(currentStartTime);
+              var _a4;
+              const currentStart = (0, import_dayjs.default)(currentStartTime2);
               let earliestBlockStart;
               for (const time of times || []) {
-                const blockedTimes = time.event_list?.filter(event => event.type !== 'schedule_event');
+                const blockedTimes = (_a4 = time.event_list) == null ? void 0 : _a4.filter((event) => event.type !== "schedule_event");
                 for (const event of blockedTimes || []) {
-                  const eventStart = (0, _dayjs.default)(event.start_at);
-                  const eventEnd = (0, _dayjs.default)(event.end_at);
+                  const eventStart = (0, import_dayjs.default)(event.start_at);
+                  const eventEnd = (0, import_dayjs.default)(event.end_at);
                   if (eventStart.isBefore(currentStart) && eventEnd.isAfter(currentStart)) {
-                    return currentStart.format('YYYY-MM-DD HH:mm');
+                    return currentStart.format("YYYY-MM-DD HH:mm");
                   }
                   if (eventStart.isAfter(currentStart)) {
                     if (!earliestBlockStart || eventStart.isBefore(earliestBlockStart)) {
@@ -1874,68 +1831,79 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
                   }
                 }
               }
-              return earliestBlockStart?.format('YYYY-MM-DD HH:mm');
-            }
-            const resourcesEndTime = targetResourceTimes.reduce((acc, curr) => {
-              return (0, _dayjs.default)(curr.end_at).isAfter((0, _dayjs.default)(acc.end_at)) ? curr : acc;
-            }, targetResourceTimes[0]);
+              return earliestBlockStart == null ? void 0 : earliestBlockStart.format("YYYY-MM-DD HH:mm");
+            };
+            item.duration = {
+              type: "minutes",
+              value: 10
+            };
+            resource.startTime = timeSlots.start_at.format("YYYY-MM-DD HH:mm");
+            const targetResourceTimes = (_c = allResources == null ? void 0 : allResources.find(
+              (n) => n.id === resource.id
+            )) == null ? void 0 : _c.times;
+            const resourcesEndTime = targetResourceTimes.reduce(
+              (acc, curr) => {
+                return (0, import_dayjs.default)(curr.end_at).isAfter((0, import_dayjs.default)(acc.end_at)) ? curr : acc;
+              },
+              targetResourceTimes[0]
+            );
             const earliestBlockedStartTime = getEarliestBlockedStartTime({
               currentStartTime,
               times: targetResourceTimes
             });
-
-            // 将 operating_day_boundary 转换为与 resourcesEndTime.end_at 相同日期的完整日期时间
-            const resourceDate = (0, _dayjs.default)(resourcesEndTime.end_at).format('YYYY-MM-DD');
-            const operatingBoundaryDateTime = `${resourceDate} ${operating_day_boundary.type === 'start_time' ? '23:59' : operating_day_boundary.time}`;
-            const endTimeCandidates = [resourcesEndTime.end_at, operatingBoundaryDateTime, ...(earliestBlockedStartTime ? [earliestBlockedStartTime] : [])];
+            const resourceDate = (0, import_dayjs.default)(resourcesEndTime.end_at).format(
+              "YYYY-MM-DD"
+            );
+            const operatingBoundaryDateTime = `${resourceDate} ${operating_day_boundary.type === "start_time" ? "23:59" : operating_day_boundary.time}`;
+            const endTimeCandidates = [
+              resourcesEndTime.end_at,
+              operatingBoundaryDateTime,
+              ...earliestBlockedStartTime ? [earliestBlockedStartTime] : []
+            ];
             const endTime = endTimeCandidates.reduce((earliest, value) => {
-              return (0, _dayjs.default)(value).isBefore((0, _dayjs.default)(earliest)) ? value : earliest;
+              return (0, import_dayjs.default)(value).isBefore((0, import_dayjs.default)(earliest)) ? value : earliest;
             }, endTimeCandidates[0]);
-            // 修复：如果 endTime 只是时间格式（如 "17:00"），需要加上日期
             let formattedEndTime;
-            if (typeof endTime === 'string' && endTime.includes(':') && !endTime.includes(' ') && !endTime.includes('T')) {
-              // 如果是纯时间格式，与当前日期合并
-              const currentDate = timeSlots.start_at.format('YYYY-MM-DD');
-              formattedEndTime = (0, _dayjs.default)(`${currentDate} ${endTime}`);
+            if (typeof endTime === "string" && endTime.includes(":") && !endTime.includes(" ") && !endTime.includes("T")) {
+              const currentDate = timeSlots.start_at.format("YYYY-MM-DD");
+              formattedEndTime = (0, import_dayjs.default)(`${currentDate} ${endTime}`);
             } else {
-              formattedEndTime = (0, _dayjs.default)(endTime);
+              formattedEndTime = (0, import_dayjs.default)(endTime);
             }
-            resource.endTime = formattedEndTime.format('YYYY-MM-DD HH:mm');
-            // 如果是动态时长商品，并且当前选择的时间的结束时间小于了最低提示时长（warningThreshold），则追加一个提示
-            // 如果currentStartTime + warningThreshold 大于 currentEndTime,且 osWarnTips 没有pisell2.product.card.closing-soon.warning 这一项，则加入这一项
-            if (item._productOrigin?.duration?.flexible_config?.is_enable_minimum_duration && (0, _dayjs.default)(currentStartTime).add(item._productOrigin?.duration?.flexible_config?.warning_threshold || 0, 'minutes').isAfter((0, _dayjs.default)(formattedEndTime))) {
-              if (!osWarnTips.includes('pisell2.product.card.closing-soon.warning')) {
-                osWarnTips.push('pisell2.product.card.closing-soon.warning');
+            resource.endTime = formattedEndTime.format("YYYY-MM-DD HH:mm");
+            if (((_f = (_e = (_d = item._productOrigin) == null ? void 0 : _d.duration) == null ? void 0 : _e.flexible_config) == null ? void 0 : _f.is_enable_minimum_duration) && (0, import_dayjs.default)(currentStartTime).add(((_i = (_h = (_g = item._productOrigin) == null ? void 0 : _g.duration) == null ? void 0 : _h.flexible_config) == null ? void 0 : _i.warning_threshold) || 0, "minutes").isAfter((0, import_dayjs.default)(formattedEndTime))) {
+              if (!osWarnTips.includes("pisell2.product.card.closing-soon.warning")) {
+                osWarnTips.push("pisell2.product.card.closing-soon.warning");
               }
             }
           } else {
             resource.startTime = currentStartTime;
-            resource.endTime = (0, _dayjs.default)(currentStartTime).add(item._productOrigin?.duration?.value || 10, 'minutes').format('YYYY-MM-DD HH:mm');
+            resource.endTime = (0, import_dayjs.default)(currentStartTime).add(((_k = (_j = item._productOrigin) == null ? void 0 : _j.duration) == null ? void 0 : _k.value) || 10, "minutes").format("YYYY-MM-DD HH:mm");
           }
-          // delete resource.times;
         });
         this.store.cart.updateItem({
           _id: item._id,
           resources: newResources,
           osWarnTips
         });
-
-        // 更新下一个商品的开始时间为当前商品的结束时间
-        if (index < accountItems.length - 1 && newResources?.[0]?.resourceType === 'single') {
+        if (index < accountItems.length - 1 && ((_a2 = newResources == null ? void 0 : newResources[0]) == null ? void 0 : _a2.resourceType) === "single") {
           currentStartTime = newResources[0].endTime;
         }
       });
     });
-    this.core.effects.emit(`${this.store.cart.name}:onUpdateBookingDate`, {});
+    this.core.effects.emit(
+      `${this.store.cart.name}:onUpdateBookingDate`,
+      {}
+    );
   }
   getScheduleDataByIds(scheduleIds) {
     const targetSchedules = this.store.schedule.getScheduleListByIds(scheduleIds);
-    const targetSchedulesData = targetSchedules.map(item => {
-      return (0, _utils3.calcCalendarDataByScheduleResult)(item);
+    const targetSchedulesData = targetSchedules.map((item) => {
+      return (0, import_utils3.calcCalendarDataByScheduleResult)(item);
     });
     const newSchedule = {};
-    targetSchedulesData.forEach(item => {
-      item.forEach(n => {
+    targetSchedulesData.forEach((item) => {
+      item.forEach((n) => {
         if (!newSchedule[n.date]) {
           newSchedule[n.date] = n;
         } else {
@@ -1946,9 +1914,8 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       });
     });
     const newScheduleArr = Object.values(newSchedule);
-    // newScheduleArr 需要做个排序，按日期从小到大
     newScheduleArr.sort((a, b) => {
-      return (0, _dayjs.default)(a.date).diff((0, _dayjs.default)(b.date));
+      return (0, import_dayjs.default)(a.date).diff((0, import_dayjs.default)(b.date));
     });
     return newScheduleArr;
   }
@@ -1958,22 +1925,17 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     if (targetProductData) {
       this.store.currentProduct = targetProductData;
       this.store.currentProductMeta = {};
-      // 资源预加载，如果是 duration 类型的商品，且是先选日期的流程，在这里预拉取资源数据
-      if (targetProductData['schedule.ids']) {
-        const newScheduleArr = this.getScheduleDataByIds(targetProductData['schedule.ids']);
-        if (!this.store.currentProductMeta) this.store.currentProductMeta = {};
+      if (targetProductData["schedule.ids"]) {
+        const newScheduleArr = this.getScheduleDataByIds(
+          targetProductData["schedule.ids"]
+        );
+        if (!this.store.currentProductMeta)
+          this.store.currentProductMeta = {};
         this.store.currentProductMeta.schedule = newScheduleArr;
       } else if (targetProductData.duration) {
         const dateRange = this.store.date.getDateRange();
-        // 如果不是先选日期的流程 duration 商品就啥也不做
-        if (!dateRange?.length) return;
-        // this.store.date.getResourceDates({
-        //   query: {
-        //     start_date: dateRange[0].date,
-        //     end_date: dateRange[dateRange.length - 1].date,
-        //     resource_ids: targetProductData.product_resource?.resources?.map((n: any) => n.id),
-        //   },
-        // });
+        if (!(dateRange == null ? void 0 : dateRange.length))
+          return;
         this.getAvailableDate({
           startDate: dateRange[0].date,
           endDate: dateRange[dateRange.length - 1].date,
@@ -1986,9 +1948,8 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     if (this.store.currentProductMeta) {
       this.store.currentProductMeta.schedule = [];
     }
-    this.store.currentProduct = undefined;
+    this.store.currentProduct = void 0;
   }
-
   // 通过商品和 schedule 来获取视频可用的时间片、时间片内资源可用的数据
   getTimeslotBySchedule({
     date,
@@ -1996,43 +1957,59 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     resources,
     product
   }) {
+    var _a, _b, _c, _d;
     const targetProduct = this.store.currentProduct;
-    // 如果外面传递了product 优先用外面的
     const targetProductData = product || targetProduct;
     let targetSchedules = [];
-    // 如果外面传递了 scheduleIds,优先取入参
-    if (scheduleIds?.length) {
+    if (scheduleIds == null ? void 0 : scheduleIds.length) {
       targetSchedules = this.store.schedule.getScheduleListByIds(scheduleIds);
     } else {
-      targetSchedules = this.store.schedule.getScheduleListByIds(targetProductData['schedule.ids']);
+      targetSchedules = this.store.schedule.getScheduleListByIds(
+        targetProductData["schedule.ids"]
+      );
     }
     const resourcesDates = this.store.date.getDateList();
-    const targetResourceDate = resourcesDates.find(n => n.date === date);
-    const cartItems = (0, _lodashEs.cloneDeep)(this.store.cart.getItems());
-    const resourcesMap = (0, _utils2.getResourcesMap)(targetResourceDate?.resource || []);
-    const selectedResources = (0, _resources.getOthersSelectedResources)(cartItems, '', resourcesMap);
-    const productResources = (0, _resources.getResourcesByProduct)(resourcesMap, resources || this.store.currentProduct?.product_resource?.resources || [], selectedResources, 1);
-    const minTimeMaxTime = (0, _utils3.calcMinTimeMaxTimeBySchedules)(targetSchedules, {}, date);
-    const scheduleTimeSlots = (0, _utils3.getAllSortedDateRanges)(minTimeMaxTime);
-    // 当前所有待选择资源的集合，先提出来，提升性能
-    let allProductResources = productResources.flatMap(n => n.renderList);
-    // 资源排下序，把单个资源靠前，组合资源排在后面
+    const targetResourceDate = resourcesDates.find((n) => n.date === date);
+    const cartItems = (0, import_lodash_es.cloneDeep)(this.store.cart.getItems());
+    const resourcesMap = (0, import_utils2.getResourcesMap)((targetResourceDate == null ? void 0 : targetResourceDate.resource) || []);
+    const selectedResources = (0, import_resources.getOthersSelectedResources)(
+      cartItems,
+      "",
+      resourcesMap
+    );
+    const productResources = (0, import_resources.getResourcesByProduct)(
+      resourcesMap,
+      resources || ((_b = (_a = this.store.currentProduct) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) || [],
+      selectedResources,
+      1
+    );
+    const minTimeMaxTime = (0, import_utils3.calcMinTimeMaxTimeBySchedules)(
+      targetSchedules,
+      {},
+      date
+    );
+    const scheduleTimeSlots = (0, import_utils3.getAllSortedDateRanges)(minTimeMaxTime);
+    let allProductResources = productResources.flatMap((n) => n.renderList);
     allProductResources.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 _a2, _b2, _c2, _d2;
+      const aIsCombined = ((_b2 = (_a2 = a.metadata) == null ? void 0 : _a2.combined_resource) == null ? void 0 : _b2.status) === 1;
+      const bIsCombined = ((_d2 = (_c2 = b.metadata) == null ? void 0 : _c2.combined_resource) == null ? void 0 : _d2.status) === 1;
+      if (aIsCombined && !bIsCombined)
+        return 1;
+      if (!aIsCombined && bIsCombined)
+        return -1;
       return 0;
     });
-    const enabledResourceTypeConfigs = targetProductData?.product_resource?.resources?.filter(n => n.status === 1) || [];
-    const resourceTypeConfigById = new Map(enabledResourceTypeConfigs.map(n => [n.id, n]));
-
-    // 计算每个日程切片下日程可用的资源的容量总和
-    const formatScheduleTimeSlots = scheduleTimeSlots.map(item => {
-      // 用来计算资源的可使用情况，针对单个schedule 时间片
+    const enabledResourceTypeConfigs = ((_d = (_c = targetProductData == null ? void 0 : targetProductData.product_resource) == null ? void 0 : _c.resources) == null ? void 0 : _d.filter(
+      (n) => n.status === 1
+    )) || [];
+    const resourceTypeConfigById = new Map(
+      enabledResourceTypeConfigs.map((n) => [n.id, n])
+    );
+    const formatScheduleTimeSlots = scheduleTimeSlots.map((item) => {
       const resourcesUseableMap = {};
       const statsByResourceType = {};
-      enabledResourceTypeConfigs.forEach(cfg => {
+      enabledResourceTypeConfigs.forEach((cfg) => {
         statsByResourceType[cfg.id] = {
           count: 0,
           left: 0,
@@ -2040,68 +2017,59 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
           summaryConfigCount: 0
         };
       });
-
-      // 遍历所有资源
-      allProductResources?.forEach(m => {
+      allProductResources == null ? void 0 : allProductResources.forEach((m) => {
         const currentResourceTypeConfig = resourceTypeConfigById.get(m.form_id);
-        if (!currentResourceTypeConfig) return;
-
-        // 遍历所有资源的上工时间片
+        if (!currentResourceTypeConfig)
+          return;
         let currentResourceMaxRemainingCapacity = 0;
         let isAllTimeSlicesUsable = true;
-        // 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的开始结束时间
-
-        // n.start_at 是 2025-06-30 15:00 end_at 2025-06-30 17:00
-        // item.start 是 2025-06-30 16:00 item.end 是 2025-06-30 19:00
-        // 需要判断 n.start_at 和 n.end_at 是否在 item.start 和 item.end 之间
-        // 如果是仅用于计算的资源， n.start_at 和 n.end_at 在 item.start 和 item.end 有交集，则此时间需要计算
-        // https://project.feishu.cn/v2qint/bug/detail/6657165010
-        const mTimes = m.times.filter(n => {
-          return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(item.start), 'minute') && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(item.end), 'minute') || m.onlyComputed && (0, _dayjs.default)(n.start_at).isBefore((0, _dayjs.default)(item.end), 'minute') && (0, _dayjs.default)(n.end_at).isAfter((0, _dayjs.default)(item.start), 'minute');
+        const mTimes = m.times.filter((n) => {
+          return !(0, import_dayjs.default)(n.start_at).isAfter((0, import_dayjs.default)(item.start), "minute") && !(0, import_dayjs.default)(n.end_at).isBefore((0, import_dayjs.default)(item.end), "minute") || m.onlyComputed && (0, import_dayjs.default)(n.start_at).isBefore((0, import_dayjs.default)(item.end), "minute") && (0, import_dayjs.default)(n.end_at).isAfter((0, import_dayjs.default)(item.start), "minute");
         });
-        // 如果在这个区间的时间一个都没有，可以直接认为这个资源不可用
         if (mTimes.length === 0) {
           return;
         }
-
-        // 统计该资源类型在这个时间片的“配置容量”（无占用），只统计上工的资源
         if (!m.onlyComputed) {
-          const currentStats = statsByResourceType[m.form_id] || {
+          const currentStats2 = statsByResourceType[m.form_id] || {
             count: 0,
             left: 0,
             summaryCount: 0,
             summaryConfigCount: 0
           };
-          if (currentResourceTypeConfig.type === 'multiple') currentStats.summaryConfigCount += m.capacity;else currentStats.summaryConfigCount += 1;
-          statsByResourceType[m.form_id] = currentStats;
+          if (currentResourceTypeConfig.type === "multiple")
+            currentStats2.summaryConfigCount += m.capacity;
+          else
+            currentStats2.summaryConfigCount += 1;
+          statsByResourceType[m.form_id] = currentStats2;
         }
-        mTimes.forEach(childTiem => {
-          // 挨个去匹配某个工作时间段结合当前日程时间，资源能不能用，有多少容量能用
-          const res = (0, _resources.getIsUsableByTimeItem)({
+        mTimes.forEach((childTiem) => {
+          const res = (0, import_resources.getIsUsableByTimeItem)({
             timeSlice: {
               start_time: item.start,
               end_time: item.end,
-              start_at: (0, _dayjs.default)(item.start),
-              end_at: (0, _dayjs.default)(item.end)
+              start_at: (0, import_dayjs.default)(item.start),
+              end_at: (0, import_dayjs.default)(item.end)
             },
             time: childTiem,
             resource: m,
             currentCount: 1,
             resourcesUseableMap,
-            cut_off_time: targetProductData?.cut_off_time
+            cut_off_time: targetProductData == null ? void 0 : targetProductData.cut_off_time
           });
-          if (resourcesUseableMap?.[m.id] !== false && res.reason !== 'capacityOnly') {
+          if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[m.id]) !== false && res.reason !== "capacityOnly") {
             resourcesUseableMap[m.id] = res.usable;
           }
-          if (!res.usable) isAllTimeSlicesUsable = false;
+          if (!res.usable)
+            isAllTimeSlicesUsable = false;
           if (res.usable && !m.onlyComputed) {
-            if (res.remainingCapacity > currentResourceMaxRemainingCapacity) currentResourceMaxRemainingCapacity = res.remainingCapacity;
+            if (res.remainingCapacity > currentResourceMaxRemainingCapacity)
+              currentResourceMaxRemainingCapacity = res.remainingCapacity;
           }
         });
-        if (!isAllTimeSlicesUsable) return;
-        if (m.onlyComputed) return;
+        if (!isAllTimeSlicesUsable)
+          return;
+        if (m.onlyComputed)
+          return;
         const currentStats = statsByResourceType[m.form_id] || {
           count: 0,
           left: 0,
@@ -2109,61 +2077,55 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
           summaryConfigCount: 0
         };
         currentStats.left += 1;
-        if (currentResourceTypeConfig.type === 'multiple') {
+        if (currentResourceTypeConfig.type === "multiple") {
           currentStats.summaryCount += currentResourceMaxRemainingCapacity;
         }
-        if (currentResourceMaxRemainingCapacity > currentStats.count) currentStats.count = currentResourceMaxRemainingCapacity;
-        // else {
-        // 单个预约：一个资源只计 1，不关心剩余容量
-        // currentStats.summaryCount += 1;
-        // if (currentStats.count < 1) currentStats.count = 1;
-        //}
-
+        if (currentResourceMaxRemainingCapacity > currentStats.count)
+          currentStats.count = currentResourceMaxRemainingCapacity;
         statsByResourceType[m.form_id] = currentStats;
       });
-      // 容量检测
-      const cartItems = this.store.cart.getItems();
-      productResources.forEach(n => {
+      const cartItems2 = this.store.cart.getItems();
+      productResources.forEach((n) => {
         const currentResourceTypeConfig = resourceTypeConfigById.get(n.id);
-        if (!currentResourceTypeConfig) return;
+        if (!currentResourceTypeConfig)
+          return;
         const currentStats = statsByResourceType[n.id] || {
           count: 0,
           left: 0,
           summaryCount: 0
         };
-
-        // 单个预约检测规则：
-        // 1、跟我一样的商品同一时间在购物车里不可以超过我最少的那种资源的关联的资源个数
-        // 2、跟我不一样的商品，只需要跟我当前商品有同一种类型的资源的同一时间的，她配置了几个资源的个数+我配置了几个资源的个数，然后购物车里有几个这样的商品，对应的资源做一个去重，不超过这个去重以后的总数
-        if (n.type === 'single') {
-          const currentResourcesSet = new Set([...n.optional_resource, ...n.default_resource]);
-          // 规则 1
-          const sameCartItems = cartItems.filter(m => m._productOrigin?.id?.toString() === targetProductData?.id?.toString() && `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end);
+        if (n.type === "single") {
+          const currentResourcesSet = /* @__PURE__ */ new Set([...n.optional_resource, ...n.default_resource]);
+          const sameCartItems = cartItems2.filter((m) => {
+            var _a2, _b2, _c2;
+            return ((_b2 = (_a2 = m._productOrigin) == null ? void 0 : _a2.id) == null ? void 0 : _b2.toString()) === ((_c2 = targetProductData == null ? void 0 : targetProductData.id) == null ? void 0 : _c2.toString()) && `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end;
+          });
           if (sameCartItems.length > 0 && sameCartItems.length >= currentResourcesSet.size || sameCartItems.length > currentStats.left) {
             currentStats.left = 0;
             currentStats.count = 0;
             currentStats.summaryCount = 0;
           }
-          // 规则 2
-          let otherCartItems = cartItems.filter(m => {
-            const isTimeMatch = m._productOrigin?.id?.toString() !== targetProductData?.id?.toString() && `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end;
-            const isResourceMatch = m._productOrigin?.product_resource?.resources?.find(m => m.type === n.type && m.status === 1);
-            return isTimeMatch && isResourceMatch;
-          });
-          otherCartItems.forEach(m => {
-            const sameTypeResources = m._productOrigin?.product_resource?.resources?.find(m => m.type === n.type && m.status === 1);
-            const sameTypeResourcesSet = new Set([...(sameTypeResources?.optional_resource || []), ...(sameTypeResources?.default_resource || [])]);
-            // 把sameTypeResourcesSet 加到currentResourcesSet
-            sameTypeResourcesSet.forEach(resource => currentResourcesSet.add(resource));
+          let otherCartItems = cartItems2.filter(
+            (m) => {
+              var _a2, _b2, _c2, _d2, _e, _f;
+              const isTimeMatch = ((_b2 = (_a2 = m._productOrigin) == null ? void 0 : _a2.id) == null ? void 0 : _b2.toString()) !== ((_c2 = targetProductData == null ? void 0 : targetProductData.id) == null ? void 0 : _c2.toString()) && `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end;
+              const isResourceMatch = (_f = (_e = (_d2 = m._productOrigin) == null ? void 0 : _d2.product_resource) == null ? void 0 : _e.resources) == null ? void 0 : _f.find((m2) => m2.type === n.type && m2.status === 1);
+              return isTimeMatch && isResourceMatch;
+            }
+          );
+          otherCartItems.forEach((m) => {
+            var _a2, _b2, _c2;
+            const sameTypeResources = (_c2 = (_b2 = (_a2 = m._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b2.resources) == null ? void 0 : _c2.find((m2) => m2.type === n.type && m2.status === 1);
+            const sameTypeResourcesSet = /* @__PURE__ */ new Set([...(sameTypeResources == null ? void 0 : sameTypeResources.optional_resource) || [], ...(sameTypeResources == null ? void 0 : sameTypeResources.default_resource) || []]);
+            sameTypeResourcesSet.forEach((resource) => currentResourcesSet.add(resource));
           });
-          // 先确定是否每一个currentResourcesSet在这个时间点的 event_list 都是空的,如果不是空的还需要把他踢出currentResourcesSet
-          const currentDataResources = this.store.date.getResourcesListByDate((0, _dayjs.default)(item.start).format('YYYY-MM-DD'));
-          currentDataResources?.forEach(m => {
+          const currentDataResources = this.store.date.getResourcesListByDate((0, import_dayjs.default)(item.start).format("YYYY-MM-DD"));
+          currentDataResources == null ? void 0 : currentDataResources.forEach((m) => {
             if (currentResourcesSet.has(m.id)) {
-              const mTimes = m.times.filter(n => {
-                return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(item.start), 'minute') && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(item.end), 'minute') || (0, _dayjs.default)(n.start_at).isBefore((0, _dayjs.default)(item.end), 'minute') && (0, _dayjs.default)(n.end_at).isAfter((0, _dayjs.default)(item.start), 'minute');
+              const mTimes = m.times.filter((n2) => {
+                return !(0, import_dayjs.default)(n2.start_at).isAfter((0, import_dayjs.default)(item.start), "minute") && !(0, import_dayjs.default)(n2.end_at).isBefore((0, import_dayjs.default)(item.end), "minute") || (0, import_dayjs.default)(n2.start_at).isBefore((0, import_dayjs.default)(item.end), "minute") && (0, import_dayjs.default)(n2.end_at).isAfter((0, import_dayjs.default)(item.start), "minute");
               });
-              if (!mTimes.length || mTimes.some(n => n.event_list.length)) {
+              if (!mTimes.length || mTimes.some((n2) => n2.event_list.length)) {
                 currentResourcesSet.delete(m.id);
               }
             }
@@ -2174,61 +2136,57 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
             currentStats.summaryCount = 0;
           }
         } else {
-          // 多个预约的检测规则：
-          // 规则1、跟我一样的商品同一时间在购物车需要的容量总数不可以超过我配置的资源的 capacity 之和
-          const sameCartItems = cartItems.filter(m => m._productOrigin?.id?.toString() === targetProductData?.id?.toString() && `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end);
-          const sameCartNeedCapacity = sameCartItems.reduce((acc, curr) => acc + (0, _capacity.getCapacityInfoByCartItem)(curr).currentCapacity, 0);
+          const sameCartItems = cartItems2.filter((m) => {
+            var _a2, _b2, _c2;
+            return ((_b2 = (_a2 = m._productOrigin) == null ? void 0 : _a2.id) == null ? void 0 : _b2.toString()) === ((_c2 = targetProductData == null ? void 0 : targetProductData.id) == null ? void 0 : _c2.toString()) && `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end;
+          });
+          const sameCartNeedCapacity = sameCartItems.reduce((acc, curr) => acc + (0, import_capacity.getCapacityInfoByCartItem)(curr).currentCapacity, 0);
           const currentProductResourcesCapacity = n.renderList.reduce((acc, curr) => !curr.onlyComputed ? acc + curr.capacity || 0 : acc, 0);
           if (sameCartNeedCapacity >= currentProductResourcesCapacity) {
             currentStats.left = 0;
             currentStats.count = 0;
             currentStats.summaryCount = 0;
           }
-          // 规则2、不管是不是跟我一样的商品，只需要跟我当前商品有同一种类型的资源的同一时间的，把所有购物车的 capacity 之和 和 所有当前类型资源的 capacity 之和比较，如果超过了resourcesCapacity，则不可用
-          // const otherCartItems = cartItems.filter((m) => m._productOrigin?.id?.toString() !== targetProductData?.id?.toString() && m.start_time === item.start && m.end_time === item.end);
-          const otherSameTimesCartItems = cartItems.filter(m => `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end);
-          const otherCartNeedCapacity = otherSameTimesCartItems.reduce((acc, curr) => acc + (0, _capacity.getCapacityInfoByCartItem)(curr).currentCapacity, 0);
-          const allRenderList = [...n.renderList.filter(m => !m.onlyComputed)];
-          otherSameTimesCartItems.forEach(m => {
-            const productResources = (0, _resources.getResourcesByProduct)((0, _utils2.getResourcesMap)(targetResourceDate?.resource || []), m._productOrigin?.product_resource?.resources || [], selectedResources, 1);
-            productResources.forEach(m => {
-              if (m.id === n.id) {
-                m.renderList.forEach(n => {
-                  if (!n.onlyComputed && !allRenderList.find(m => m.id === n.id)) {
-                    allRenderList.push(n);
+          const otherSameTimesCartItems = cartItems2.filter((m) => `${m.start_date} ${m.start_time}` === item.start && `${m.start_date} ${m.end_time}` === item.end);
+          const otherCartNeedCapacity = otherSameTimesCartItems.reduce((acc, curr) => acc + (0, import_capacity.getCapacityInfoByCartItem)(curr).currentCapacity, 0);
+          const allRenderList = [...n.renderList.filter((m) => !m.onlyComputed)];
+          otherSameTimesCartItems.forEach((m) => {
+            var _a2, _b2;
+            const productResources2 = (0, import_resources.getResourcesByProduct)(
+              (0, import_utils2.getResourcesMap)((targetResourceDate == null ? void 0 : targetResourceDate.resource) || []),
+              ((_b2 = (_a2 = m._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b2.resources) || [],
+              selectedResources,
+              1
+            );
+            productResources2.forEach((m2) => {
+              if (m2.id === n.id) {
+                m2.renderList.forEach((n2) => {
+                  if (!n2.onlyComputed && !allRenderList.find((m3) => m3.id === n2.id)) {
+                    allRenderList.push(n2);
                   }
                 });
               }
             });
           });
           const currentTypeResourcesCapacity = allRenderList.reduce((acc, curr) => acc + curr.capacity || 0, 0);
-          // 计算当前时间段内所有资源的已使用容量
           const usedCapacity = allRenderList.reduce((acc, curr) => {
-            const mTimes = curr.times.filter(n => {
-              return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(item.start), 'minute') && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(item.end), 'minute') || (0, _dayjs.default)(n.start_at).isBefore((0, _dayjs.default)(item.end), 'minute') && (0, _dayjs.default)(n.end_at).isAfter((0, _dayjs.default)(item.start), 'minute');
+            const mTimes = curr.times.filter((n2) => {
+              return !(0, import_dayjs.default)(n2.start_at).isAfter((0, import_dayjs.default)(item.start), "minute") && !(0, import_dayjs.default)(n2.end_at).isBefore((0, import_dayjs.default)(item.end), "minute") || (0, import_dayjs.default)(n2.start_at).isBefore((0, import_dayjs.default)(item.end), "minute") && (0, import_dayjs.default)(n2.end_at).isAfter((0, import_dayjs.default)(item.start), "minute");
             });
-            // 这里为什么要设置个 map，因为有可能日程有重叠，所以要把重叠的 event_list 去除
-            const mSet = new Map();
-            mTimes.forEach(n => {
-              // acc += n.event_list?.reduce((acc: any, curr: any) => acc + curr.pax, 0);
-              // mSet.set(n)
-              n.event_list.forEach(m => {
-                // 需要确认 m 的时间段是否和 item 的时间段有交集
-                if ((0, _resources.isConflict)({
-                  start_at: m.start_at,
-                  end_at: m.end_at
-                }, {
-                  start_at: (0, _dayjs.default)(item.start),
-                  end_at: (0, _dayjs.default)(item.end)
-                })) {
+            const mSet = /* @__PURE__ */ new Map();
+            mTimes.forEach((n2) => {
+              n2.event_list.forEach((m) => {
+                if ((0, import_resources.isConflict)(
+                  { start_at: m.start_at, end_at: m.end_at },
+                  { start_at: (0, import_dayjs.default)(item.start), end_at: (0, import_dayjs.default)(item.end) }
+                )) {
                   mSet.set(m.id, m.pax ?? 1);
                 }
               });
             });
-            acc += Array.from(mSet.values()).reduce((acc, curr) => acc + curr, 0);
+            acc += Array.from(mSet.values()).reduce((acc2, curr2) => acc2 + curr2, 0);
             return acc;
           }, 0);
-          // 如果已使用容量超过了当前类型资源的容量，则不可用
           if (otherCartNeedCapacity + usedCapacity >= currentTypeResourcesCapacity) {
             currentStats.left = 0;
             currentStats.count = 0;
@@ -2237,48 +2195,55 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
         }
         statsByResourceType[n.id] = currentStats;
       });
-      const startDayJs = (0, _dayjs.default)(item.start);
-      const endDayJs = (0, _dayjs.default)(item.end);
-
-      // 选择“瓶颈资源类型”：multiple 取 summaryCount 最小，single 取 left 最小
+      const startDayJs = (0, import_dayjs.default)(item.start);
+      const endDayJs = (0, import_dayjs.default)(item.end);
       let bottleneckResourceTypeId;
       let bottleneckValue = Infinity;
-      enabledResourceTypeConfigs.forEach(cfg => {
+      enabledResourceTypeConfigs.forEach((cfg) => {
         const stats = statsByResourceType[cfg.id] || {
           count: 0,
           left: 0,
           summaryCount: 0,
           summaryConfigCount: 0
         };
-        const value = cfg.type === 'multiple' ? stats.summaryCount : stats.left;
+        const value = cfg.type === "multiple" ? stats.summaryCount : stats.left;
         if (value < bottleneckValue) {
           bottleneckValue = value;
           bottleneckResourceTypeId = cfg.id;
         }
       });
-      const bottleneckStats = bottleneckResourceTypeId !== undefined ? statsByResourceType[bottleneckResourceTypeId] || {
+      const bottleneckStats = bottleneckResourceTypeId !== void 0 ? statsByResourceType[bottleneckResourceTypeId] || {
         count: 0,
         left: 0,
         summaryCount: 0,
         summaryConfigCount: 0
-      } : {
-        count: 0,
-        left: 0,
-        summaryCount: 0,
-        summaryConfigCount: 0
-      };
-      const bottleneckConfig = bottleneckResourceTypeId !== undefined ? resourceTypeConfigById.get(bottleneckResourceTypeId) : undefined;
-      let status = 'sold_out';
-      if (bottleneckStats.left === 0) status = 'sold_out';else if (!bottleneckConfig || bottleneckStats.summaryConfigCount === 0) status = 'sold_out';else if (bottleneckConfig.type === 'multiple') {
+      } : { count: 0, left: 0, summaryCount: 0, summaryConfigCount: 0 };
+      const bottleneckConfig = bottleneckResourceTypeId !== void 0 ? resourceTypeConfigById.get(bottleneckResourceTypeId) : void 0;
+      let status = "sold_out";
+      if (bottleneckStats.left === 0)
+        status = "sold_out";
+      else if (!bottleneckConfig || bottleneckStats.summaryConfigCount === 0)
+        status = "sold_out";
+      else if (bottleneckConfig.type === "multiple") {
         const usageRatio = bottleneckStats.summaryCount / bottleneckStats.summaryConfigCount;
-        if (usageRatio > 0.5) status = 'lots_of_space';else if (bottleneckStats.summaryCount > 0) status = 'filling_up_fast';else status = 'sold_out';
+        if (usageRatio > 0.5)
+          status = "lots_of_space";
+        else if (bottleneckStats.summaryCount > 0)
+          status = "filling_up_fast";
+        else
+          status = "sold_out";
       } else {
         const usageRatio = bottleneckStats.left / bottleneckStats.summaryConfigCount;
-        if (usageRatio > 0.5) status = 'lots_of_space';else if (bottleneckStats.count > 0) status = 'filling_up_fast';else status = 'sold_out';
+        if (usageRatio > 0.5)
+          status = "lots_of_space";
+        else if (bottleneckStats.count > 0)
+          status = "filling_up_fast";
+        else
+          status = "sold_out";
       }
       return {
-        start_time: startDayJs.format('HH:mm'),
-        end_time: endDayJs.format('HH:mm'),
+        start_time: startDayJs.format("HH:mm"),
+        end_time: endDayJs.format("HH:mm"),
         start_at: startDayJs,
         end_at: endDayJs,
         count: bottleneckStats.count,
@@ -2289,7 +2254,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     });
     return formatScheduleTimeSlots;
   }
-
   // 提供给 UI的方法，当前步骤是选择商品，下一步不管是什么都需要在这里做一次检测
   // 时长类商品关联的资源为多个预约时，在点击进入"选择资源"步骤之前，需要检测当前所有资源的总容量
   // 选择商品数量大于所有资源配置的总容量时，不能进入下一步，需要在"选择商品"这一步时提示。
@@ -2298,27 +2262,27 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    * 找到多个资源的公共可用时间段
    */
   findCommonAvailableTimeSlots(resources) {
-    if (resources.length === 0) return [];
-    // 收集所有资源的时间段，转换为统一的时间格式
-    const allTimeSlots = resources.map(resource => resource.times.map(time => ({
-      start: (0, _dayjs.default)(time.start_at),
-      end: (0, _dayjs.default)(time.end_at)
-    })));
-    // 找到公共时间段的交集
-    let commonSlots = allTimeSlots[0]; // 从第一个资源的时间段开始
-
-    // 与其他资源的时间段求交集
+    if (resources.length === 0)
+      return [];
+    console.log(`计算 ${resources.length} 个资源的公共时间段`);
+    const allTimeSlots = resources.map(
+      (resource) => resource.times.map((time) => ({
+        start: (0, import_dayjs.default)(time.start_at),
+        end: (0, import_dayjs.default)(time.end_at)
+      }))
+    );
+    console.log("所有资源的时间段:", allTimeSlots.map(
+      (slots) => slots.map((slot) => `${slot.start.format("HH:mm")}-${slot.end.format("HH:mm")}`)
+    ));
+    let commonSlots = allTimeSlots[0];
+    console.log("初始公共时间段:", commonSlots.map((slot) => `${slot.start.format("HH:mm")}-${slot.end.format("HH:mm")}`));
     for (let i = 1; i < allTimeSlots.length; i++) {
       const currentResourceSlots = allTimeSlots[i];
       const intersections = [];
-
-      // 计算当前公共时间段与下一个资源时间段的交集
-      commonSlots.forEach(commonSlot => {
-        currentResourceSlots.forEach(currentSlot => {
+      commonSlots.forEach((commonSlot) => {
+        currentResourceSlots.forEach((currentSlot) => {
           const overlapStart = commonSlot.start.isAfter(currentSlot.start) ? commonSlot.start : currentSlot.start;
           const overlapEnd = commonSlot.end.isBefore(currentSlot.end) ? commonSlot.end : currentSlot.end;
-
-          // 如果有重叠时间且重叠时间大于0
           if (overlapStart.isBefore(overlapEnd)) {
             intersections.push({
               start: overlapStart,
@@ -2328,88 +2292,74 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
         });
       });
       if (intersections.length === 0) {
+        console.log(`资源${i}与当前公共时间段无交集，跳过该资源`);
         continue;
       }
       commonSlots = intersections;
+      console.log(`与资源${i}求交集后的公共时间段:`, commonSlots.map((slot) => `${slot.start.format("HH:mm")}-${slot.end.format("HH:mm")}`));
     }
-
-    // 格式化返回结果
-    const result = commonSlots.map(slot => ({
-      startTime: slot.start.format('HH:mm'),
-      endTime: slot.end.format('HH:mm')
+    const result = commonSlots.map((slot) => ({
+      startTime: slot.start.format("HH:mm"),
+      endTime: slot.end.format("HH:mm")
     }));
+    console.log("最终公共时间段:", result);
     return result;
   }
   checkMaxDurationCapacity() {
-    const cartItems = this.store.cart.getItems().filter(item => !(0, _utils5.isNormalProduct)(item._productOrigin));
-    if (cartItems.length === 0) return {
-      success: true,
-      minAvailableCount: 0
-    };
-
-    // 将购物车商品分为有时间的和没有时间的
+    var _a, _b;
+    const cartItems = this.store.cart.getItems().filter((item) => !(0, import_utils5.isNormalProduct)(item._productOrigin));
+    if (cartItems.length === 0)
+      return { success: true, minAvailableCount: 0 };
     const itemsWithTime = [];
     const itemsWithoutTime = [];
-    // 记录每种资源类型的可用数量
     const availableCountsByResourceType = [];
-    cartItems.forEach(cartItem => {
+    cartItems.forEach((cartItem) => {
       if (cartItem.start_time && cartItem.end_time && cartItem.start_date) {
         itemsWithTime.push(cartItem);
       } else {
         itemsWithoutTime.push(cartItem);
       }
     });
-
-    // 处理没有时间的商品，为它们分配公共可用时间的第一个时间片
     const processedItemsWithoutTime = [];
     if (itemsWithoutTime.length > 0) {
-      // 按资源类型分组处理没有时间的商品
       const itemsByResourceType = {};
-      itemsWithoutTime.forEach(cartItem => {
-        if (!cartItem._productOrigin) return;
-        const resourceTypes = cartItem._productOrigin.product_resource?.resources || [];
-        resourceTypes.forEach(resourceType => {
+      itemsWithoutTime.forEach((cartItem) => {
+        var _a2;
+        if (!cartItem._productOrigin)
+          return;
+        const resourceTypes = ((_a2 = cartItem._productOrigin.product_resource) == null ? void 0 : _a2.resources) || [];
+        resourceTypes.forEach((resourceType) => {
+          var _a3;
           if (resourceType.status === 1) {
-            const resourceCode = resourceType.code || resourceType.id?.toString();
+            const resourceCode = resourceType.code || ((_a3 = resourceType.id) == null ? void 0 : _a3.toString());
             if (!itemsByResourceType[resourceCode]) {
               itemsByResourceType[resourceCode] = [];
             }
-            // 避免重复添加同一个商品
-            // 如果之前添加过的依赖相同资源的跟我现在是同一个 holder，也不需要重复添加
-            if (itemsByResourceType[resourceCode].find(item => item.holder_id === cartItem.holder_id)) {
+            if (itemsByResourceType[resourceCode].find((item) => item.holder_id === cartItem.holder_id)) {
               return;
             }
-            if (!itemsByResourceType[resourceCode].find(item => item._id === cartItem._id)) {
+            if (!itemsByResourceType[resourceCode].find((item) => item._id === cartItem._id)) {
               itemsByResourceType[resourceCode].push(cartItem);
             }
           }
         });
       });
-
-      // 为每种资源类型检查容量
       const dateRange = this.store.date.getDateRange();
-      if (!dateRange || dateRange.length === 0) return {
-        success: false,
-        minAvailableCount: 0
-      };
+      if (!dateRange || dateRange.length === 0)
+        return { success: false, minAvailableCount: 0 };
       const resourcesDates = this.store.date.getDateList();
-      const targetResourceDate = resourcesDates.find(n => n.date === dateRange[0].date);
-      if (!targetResourceDate) return {
-        success: false,
-        minAvailableCount: 0
-      };
-      const resourcesMap = (0, _utils2.getResourcesMap)(targetResourceDate.resource || []);
-
-      // 从购物车商品中获取资源类型配置，建立 resourceCode 到 form_id 的映射关系
+      const targetResourceDate = resourcesDates.find((n) => n.date === dateRange[0].date);
+      if (!targetResourceDate)
+        return { success: false, minAvailableCount: 0 };
+      const resourcesMap = (0, import_utils2.getResourcesMap)(targetResourceDate.resource || []);
       const resourceCodeToFormIdMap = {};
-
-      // 遍历购物车中的商品，收集所有资源类型配置
-      Object.values(itemsByResourceType).flat().forEach(cartItem => {
-        if (cartItem._productOrigin?.product_resource?.resources) {
-          cartItem._productOrigin.product_resource.resources.forEach(resourceConfig => {
-            // 只处理启用的资源类型 (status === 1)
+      Object.values(itemsByResourceType).flat().forEach((cartItem) => {
+        var _a2, _b2;
+        if ((_b2 = (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b2.resources) {
+          cartItem._productOrigin.product_resource.resources.forEach((resourceConfig) => {
+            var _a3, _b3;
             if (resourceConfig.status === 1 && resourceConfig.code) {
-              const formId = resourceConfig.id?.toString() || resourceConfig.resource_type_id?.toString();
+              const formId = ((_a3 = resourceConfig.id) == null ? void 0 : _a3.toString()) || ((_b3 = resourceConfig.resource_type_id) == null ? void 0 : _b3.toString());
               if (formId) {
                 resourceCodeToFormIdMap[resourceConfig.code] = formId;
               }
@@ -2419,77 +2369,60 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       });
       let hasCapacityIssue = false;
       const resourceCapacityInfo = [];
-
-      // 用于跟踪已处理的商品，避免重复添加
-      const processedCartItemIds = new Set();
-
-      // 先检查所有资源类型，收集可用数量信息
+      const processedCartItemIds = /* @__PURE__ */ new Set();
       for (const [resourceCode, items] of Object.entries(itemsByResourceType)) {
-        // 获取该资源类型对应的 form_id
         const targetFormId = resourceCodeToFormIdMap[resourceCode];
         if (!targetFormId) {
-          return {
-            success: false,
-            minAvailableCount: 0
-          };
+          console.log(`资源类型 ${resourceCode} 找不到对应的 form_id`);
+          return { success: false, minAvailableCount: 0 };
         }
-
-        // 获取该资源类型的所有资源
         const resourcesOfThisType = [];
-        items.forEach(cartItem => {
-          const productResourceIds = (0, _capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
-          productResourceIds.forEach(resourceId => {
+        items.forEach((cartItem) => {
+          const productResourceIds = (0, import_capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
+          productResourceIds.forEach((resourceId) => {
+            var _a2;
             const resource = resourcesMap[resourceId];
-            if (resource && resource.form_id?.toString() === targetFormId) {
-              // 避免重复添加同一个资源
-              if (!resourcesOfThisType.find(r => r.id === resource.id)) {
+            if (resource && ((_a2 = resource.form_id) == null ? void 0 : _a2.toString()) === targetFormId) {
+              if (!resourcesOfThisType.find((r) => r.id === resource.id)) {
                 resourcesOfThisType.push(resource);
               }
             }
           });
         });
         if (resourcesOfThisType.length === 0) {
-          return {
-            success: false,
-            minAvailableCount: 0
-          };
+          console.log(`资源类型 ${resourceCode} 没有找到可用资源`);
+          return { success: false, minAvailableCount: 0 };
         }
-
-        // 检查资源类型（单个预约 vs 多个预约）
-        // 从商品配置中获取资源类型信息
         let resourceTypeConfig = null;
         for (const cartItem of items) {
-          if (cartItem._productOrigin?.product_resource?.resources) {
-            resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(r => r.code === resourceCode && r.status === 1);
-            if (resourceTypeConfig) break;
+          if ((_b = (_a = cartItem._productOrigin) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) {
+            resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(
+              (r) => r.code === resourceCode && r.status === 1
+            );
+            if (resourceTypeConfig)
+              break;
           }
         }
-        const isMultipleBooking = resourceTypeConfig?.type === 'multiple';
+        const isMultipleBooking = (resourceTypeConfig == null ? void 0 : resourceTypeConfig.type) === "multiple";
         let totalAvailable;
         let requiredAmount;
         let availableAmount;
         if (isMultipleBooking) {
-          // 多个预约：计算容量
           totalAvailable = resourcesOfThisType.reduce((sum, resource) => {
             return sum + (resource.capacity || 0);
           }, 0);
           requiredAmount = items.reduce((sum, cartItem) => {
-            const {
-              currentCapacity
-            } = (0, _capacity.getCapacityInfoByCartItem)(cartItem);
+            const { currentCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(cartItem);
             return sum + currentCapacity;
           }, 0);
           availableAmount = Math.max(0, totalAvailable - requiredAmount);
         } else {
-          // 单个预约：计算资源个数
           totalAvailable = resourcesOfThisType.length;
           requiredAmount = items.reduce((sum, cartItem) => {
             return sum + (cartItem.num || 1);
           }, 0);
           availableAmount = Math.max(0, totalAvailable - requiredAmount);
         }
-
-        // 记录资源容量信息
         resourceCapacityInfo.push({
           code: resourceCode,
           available: availableAmount,
@@ -2498,27 +2431,23 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
           isMultiple: isMultipleBooking
         });
         availableCountsByResourceType.push(availableAmount);
-
-        // 检查是否有容量问题
         if (requiredAmount > totalAvailable) {
           hasCapacityIssue = true;
+          console.log(`资源类型 ${resourceCode} ${isMultipleBooking ? "容量" : "资源数量"}不足: 需要 ${requiredAmount}, 总共 ${totalAvailable}`);
         }
-
-        // 为通过检测的商品分配一个公共可用时间段
-
-        // 找到所有资源都可用的时间段
+        console.log(`资源类型 ${resourceCode} 的资源时间信息:`, resourcesOfThisType.map((r) => ({
+          id: r.id,
+          times: r.times.map((t) => `${t.start_at} - ${t.end_at}`)
+        })));
         const commonTimeSlots = this.findCommonAvailableTimeSlots(resourcesOfThisType);
+        console.log(`资源类型 ${resourceCode} 的公共时间段:`, commonTimeSlots);
         if (commonTimeSlots.length === 0) {
-          return {
-            success: false,
-            minAvailableCount: 0
-          };
+          console.log(`资源类型 ${resourceCode} 没有公共可用时间段`);
+          return { success: false, minAvailableCount: 0 };
         }
-
-        // 使用第一个公共可用时间段，但只处理未处理过的商品
         const firstCommonSlot = commonTimeSlots[0];
-        items.forEach(cartItem => {
-          // 只处理未处理过的商品，避免重复添加
+        console.log(`使用公共时间段: ${firstCommonSlot.startTime} - ${firstCommonSlot.endTime}`);
+        items.forEach((cartItem) => {
           if (!processedCartItemIds.has(cartItem._id)) {
             processedCartItemIds.add(cartItem._id);
             const processedItem = {
@@ -2532,93 +2461,59 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
           }
         });
       }
-
-      // 如果有容量问题，找出限制最严格的资源类型，返回其总容量
       if (hasCapacityIssue) {
-        // 找出超出容量的资源类型中，总容量最少的那个
-        const overCapacityResources = resourceCapacityInfo.filter(info => info.required > info.total);
+        const overCapacityResources = resourceCapacityInfo.filter((info) => info.required > info.total);
         if (overCapacityResources.length > 0) {
-          const minTotalCapacity = Math.min(...overCapacityResources.map(info => info.total));
-          return {
-            success: false,
-            minAvailableCount: minTotalCapacity
-          };
+          const minTotalCapacity2 = Math.min(...overCapacityResources.map((info) => info.total));
+          return { success: false, minAvailableCount: minTotalCapacity2 };
         }
-        // 如果没有超出容量的（理论上不应该发生），返回总容量最少的
-        const minTotalCapacity = Math.min(...resourceCapacityInfo.map(info => info.total));
-        return {
-          success: false,
-          minAvailableCount: minTotalCapacity
-        };
+        const minTotalCapacity = Math.min(...resourceCapacityInfo.map((info) => info.total));
+        return { success: false, minAvailableCount: minTotalCapacity };
       }
     }
-
-    // 合并所有商品（有时间的 + 处理后的没有时间的）
     const allProcessedItems = [...itemsWithTime, ...processedItemsWithoutTime];
-
-    // 按时间段分组检查
     const cartItemsByTimeSlot = {};
-    allProcessedItems.forEach(cartItem => {
-      if (!cartItem.start_time || !cartItem.end_time || !cartItem.start_date) return;
+    allProcessedItems.forEach((cartItem) => {
+      if (!cartItem.start_time || !cartItem.end_time || !cartItem.start_date)
+        return;
       const timeSlotKey = `${cartItem.start_date}_${cartItem.start_time}_${cartItem.end_date || cartItem.start_date}_${cartItem.end_time}`;
       if (!cartItemsByTimeSlot[timeSlotKey]) {
         cartItemsByTimeSlot[timeSlotKey] = [];
       }
       cartItemsByTimeSlot[timeSlotKey].push(cartItem);
     });
-    // 检查每个时间段是否有足够的资源容量
     for (const [timeSlotKey, itemsInTimeSlot] of Object.entries(cartItemsByTimeSlot)) {
-      const [startDate, startTime, endDate, endTime] = timeSlotKey.split('_');
+      const [startDate, startTime, endDate, endTime] = timeSlotKey.split("_");
       const timeSlotStart = `${startDate} ${startTime}`;
       const timeSlotEnd = `${endDate} ${endTime}`;
-
-      // 获取这个时间段所有商品涉及的资源
       const allResourcesForTimeSlot = [];
-      const resourcesIdSet = new Set();
-
-      // 获取资源数据
+      const resourcesIdSet = /* @__PURE__ */ new Set();
       const dateRange = this.store.date.getDateRange();
       const resourcesDates = this.store.date.getDateList();
-      const targetResourceDate = resourcesDates.find(n => n.date === startDate);
-      if (!targetResourceDate) continue;
-      const resourcesMap = (0, _utils2.getResourcesMap)(targetResourceDate.resource || []);
-      itemsInTimeSlot.forEach(cartItem => {
-        if (!cartItem._productOrigin) return;
-
-        // 获取商品的资源配置
-        const productResourceIds = (0, _capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
-        productResourceIds.forEach(resourceId => {
+      const targetResourceDate = resourcesDates.find((n) => n.date === startDate);
+      if (!targetResourceDate)
+        continue;
+      const resourcesMap = (0, import_utils2.getResourcesMap)(targetResourceDate.resource || []);
+      itemsInTimeSlot.forEach((cartItem) => {
+        if (!cartItem._productOrigin)
+          return;
+        const productResourceIds = (0, import_capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
+        productResourceIds.forEach((resourceId) => {
           if (resourcesMap[resourceId] && !resourcesIdSet.has(resourceId)) {
             resourcesIdSet.add(resourceId);
             allResourcesForTimeSlot.push(resourcesMap[resourceId]);
           }
         });
       });
-
-      // 按资源类型分组检查容量
-      const {
-        success,
-        required,
-        available
-      } = (0, _capacity.checkTimeSlotCapacity)(timeSlotStart, timeSlotEnd, itemsInTimeSlot, allResourcesForTimeSlot);
+      const { success, required, available } = (0, import_capacity.checkTimeSlotCapacity)(timeSlotStart, timeSlotEnd, itemsInTimeSlot, allResourcesForTimeSlot);
       if (!success) {
-        // 如果有可用数量记录，返回最小值；否则返回 0
-        const minAvailableCount = availableCountsByResourceType.length > 0 ? Math.min(...availableCountsByResourceType) : 0;
-        return {
-          success: false,
-          minAvailableCount
-        };
+        const minAvailableCount2 = availableCountsByResourceType.length > 0 ? Math.min(...availableCountsByResourceType) : 0;
+        return { success: false, minAvailableCount: minAvailableCount2 };
       }
     }
-
-    // 全部通过检测，返回成功和最小可用数量
     const minAvailableCount = availableCountsByResourceType.length > 0 ? Math.min(...availableCountsByResourceType) : 0;
-    return {
-      success: true,
-      minAvailableCount
-    };
+    return { success: true, minAvailableCount };
   }
-
   /**
    * 将 ProductData 转换为 CartItem，但不添加到购物车
    * 参考 addProductToCart 方法的实现
@@ -2635,34 +2530,21 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       product_variant_id,
       quantity = 1
     } = product || {};
-
-    // 处理商品数据，类似 addProductToCart 中的逻辑
-    const productData = {
-      ...origin,
-      product_variant_id
-    };
-
-    // 处理组合商品
-    const processedProduct = (0, _utils.handleVariantProduct)(productData);
-
-    // 如果没有传入账户，获取当前活跃账户
+    const productData = { ...origin, product_variant_id };
+    const processedProduct = (0, import_utils.handleVariantProduct)(productData);
     if (!account) {
       const activeAccount = this.getActiveAccount();
       if (activeAccount) {
         account = activeAccount;
       }
     }
-
-    // 创建基础的 CartItem
     const cartItem = {
-      _id: (0, _utils.getUniqueId)('temp_'),
-      _origin: (0, _utils.createCartItemOrigin)(),
+      _id: (0, import_utils.getUniqueId)("temp_"),
+      _origin: (0, import_utils.createCartItemOrigin)(),
       _productOrigin: processedProduct,
       _productInit: product
     };
-
-    // 使用格式化函数填充 CartItem 数据
-    (0, _utils.formatProductToCartItem)({
+    (0, import_utils.formatProductToCartItem)({
       cartItem,
       product: processedProduct,
       bundle,
@@ -2670,18 +2552,14 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       product_variant_id,
       quantity
     });
-
-    // 如果有日期信息，格式化日期到购物车
     if (date) {
-      (0, _utils.formatDateToCartItem)({
+      (0, import_utils.formatDateToCartItem)({
         cartItem,
         date
       });
     }
-
-    // 如果有账户信息，格式化账户到购物车
     if (account) {
-      (0, _utils.formatAccountToCartItem)({
+      (0, import_utils.formatAccountToCartItem)({
         cartItem,
         account
       });
@@ -2693,79 +2571,59 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     date,
     account
   }) {
-    const cartItems = this.store.cart.getItems().filter(item => !(0, _utils5.isNormalProduct)(item._productOrigin));
-
-    // 将 ProductData 转换为 CartItem 但不真正添加到购物车
-    const currentCartItem = this.convertProductToCartItem({
-      product,
-      date,
-      account
-    });
+    var _a, _b;
+    const cartItems = this.store.cart.getItems().filter((item) => !(0, import_utils5.isNormalProduct)(item._productOrigin));
+    const currentCartItem = this.convertProductToCartItem({ product, date, account });
     cartItems.push(currentCartItem);
-    if (cartItems.length === 0) return {
-      success: true,
-      minAvailableCount: 0
-    };
-
-    // 将购物车商品分为有时间的和没有时间的
+    if (cartItems.length === 0)
+      return { success: true, minAvailableCount: 0 };
     const itemsWithTime = [];
     const itemsWithoutTime = [];
-    // 记录每种资源类型的可用数量
     const availableCountsByResourceType = [];
-    cartItems.forEach(cartItem => {
+    cartItems.forEach((cartItem) => {
       if (cartItem.start_time && cartItem.end_time && cartItem.start_date) {
         itemsWithTime.push(cartItem);
       } else {
         itemsWithoutTime.push(cartItem);
       }
     });
-
-    // 处理没有时间的商品，为它们分配公共可用时间的第一个时间片
     const processedItemsWithoutTime = [];
     if (itemsWithoutTime.length > 0) {
-      // 按资源类型分组处理没有时间的商品
       const itemsByResourceType = {};
-      itemsWithoutTime.forEach(cartItem => {
-        if (!cartItem._productOrigin) return;
-        const resourceTypes = cartItem._productOrigin.product_resource?.resources || [];
-        resourceTypes.forEach(resourceType => {
+      itemsWithoutTime.forEach((cartItem) => {
+        var _a2;
+        if (!cartItem._productOrigin)
+          return;
+        const resourceTypes = ((_a2 = cartItem._productOrigin.product_resource) == null ? void 0 : _a2.resources) || [];
+        resourceTypes.forEach((resourceType) => {
+          var _a3;
           if (resourceType.status === 1) {
-            const resourceCode = resourceType.code || resourceType.id?.toString();
+            const resourceCode = resourceType.code || ((_a3 = resourceType.id) == null ? void 0 : _a3.toString());
             if (!itemsByResourceType[resourceCode]) {
               itemsByResourceType[resourceCode] = [];
             }
-            // 避免重复添加同一个商品
-            if (!itemsByResourceType[resourceCode].find(item => item._id === cartItem._id)) {
+            if (!itemsByResourceType[resourceCode].find((item) => item._id === cartItem._id)) {
               itemsByResourceType[resourceCode].push(cartItem);
             }
           }
         });
       });
-
-      // 为每种资源类型检查容量
       const dateRange = this.store.date.getDateRange();
-      if (!dateRange || dateRange.length === 0) return {
-        success: false,
-        minAvailableCount: 0
-      };
+      if (!dateRange || dateRange.length === 0)
+        return { success: false, minAvailableCount: 0 };
       const resourcesDates = this.store.date.getDateList();
-      const targetResourceDate = resourcesDates.find(n => n.date === dateRange[0].date);
-      if (!targetResourceDate) return {
-        success: false,
-        minAvailableCount: 0
-      };
-      const resourcesMap = (0, _utils2.getResourcesMap)(targetResourceDate.resource || []);
-
-      // 从购物车商品中获取资源类型配置，建立 resourceCode 到 form_id 的映射关系
+      const targetResourceDate = resourcesDates.find((n) => n.date === dateRange[0].date);
+      if (!targetResourceDate)
+        return { success: false, minAvailableCount: 0 };
+      const resourcesMap = (0, import_utils2.getResourcesMap)(targetResourceDate.resource || []);
       const resourceCodeToFormIdMap = {};
-
-      // 遍历购物车中的商品，收集所有资源类型配置
-      Object.values(itemsByResourceType).flat().forEach(cartItem => {
-        if (cartItem._productOrigin?.product_resource?.resources) {
-          cartItem._productOrigin.product_resource.resources.forEach(resourceConfig => {
-            // 只处理启用的资源类型 (status === 1)
+      Object.values(itemsByResourceType).flat().forEach((cartItem) => {
+        var _a2, _b2;
+        if ((_b2 = (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.product_resource) == null ? void 0 : _b2.resources) {
+          cartItem._productOrigin.product_resource.resources.forEach((resourceConfig) => {
+            var _a3, _b3;
             if (resourceConfig.status === 1 && resourceConfig.code) {
-              const formId = resourceConfig.id?.toString() || resourceConfig.resource_type_id?.toString();
+              const formId = ((_a3 = resourceConfig.id) == null ? void 0 : _a3.toString()) || ((_b3 = resourceConfig.resource_type_id) == null ? void 0 : _b3.toString());
               if (formId) {
                 resourceCodeToFormIdMap[resourceConfig.code] = formId;
               }
@@ -2775,77 +2633,60 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       });
       let hasCapacityIssue = false;
       const resourceCapacityInfo = [];
-
-      // 用于跟踪已处理的商品，避免重复添加
-      const processedCartItemIds = new Set();
-
-      // 先检查所有资源类型，收集可用数量信息
+      const processedCartItemIds = /* @__PURE__ */ new Set();
       for (const [resourceCode, items] of Object.entries(itemsByResourceType)) {
-        // 获取该资源类型对应的 form_id
         const targetFormId = resourceCodeToFormIdMap[resourceCode];
         if (!targetFormId) {
-          return {
-            success: false,
-            minAvailableCount: 0
-          };
+          console.log(`资源类型 ${resourceCode} 找不到对应的 form_id`);
+          return { success: false, minAvailableCount: 0 };
         }
-
-        // 获取该资源类型的所有资源
         const resourcesOfThisType = [];
-        items.forEach(cartItem => {
-          const productResourceIds = (0, _capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
-          productResourceIds.forEach(resourceId => {
+        items.forEach((cartItem) => {
+          const productResourceIds = (0, import_capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
+          productResourceIds.forEach((resourceId) => {
+            var _a2;
             const resource = resourcesMap[resourceId];
-            if (resource && resource.form_id?.toString() === targetFormId) {
-              // 避免重复添加同一个资源
-              if (!resourcesOfThisType.find(r => r.id === resource.id)) {
+            if (resource && ((_a2 = resource.form_id) == null ? void 0 : _a2.toString()) === targetFormId) {
+              if (!resourcesOfThisType.find((r) => r.id === resource.id)) {
                 resourcesOfThisType.push(resource);
               }
             }
           });
         });
         if (resourcesOfThisType.length === 0) {
-          return {
-            success: false,
-            minAvailableCount: 0
-          };
+          console.log(`资源类型 ${resourceCode} 没有找到可用资源`);
+          return { success: false, minAvailableCount: 0 };
         }
-
-        // 检查资源类型（单个预约 vs 多个预约）
-        // 从商品配置中获取资源类型信息
         let resourceTypeConfig = null;
         for (const cartItem of items) {
-          if (cartItem._productOrigin?.product_resource?.resources) {
-            resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(r => r.code === resourceCode && r.status === 1);
-            if (resourceTypeConfig) break;
+          if ((_b = (_a = cartItem._productOrigin) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) {
+            resourceTypeConfig = cartItem._productOrigin.product_resource.resources.find(
+              (r) => r.code === resourceCode && r.status === 1
+            );
+            if (resourceTypeConfig)
+              break;
           }
         }
-        const isMultipleBooking = resourceTypeConfig?.type === 'multiple';
+        const isMultipleBooking = (resourceTypeConfig == null ? void 0 : resourceTypeConfig.type) === "multiple";
         let totalAvailable;
         let requiredAmount;
         let availableAmount;
         if (isMultipleBooking) {
-          // 多个预约：计算容量
           totalAvailable = resourcesOfThisType.reduce((sum, resource) => {
             return sum + (resource.capacity || 0);
           }, 0);
           requiredAmount = items.reduce((sum, cartItem) => {
-            const {
-              currentCapacity
-            } = (0, _capacity.getCapacityInfoByCartItem)(cartItem);
+            const { currentCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(cartItem);
             return sum + currentCapacity;
           }, 0);
           availableAmount = Math.max(0, totalAvailable - requiredAmount);
         } else {
-          // 单个预约：计算资源个数
           totalAvailable = resourcesOfThisType.length;
           requiredAmount = items.reduce((sum, cartItem) => {
             return sum + (cartItem.num || 1);
           }, 0);
           availableAmount = Math.max(0, totalAvailable - requiredAmount);
         }
-
-        // 记录资源容量信息
         resourceCapacityInfo.push({
           code: resourceCode,
           available: availableAmount,
@@ -2854,27 +2695,23 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
           isMultiple: isMultipleBooking
         });
         availableCountsByResourceType.push(availableAmount);
-
-        // 检查是否有容量问题
         if (requiredAmount > totalAvailable) {
           hasCapacityIssue = true;
+          console.log(`资源类型 ${resourceCode} ${isMultipleBooking ? "容量" : "资源数量"}不足: 需要 ${requiredAmount}, 总共 ${totalAvailable}`);
         }
-
-        // 为通过检测的商品分配一个公共可用时间段
-
-        // 找到所有资源都可用的时间段
+        console.log(`资源类型 ${resourceCode} 的资源时间信息:`, resourcesOfThisType.map((r) => ({
+          id: r.id,
+          times: r.times.map((t) => `${t.start_at} - ${t.end_at}`)
+        })));
         const commonTimeSlots = this.findCommonAvailableTimeSlots(resourcesOfThisType);
+        console.log(`资源类型 ${resourceCode} 的公共时间段:`, commonTimeSlots);
         if (commonTimeSlots.length === 0) {
-          return {
-            success: false,
-            minAvailableCount: 0
-          };
+          console.log(`资源类型 ${resourceCode} 没有公共可用时间段`);
+          return { success: false, minAvailableCount: 0 };
         }
-
-        // 使用第一个公共可用时间段，但只处理未处理过的商品
         const firstCommonSlot = commonTimeSlots[0];
-        items.forEach(cartItem => {
-          // 只处理未处理过的商品，避免重复添加
+        console.log(`使用公共时间段: ${firstCommonSlot.startTime} - ${firstCommonSlot.endTime}`);
+        items.forEach((cartItem) => {
           if (!processedCartItemIds.has(cartItem._id)) {
             processedCartItemIds.add(cartItem._id);
             const processedItem = {
@@ -2888,120 +2725,83 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
           }
         });
       }
-
-      // 如果有容量问题，找出限制最严格的资源类型，返回其总容量
       if (hasCapacityIssue) {
-        // 找出超出容量的资源类型中，总容量最少的那个
-        const overCapacityResources = resourceCapacityInfo.filter(info => info.required > info.total);
+        const overCapacityResources = resourceCapacityInfo.filter((info) => info.required > info.total);
         if (overCapacityResources.length > 0) {
-          const minTotalCapacity = Math.min(...overCapacityResources.map(info => info.total));
-          return {
-            success: false,
-            minAvailableCount: minTotalCapacity
-          };
+          const minTotalCapacity2 = Math.min(...overCapacityResources.map((info) => info.total));
+          return { success: false, minAvailableCount: minTotalCapacity2 };
         }
-        // 如果没有超出容量的（理论上不应该发生），返回总容量最少的
-        const minTotalCapacity = Math.min(...resourceCapacityInfo.map(info => info.total));
-        return {
-          success: false,
-          minAvailableCount: minTotalCapacity
-        };
+        const minTotalCapacity = Math.min(...resourceCapacityInfo.map((info) => info.total));
+        return { success: false, minAvailableCount: minTotalCapacity };
       }
     }
-
-    // 合并所有商品（有时间的 + 处理后的没有时间的）
     const allProcessedItems = [...itemsWithTime, ...processedItemsWithoutTime];
-
-    // 按时间段分组检查
     const cartItemsByTimeSlot = {};
-    allProcessedItems.forEach(cartItem => {
-      if (!cartItem.start_time || !cartItem.end_time || !cartItem.start_date) return;
+    allProcessedItems.forEach((cartItem) => {
+      if (!cartItem.start_time || !cartItem.end_time || !cartItem.start_date)
+        return;
       const timeSlotKey = `${cartItem.start_date}_${cartItem.start_time}_${cartItem.end_date || cartItem.start_date}_${cartItem.end_time}`;
       if (!cartItemsByTimeSlot[timeSlotKey]) {
         cartItemsByTimeSlot[timeSlotKey] = [];
       }
       cartItemsByTimeSlot[timeSlotKey].push(cartItem);
     });
-    // 检查每个时间段是否有足够的资源容量
     for (const [timeSlotKey, itemsInTimeSlot] of Object.entries(cartItemsByTimeSlot)) {
-      const [startDate, startTime, endDate, endTime] = timeSlotKey.split('_');
+      const [startDate, startTime, endDate, endTime] = timeSlotKey.split("_");
       const timeSlotStart = `${startDate} ${startTime}`;
       const timeSlotEnd = `${endDate} ${endTime}`;
-
-      // 获取这个时间段所有商品涉及的资源
       const allResourcesForTimeSlot = [];
-      const resourcesIdSet = new Set();
-
-      // 获取资源数据
-      // const dateRange = this.store.date.getDateRange();
+      const resourcesIdSet = /* @__PURE__ */ new Set();
       const resourcesDates = this.store.date.getDateList();
-      const targetResourceDate = resourcesDates.find(n => n.date === startDate);
-      if (!targetResourceDate) continue;
-      const resourcesMap = (0, _utils2.getResourcesMap)(targetResourceDate.resource || []);
-      itemsInTimeSlot.forEach(cartItem => {
-        if (!cartItem._productOrigin) return;
-
-        // 获取商品的资源配置
-        const productResourceIds = (0, _capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
-        productResourceIds.forEach(resourceId => {
+      const targetResourceDate = resourcesDates.find((n) => n.date === startDate);
+      if (!targetResourceDate)
+        continue;
+      const resourcesMap = (0, import_utils2.getResourcesMap)(targetResourceDate.resource || []);
+      itemsInTimeSlot.forEach((cartItem) => {
+        if (!cartItem._productOrigin)
+          return;
+        const productResourceIds = (0, import_capacity.getResourcesIdsByProduct)(cartItem._productOrigin);
+        productResourceIds.forEach((resourceId) => {
           if (resourcesMap[resourceId] && !resourcesIdSet.has(resourceId)) {
             resourcesIdSet.add(resourceId);
             allResourcesForTimeSlot.push(resourcesMap[resourceId]);
           }
         });
       });
-
-      // 按资源类型分组检查容量
-      const {
-        success,
-        required,
-        available
-      } = (0, _capacity.checkTimeSlotCapacity)(timeSlotStart, timeSlotEnd, itemsInTimeSlot, allResourcesForTimeSlot);
+      const { success, required, available } = (0, import_capacity.checkTimeSlotCapacity)(timeSlotStart, timeSlotEnd, itemsInTimeSlot, allResourcesForTimeSlot);
       if (!success) {
-        // 如果有可用数量记录，返回最小值；否则返回 0
-        // const minAvailableCount = availableCountsByResourceType.length > 0 ? Math.min(...availableCountsByResourceType) : 0;
-        return {
-          success: false,
-          minAvailableCount: available
-        };
+        return { success: false, minAvailableCount: available };
       }
     }
-
-    // 全部通过检测，返回成功和最小可用数量
     const minAvailableCount = availableCountsByResourceType.length > 0 ? Math.min(...availableCountsByResourceType) : 0;
-    return {
-      success: true,
-      minAvailableCount
-    };
+    return { success: true, minAvailableCount };
   }
   setOtherData(key, value) {
     this.otherData[key] = value;
     this.checkSaveCache({
       cacheId: this.cacheId,
       fatherModule: this.name,
-      store: {
-        otherData: this.otherData
-      },
-      cacheKey: ['otherData']
+      store: { otherData: this.otherData },
+      cacheKey: ["otherData"]
     });
   }
   getOtherData(key) {
     return this.otherData[key];
   }
   async getProductTypeById(id) {
+    var _a;
     const productData = await this.store.products.getProduct(id);
     if (productData) {
       if (productData.duration) {
-        return 'duration';
+        return "duration";
       }
-      if (productData['schedule.ids']?.length) {
-        return 'session';
+      if ((_a = productData["schedule.ids"]) == null ? void 0 : _a.length) {
+        return "session";
       }
-      return 'normal';
+      return "normal";
     }
-    return 'normal';
+    return "normal";
   }
-
   /**
    * 提供给 UI 的方法，减轻 UI 层的计算压力，UI 层只需要传递 cartItemId 和 resourceCode 即返回对应的 renderList
    *
@@ -3011,82 +2811,113 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
    * @memberof BookingByStepImpl
    */
   getResourcesByCartItemAndCode(cartItemId, resourceCode) {
+    var _a, _b;
     const dateRange = this.store.date.getDateRange();
     const resources = [];
-    if (dateRange?.length) {
-      dateRange.forEach(n => {
-        if (n.resource) resources.push(...n.resource);
+    if (dateRange == null ? void 0 : dateRange.length) {
+      dateRange.forEach((n) => {
+        if (n.resource)
+          resources.push(...n.resource);
       });
     }
     if (!resources.length) {
       const dateList = this.store.date.getDateList();
-      dateList.forEach(n => {
-        if (n.resource) resources.push(...n.resource);
+      dateList.forEach((n) => {
+        if (n.resource)
+          resources.push(...n.resource);
       });
     }
-    const resourcesMap = (0, _utils2.getResourcesMap)((0, _lodashEs.cloneDeep)(resources));
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-    const cartItem = cartItems.find(item => item._id === cartItemId);
-    if (!cartItem) return [];
+    const resourcesMap = (0, import_utils2.getResourcesMap)((0, import_lodash_es.cloneDeep)(resources));
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
+    const cartItem = cartItems.find((item) => item._id === cartItemId);
+    if (!cartItem)
+      return [];
     let selectedResources = [];
-    const {
-      currentCapacity,
-      formatCapacity
-    } = (0, _capacity.getCapacityInfoByCartItem)(cartItem);
+    const { currentCapacity, formatCapacity } = (0, import_capacity.getCapacityInfoByCartItem)(cartItem);
     cartItem._origin.metadata.capacity = formatCapacity;
     if (cartItem.holder_id) {
-      selectedResources = (0, _resources.getOthersSelectedResources)(cartItems, cartItem.holder_id, resourcesMap);
+      selectedResources = (0, import_resources.getOthersSelectedResources)(
+        cartItems,
+        cartItem.holder_id,
+        resourcesMap
+      );
     } else {
-      selectedResources = (0, _resources.getOthersCartSelectedResources)(cartItems, cartItem._id, resourcesMap);
+      selectedResources = (0, import_resources.getOthersCartSelectedResources)(
+        cartItems,
+        cartItem._id,
+        resourcesMap
+      );
     }
-    const productResources = (0, _resources.getResourcesByProduct)(resourcesMap, cartItem._productOrigin?.product_resource?.resources || [], selectedResources, currentCapacity);
-    const targetResource = productResources.find(resource => resource.code === resourceCode);
-    if (!targetResource) return [];
+    const productResources = (0, import_resources.getResourcesByProduct)(
+      resourcesMap,
+      ((_b = (_a = cartItem._productOrigin) == null ? void 0 : _a.product_resource) == null ? void 0 : _b.resources) || [],
+      selectedResources,
+      currentCapacity
+    );
+    const targetResource = productResources.find(
+      (resource) => resource.code === resourceCode
+    );
+    if (!targetResource)
+      return [];
     if (cartItem._origin.start_time) {
-      const startTime = (0, _dayjs.default)(`${cartItem._origin.start_date} ${cartItem._origin.start_time}`);
-      const endTime = (0, _dayjs.default)(`${cartItem._origin.end_date} ${cartItem._origin.end_time}`);
+      const startTime = (0, import_dayjs.default)(
+        `${cartItem._origin.start_date} ${cartItem._origin.start_time}`
+      );
+      const endTime = (0, import_dayjs.default)(
+        `${cartItem._origin.end_date} ${cartItem._origin.end_time}`
+      );
       const resourcesUseableMap = {};
-      targetResource.renderList = targetResource.renderList.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;
-        return 0;
-      });
-      targetResource.renderList = targetResource.renderList.filter(m => {
-        const mTimes = m.times.filter(n => {
-          return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(startTime)) && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(endTime));
+      targetResource.renderList = targetResource.renderList.sort(
+        (a, b) => {
+          var _a2, _b2, _c, _d;
+          const aIsCombined = ((_b2 = (_a2 = a.metadata) == null ? void 0 : _a2.combined_resource) == null ? void 0 : _b2.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;
+        }
+      );
+      targetResource.renderList = targetResource.renderList.filter((m) => {
+        const mTimes = m.times.filter((n) => {
+          return !(0, import_dayjs.default)(n.start_at).isAfter((0, import_dayjs.default)(startTime)) && !(0, import_dayjs.default)(n.end_at).isBefore((0, import_dayjs.default)(endTime));
         });
-        if (mTimes.length === 0) return false;
-        const canUseArr = mTimes.map(item => {
-          const res = (0, _resources.getIsUsableByTimeItem)({
+        if (mTimes.length === 0)
+          return false;
+        const canUseArr = mTimes.map((item) => {
+          var _a2;
+          const res = (0, import_resources.getIsUsableByTimeItem)({
             timeSlice: {
-              start_time: startTime.format('HH:mm'),
-              end_time: endTime.format('HH:mm'),
+              start_time: startTime.format("HH:mm"),
+              end_time: endTime.format("HH:mm"),
               start_at: startTime,
               end_at: endTime
             },
             time: item,
             resource: m,
             currentCount: currentCapacity || 0,
-            resourcesUseableMap: resourcesUseableMap,
-            cut_off_time: cartItem._productOrigin?.cut_off_time
+            resourcesUseableMap,
+            cut_off_time: (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.cut_off_time
           });
-          if (resourcesUseableMap?.[m.id] !== false && res.reason !== 'capacityOnly') {
+          if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[m.id]) !== false && res.reason !== "capacityOnly") {
             resourcesUseableMap[m.id] = res.usable;
           }
           return res.usable;
         });
-        if (m.onlyComputed) return false;
-        return !canUseArr.some(n => n === false);
+        if (m.onlyComputed)
+          return false;
+        return !canUseArr.some((n) => n === false);
       });
     } else {
-      targetResource.renderList = targetResource.renderList.filter(n => {
+      targetResource.renderList = targetResource.renderList.filter((n) => {
+        var _a2, _b2;
         const recordCount = n.capacity || 0;
-        if (n.onlyComputed) return false;
-        const timeSlots = (0, _resources.getTimeSlicesByResource)({
+        if (n.onlyComputed)
+          return false;
+        const timeSlots = (0, import_resources.getTimeSlicesByResource)({
           resource: n,
-          duration: cartItem._productOrigin?.duration?.value || 10,
+          duration: ((_b2 = (_a2 = cartItem._productOrigin) == null ? void 0 : _a2.duration) == null ? void 0 : _b2.value) || 10,
           split: 10,
           currentDate: dateRange[0].date
         });
@@ -3095,7 +2926,6 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     }
     return targetResource.renderList;
   }
-
   /**
    * 根据日期范围批量获取时间槽
    * @param params 参数对象
@@ -3107,15 +2937,17 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     scheduleIds,
     resources
   }) {
-    // 生成日期范围内的所有日期
+    console.log(
+      "appoimentBooking-session-date-getTimeslotsScheduleByDateRange",
+      { startDate, endDate, scheduleIds, resources }
+    );
     const dates = [];
-    let currentDate = (0, _dayjs.default)(startDate);
-    const end = (0, _dayjs.default)(endDate);
+    let currentDate = (0, import_dayjs.default)(startDate);
+    const end = (0, import_dayjs.default)(endDate);
     while (currentDate.isSameOrBefore(end)) {
-      dates.push(currentDate.format('YYYY-MM-DD'));
-      currentDate = currentDate.add(1, 'day');
+      dates.push(currentDate.format("YYYY-MM-DD"));
+      currentDate = currentDate.add(1, "day");
     }
-    // 如果不支持 Web Worker，使用同步方式处理
     const results = {};
     for (const date of dates) {
       results[date] = this.getTimeslotBySchedule({
@@ -3127,36 +2959,25 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     return results;
   }
   async getAvailableDateForSessionOptimize(params = {}) {
-    // 开始日期如果小于今天，直接以今天当做开始日期
-    let {
-      startDate,
-      endDate
-    } = params;
-    // 前端传递的 startDate，可能是今天之前的，如果 startDate 小于今天 且 endDate 小于或等于今天，需要把 startDate 置为今天
-    if ((0, _dayjs.default)(startDate).isBefore((0, _dayjs.default)(), 'day') && ((0, _dayjs.default)(endDate).isAfter((0, _dayjs.default)(), 'day') || (0, _dayjs.default)(endDate).isSame((0, _dayjs.default)(), 'day'))) {
-      startDate = (0, _dayjs.default)().format('YYYY-MM-DD');
-    }
-    // 不管前端传什么 endDate 默认查一个月的，以今天为开始日期。用于找到一个月内最近可用的日期
-    // 优化策略：
-    // 在 endDate 添加完一个月以后，如果 endDate 还小于 startDate + 7 天，则还需要 endDate+7 天
-    const endDateAfterMonth = (0, _dayjs.default)().add(1, 'month').format('YYYY-MM-DD');
+    var _a, _b, _c, _d;
+    let { startDate, endDate } = params;
+    if ((0, import_dayjs.default)(startDate).isBefore((0, import_dayjs.default)(), "day") && ((0, import_dayjs.default)(endDate).isAfter((0, import_dayjs.default)(), "day") || (0, import_dayjs.default)(endDate).isSame((0, import_dayjs.default)(), "day"))) {
+      startDate = (0, import_dayjs.default)().format("YYYY-MM-DD");
+    }
+    const endDateAfterMonth = (0, import_dayjs.default)().add(1, "month").format("YYYY-MM-DD");
     let tempEndDate = endDateAfterMonth;
-    if ((0, _dayjs.default)(startDate).add(7, 'day').isAfter((0, _dayjs.default)(endDateAfterMonth), 'day')) {
-      tempEndDate = (0, _dayjs.default)(startDate).add(7, 'day').format('YYYY-MM-DD');
+    if ((0, import_dayjs.default)(startDate).add(7, "day").isAfter((0, import_dayjs.default)(endDateAfterMonth), "day")) {
+      tempEndDate = (0, import_dayjs.default)(startDate).add(7, "day").format("YYYY-MM-DD");
     } else {
       tempEndDate = endDateAfterMonth;
     }
-    // 如果这么算出来的 tempEndDate 还小于 endDate，则需要把 endDate 置为 tempEndDate
-    if ((0, _dayjs.default)(tempEndDate).isBefore((0, _dayjs.default)(endDate), 'day')) {
-      tempEndDate = endDate || '';
+    if ((0, import_dayjs.default)(tempEndDate).isBefore((0, import_dayjs.default)(endDate), "day")) {
+      tempEndDate = endDate || "";
     }
     endDate = tempEndDate;
-
-    // 先去读缓存结果，因为正常 UI 调用的是 7 天，而下面我会直接计算 30 天（最少也是 14 天），所以先去读缓存结果，如果缓存结果存在，则直接返回
-    const cache = this.store.currentProductMeta?.['timeSlotBySchedule'];
+    const cache = (_a = this.store.currentProductMeta) == null ? void 0 : _a["timeSlotBySchedule"];
     if (cache) {
-      // 开始日期大于等于缓存的开始日期，且结束日期小于等于缓存的结束日期，则直接返回缓存结果
-      if ((0, _dayjs.default)(params.startDate).isSameOrAfter((0, _dayjs.default)(cache.startDate), 'day') && (0, _dayjs.default)(params.endDate).isSameOrBefore((0, _dayjs.default)(cache.endDate), 'day')) {
+      if ((0, import_dayjs.default)(params.startDate).isSameOrAfter((0, import_dayjs.default)(cache.startDate), "day") && (0, import_dayjs.default)(params.endDate).isSameOrBefore((0, import_dayjs.default)(cache.endDate), "day")) {
         this.store.date.setDateList(cache.dateList);
         return {
           dateList: cache.dateList,
@@ -3165,207 +2986,190 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
       }
     }
     let tempProducts;
-    // 如果当前打开了某个的商品详情弹窗，则应该默认用这个商品
     tempProducts = this.store.currentProduct;
-    const schedule = this.store.currentProductMeta?.['schedule'];
-    const filteredSchedule = (0, _resources.filterScheduleByDateRange)(schedule, startDate || '', endDate || '');
-    // 1.后端返回的数据，确定资源在每一天的可用和使用情况
-    const tempResourceIds = (0, _capacity.getResourcesIdsByProduct)(tempProducts);
+    const schedule = (_b = this.store.currentProductMeta) == null ? void 0 : _b["schedule"];
+    const filteredSchedule = (0, import_resources.filterScheduleByDateRange)(
+      schedule,
+      startDate || "",
+      endDate || ""
+    );
+    const tempResourceIds = (0, import_capacity.getResourcesIdsByProduct)(tempProducts);
     const res = await this.store.date.fetchResourceDates({
       query: {
-        start_date: startDate || '',
-        end_date: endDate || '',
+        start_date: startDate || "",
+        end_date: endDate || "",
         resource_ids: tempResourceIds
       }
     });
-    // 2. 商品 schedule 数据，确定日程在每一天的时间片
-    // 3. 把后端返回的和 schedule 的数据进行合并，确定每一天的可用和使用情况
     let dates = [];
-    let currentDate = (0, _dayjs.default)(startDate);
-    let firstAvailableDate = '';
-
-    // 预处理，获取商品下启用的资源类型，后面只需要遍历这些资源的资源列表即可
-    const openResources = tempProducts?.product_resource?.resources?.filter(m => m.status === 1) || [];
-
-    // res.data 返回的一定是启用商品的资源列表，不需要再过滤了
-    const allProductResources = (0, _lodashEs.cloneDeep)((0, _resources.sortCombinedResources)(res.data) || []);
-    // allProductResources 需要根据商品里的资源的单个预约多个预约补充resourceType
-    allProductResources.forEach(m => {
-      const resource = tempProducts?.product_resource?.resources?.find(n => n.id === m.form_id);
+    let currentDate = (0, import_dayjs.default)(startDate);
+    let firstAvailableDate = "";
+    const openResources = ((_d = (_c = tempProducts == null ? void 0 : tempProducts.product_resource) == null ? void 0 : _c.resources) == null ? void 0 : _d.filter(
+      (m) => m.status === 1
+    )) || [];
+    const allProductResources = (0, import_lodash_es.cloneDeep)((0, import_resources.sortCombinedResources)(res.data) || []);
+    allProductResources.forEach((m) => {
+      var _a2, _b2;
+      const resource = (_b2 = (_a2 = tempProducts == null ? void 0 : tempProducts.product_resource) == null ? void 0 : _a2.resources) == null ? void 0 : _b2.find(
+        (n) => n.id === m.form_id
+      );
       if (resource) {
         m.resourceType = resource.type;
       }
     });
-    const targetSchedules = this.store.schedule.getScheduleListByIds(tempProducts['schedule.ids']);
-    while ((0, _dayjs.default)(currentDate).isBefore((0, _dayjs.default)(endDate), 'day') || (0, _dayjs.default)(currentDate).isSame((0, _dayjs.default)(endDate), 'day')) {
-      const currentDateStr = currentDate.format('YYYY-MM-DD');
-      let status = 'available';
+    const targetSchedules = this.store.schedule.getScheduleListByIds(
+      tempProducts["schedule.ids"]
+    );
+    while ((0, import_dayjs.default)(currentDate).isBefore((0, import_dayjs.default)(endDate), "day") || (0, import_dayjs.default)(currentDate).isSame((0, import_dayjs.default)(endDate), "day")) {
+      const currentDateStr = currentDate.format("YYYY-MM-DD");
+      let status = "available";
       let summaryCount = 0;
       let availableCount = 0;
-      // 1. 检查商品的提前量等情况是否满足
-      const {
-        latestStartDate,
-        earliestEndDate
-      } = (0, _resources.checkSessionProductLeadTime)(tempProducts);
+      const { latestStartDate, earliestEndDate } = (0, import_resources.checkSessionProductLeadTime)(tempProducts);
       if (latestStartDate || earliestEndDate) {
-        // 如果时间在最早开始时间之前，则设置为不可用
-        if (latestStartDate && (0, _dayjs.default)(currentDate).isBefore(latestStartDate, 'day')) {
-          status = 'unavailable';
+        if (latestStartDate && (0, import_dayjs.default)(currentDate).isBefore(latestStartDate, "day")) {
+          status = "unavailable";
         }
-        // 如果时间在最早结束时间之后，则设置为不可用
-        if (earliestEndDate && (0, _dayjs.default)(currentDate).isAfter(earliestEndDate, 'day')) {
-          status = 'unavailable';
+        if (earliestEndDate && (0, import_dayjs.default)(currentDate).isAfter(earliestEndDate, "day")) {
+          status = "unavailable";
         }
       }
-      // 2. 检查 schedule 数据，确定 schedule 里没有这一天，或者这一天的isExcluded: true ，则不可用
-      if (status === 'available') {
-        const scheduleByDate = filteredSchedule.find(n => n.date === currentDateStr);
-        if (!scheduleByDate || scheduleByDate?.isExcluded) {
-          status = 'unavailable';
+      if (status === "available") {
+        const scheduleByDate = filteredSchedule.find(
+          (n) => n.date === currentDateStr
+        );
+        if (!scheduleByDate || (scheduleByDate == null ? void 0 : scheduleByDate.isExcluded)) {
+          status = "unavailable";
         }
       }
-
-      // 3. 检查这一天的 schedule 时间片里资源是否有可用的，每个时间片下每种资源只需找到第一个可用的即可
-      if (status === 'available') {
-        const minTimeMaxTime = (0, _utils3.calcMinTimeMaxTimeBySchedules)(targetSchedules, {}, currentDateStr);
-        const scheduleTimeSlots = (0, _utils3.getAllSortedDateRanges)(minTimeMaxTime);
-        // 同一天内多个时间片下 只要有一个可用则视为可用
+      if (status === "available") {
+        const minTimeMaxTime = (0, import_utils3.calcMinTimeMaxTimeBySchedules)(
+          targetSchedules,
+          {},
+          currentDateStr
+        );
+        const scheduleTimeSlots = (0, import_utils3.getAllSortedDateRanges)(minTimeMaxTime);
         let timesSlotCanUse = false;
-        scheduleTimeSlots.forEach(item => {
-          // 用来计算资源的可使用情况，针对单个schedule 时间片
+        scheduleTimeSlots.forEach((item) => {
           const resourcesUseableMap = {};
-          // 遍历产品下启用的资源
-          // 必须要保证每种类型的资源都至少有一个能够在对应时间点被选择
-          // 求出第一个资源的剩余量和总量
-          // 剩余量=每个资源在每个时间片内剩余之和
-          // 总量=每个资源在每个时间片内资源总量之和
           let isAllResourceTypesUseable = true;
-          openResources.forEach(resource => {
-            // if (!isAllResourceTypesUseable) return;
-
-            // 获取当前资源类型的资源列表
-            const currentResourcesList = allProductResources.filter(n => n.form_id === resource.resource_type_id);
-            // 如果resource.renderList里含有 onlyComputed 的数据，需要把 currentResourcesList 的数据也修正回来
-            resource.renderList?.forEach(item => {
-              if (item.onlyComputed) {
-                const targetIndex = currentResourcesList.findIndex(n => n.id === item.id);
+          openResources.forEach((resource) => {
+            var _a2;
+            const currentResourcesList = allProductResources.filter(
+              (n) => n.form_id === resource.resource_type_id
+            );
+            (_a2 = resource.renderList) == null ? void 0 : _a2.forEach((item2) => {
+              if (item2.onlyComputed) {
+                const targetIndex = currentResourcesList.findIndex((n) => n.id === item2.id);
                 if (targetIndex && targetIndex !== -1) {
                   currentResourcesList[targetIndex].onlyComputed = true;
                 }
               }
             });
-            // 可能存在 renderList 没有的情况，则需要判断 resource.optional_resource 和 resource.default_resource 是否存在那个资源，如果不存在也打上 onlyComputed 的标记
-            currentResourcesList.forEach(item => {
-              if (!resource.optional_resource?.includes(item.id) && !resource.default_resource?.includes(item.id)) {
-                item.onlyComputed = true;
+            currentResourcesList.forEach((item2) => {
+              var _a3, _b2;
+              if (!((_a3 = resource.optional_resource) == null ? void 0 : _a3.includes(item2.id)) && !((_b2 = resource.default_resource) == null ? void 0 : _b2.includes(item2.id))) {
+                item2.onlyComputed = true;
               }
             });
-            // currentResourcesList 排序，onlyComputed 的资源排在前面先计算
             currentResourcesList.sort((a, b) => {
               return a.onlyComputed ? -1 : 1;
             });
             let isAnyResourceUseableInType = false;
-            currentResourcesList?.forEach(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的开始结束时间
-              const mTimes = m.times.filter(n => {
-                return !(0, _dayjs.default)(n.start_at).isAfter((0, _dayjs.default)(item.start), 'minute') && !(0, _dayjs.default)(n.end_at).isBefore((0, _dayjs.default)(item.end), 'minute');
+            currentResourcesList == null ? void 0 : currentResourcesList.forEach((m) => {
+              const mTimes = m.times.filter((n) => {
+                return !(0, import_dayjs.default)(n.start_at).isAfter((0, import_dayjs.default)(item.start), "minute") && !(0, import_dayjs.default)(n.end_at).isBefore((0, import_dayjs.default)(item.end), "minute");
               });
-
-              // 如果在这个区间的时间一个都没有，可以直接认为这个资源不可用
-              if (mTimes.length === 0) return;
-              // 如果资源可用则把他的容量纳入总计
+              if (mTimes.length === 0)
+                return;
               if (!m.onlyComputed) {
-                if (resource.type === 'multiple') {
+                if (resource.type === "multiple") {
                   summaryCount += m.capacity;
                 } else {
                   summaryCount += 1;
                 }
               }
               let isAnyTimeSliceUseable = false;
-              mTimes.forEach(childTiem => {
-                if (isAnyTimeSliceUseable) return;
-
-                // 挨个去匹配某个工作时间段结合当前日程时间，资源能不能用，有多少容量能用
-                const res = (0, _resources.getIsUsableByTimeItem)({
+              mTimes.forEach((childTiem) => {
+                if (isAnyTimeSliceUseable)
+                  return;
+                const res2 = (0, import_resources.getIsUsableByTimeItem)({
                   timeSlice: {
                     start_time: item.start,
                     end_time: item.end,
-                    start_at: (0, _dayjs.default)(item.start),
-                    end_at: (0, _dayjs.default)(item.end)
+                    start_at: (0, import_dayjs.default)(item.start),
+                    end_at: (0, import_dayjs.default)(item.end)
                   },
                   time: childTiem,
                   resource: m,
                   currentCount: 1,
                   resourcesUseableMap,
-                  cut_off_time: tempProducts?.cut_off_time
+                  cut_off_time: tempProducts == null ? void 0 : tempProducts.cut_off_time
                 });
-                if (resourcesUseableMap?.[m.id] !== false && res.reason !== 'capacityOnly') {
-                  resourcesUseableMap[m.id] = res.usable;
+                if ((resourcesUseableMap == null ? void 0 : resourcesUseableMap[m.id]) !== false && res2.reason !== "capacityOnly") {
+                  resourcesUseableMap[m.id] = res2.usable;
                 }
-                if (res.usable && !m.onlyComputed) {
+                if (res2.usable && !m.onlyComputed) {
                   isAnyTimeSliceUseable = true;
-                  if (resource.type === 'multiple') {
-                    availableCount += res.remainingCapacity;
+                  if (resource.type === "multiple") {
+                    availableCount += res2.remainingCapacity;
                   } else {
                     availableCount += 1;
                   }
                 }
                 ;
               });
-              if (isAnyTimeSliceUseable) isAnyResourceUseableInType = true;
+              if (isAnyTimeSliceUseable)
+                isAnyResourceUseableInType = true;
             });
-            if (!isAnyResourceUseableInType) isAllResourceTypesUseable = false;
+            if (!isAnyResourceUseableInType)
+              isAllResourceTypesUseable = false;
           });
-          if (isAllResourceTypesUseable) timesSlotCanUse = true;
+          if (isAllResourceTypesUseable)
+            timesSlotCanUse = true;
         });
         if (!timesSlotCanUse) {
-          status = 'unavailable';
+          status = "unavailable";
         }
-        if (status === 'available' && !firstAvailableDate) {
+        if (status === "available" && !firstAvailableDate) {
           firstAvailableDate = currentDateStr;
         }
       }
-      // 状态： lots_of_space: availableCount / summaryCount > 0.5
-      // filling_up_fast: availableCount / summaryCount <= 0.5 && availableCount > 0
-      // sold_out: summaryCount = 0
-      // unavailable: summaryCount > 0 && availableCount = 0
       let dateStatus;
-      if (status === 'unavailable') {
-        // dateStatus = 'unavailable'
-        if (availableCount === 0 && summaryCount > 0) dateStatus = 'sold_out';else dateStatus = 'unavailable';
+      if (status === "unavailable") {
+        if (availableCount === 0 && summaryCount > 0)
+          dateStatus = "sold_out";
+        else
+          dateStatus = "unavailable";
       } else {
         const usageRatio = availableCount / summaryCount;
-        if (usageRatio > 0.5) dateStatus = 'lots_of_space';else dateStatus = 'filling_up_fast';
+        if (usageRatio > 0.5)
+          dateStatus = "lots_of_space";
+        else
+          dateStatus = "filling_up_fast";
       }
       dates.push({
-        date: (0, _dayjs.default)(currentDate).format('YYYY-MM-DD'),
-        week: (0, _dayjs.default)(currentDate).format('ddd'),
-        weekNum: (0, _dayjs.default)(currentDate).day(),
+        date: (0, import_dayjs.default)(currentDate).format("YYYY-MM-DD"),
+        week: (0, import_dayjs.default)(currentDate).format("ddd"),
+        weekNum: (0, import_dayjs.default)(currentDate).day(),
         summaryCount,
         availableCount,
         status: dateStatus
       });
-
-      // 如果 firstAvailableDate 距离 startDate 大于 14 天了，则后面就不需要再找了，也是一种性能保护
-      if (firstAvailableDate && (0, _dayjs.default)(currentDate).diff((0, _dayjs.default)(startDate), 'day') > 31) {
+      if (firstAvailableDate && (0, import_dayjs.default)(currentDate).diff((0, import_dayjs.default)(startDate), "day") > 31) {
         break;
       }
-      currentDate = (0, _dayjs.default)(currentDate).add(1, 'day');
+      currentDate = (0, import_dayjs.default)(currentDate).add(1, "day");
     }
-    // 最终把资源数据也加到日期内
-    dates = (0, _utils4.handleAvailableDateByResource)(res.data, dates);
+    dates = (0, import_utils4.handleAvailableDateByResource)(res.data, dates);
     this.store.date.setDateList(dates);
-
-    // 缓存这次结果，以防后面他小幅度范围内去修改天数
-    if (!this.store.currentProductMeta) this.store.currentProductMeta = {};
+    if (!this.store.currentProductMeta)
+      this.store.currentProductMeta = {};
     this.store.currentProductMeta.timeSlotBySchedule = {
       dateList: dates,
       firstAvailableDate,
       startDate,
-      endDate: (0, _dayjs.default)(currentDate).format('YYYY-MM-DD')
+      endDate: (0, import_dayjs.default)(currentDate).format("YYYY-MM-DD")
     };
     return {
       dateList: dates,
@@ -3373,27 +3177,33 @@ class BookingByStepImpl extends _BaseModule.BaseModule {
     };
   }
   isCartAllNormalProducts() {
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
     return !cartItems.length;
   }
   isCartHasDurationProduct() {
-    const cartItems = this.store.cart.getItems().filter(n => !(0, _utils5.isNormalProduct)(n._productOrigin));
-    return cartItems.some(n => n._productOrigin?.duration);
+    const cartItems = this.store.cart.getItems().filter((n) => !(0, import_utils5.isNormalProduct)(n._productOrigin));
+    return cartItems.some((n) => {
+      var _a;
+      return (_a = n._productOrigin) == null ? void 0 : _a.duration;
+    });
   }
   isTargetNormalProduct(product) {
-    if (!product) return false;
-    return (0, _utils5.isNormalProduct)(product);
+    if (!product)
+      return false;
+    return (0, import_utils5.isNormalProduct)(product);
   }
   isTargetCartIdNormalProduct(id) {
-    const cartItem = this.store.cart.getItems().find(n => n._id === id);
-    return cartItem && (0, _utils5.isNormalProduct)(cartItem._productOrigin);
+    const cartItem = this.store.cart.getItems().find((n) => n._id === id);
+    return cartItem && (0, import_utils5.isNormalProduct)(cartItem._productOrigin);
   }
-
   /**
    * 获取联系信息
   */
   async getContactInfo(params) {
-    return this.request.get('/customer/metadata', params);
+    return this.request.get("/customer/metadata", params);
   }
-}
-exports.BookingByStepImpl = BookingByStepImpl;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BookingByStepImpl
+});