@pisell/pisellos 2.1.36 → 2.2.1

package/dist/server/types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Server 类型定义
+ */
+export type CacheType = 'memory' | 'storage' | 'indexDB';
+export interface CacheProps {
+    key?: string;
+    type?: CacheType;
+    updateCache?: boolean;
+    cacheUpdateChange?: (data: any) => void;
+}
+export interface RequestSetting {
+    abort?: boolean;
+    headers?: any;
+    cache?: CacheProps;
+    signal?: any;
+    token?: string;
+    osServer?: boolean;
+    [key: string]: any;
+}
+/**
+ * 路由处理函数类型
+ */
+export type RouteHandler = (params: {
+    url: string;
+    method: 'get' | 'post' | 'remove' | 'put';
+    data?: any;
+    config?: RequestSetting;
+}) => Promise<any> | any;
+/**
+ * HTTP 方法类型
+ */
+export type HttpMethod = 'get' | 'post' | 'remove' | 'put';
+/**
+ * 路由定义类型
+ */
+export type RouteDefinition = {
+    method: HttpMethod;
+    path: string;
+    handler: RouteHandler;
+};
+/**
+ * Router 对象类型
+ */
+export interface Router {
+    get: Record<string, RouteHandler>;
+    post: Record<string, RouteHandler>;
+    put: Record<string, RouteHandler>;
+    remove: Record<string, RouteHandler>;
+}
+/**
+ * 模块注册配置（内部使用）
+ */
+export interface ModuleRegistryConfig {
+    /** 模块名称 */
+    name: string;
+    /** 模块类 */
+    moduleClass: any;
+    /** 模块完整名称（用于注册到 Core） */
+    moduleName: string;
+    /** 模块版本 */
+    version: string;
+    /** 默认 store 结构 */
+    defaultStore: Record<string, any>;
+}

package/dist/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/utils/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Server 工具函数集合
+ */
+export * from './time';
+export * from './schedule';

package/dist/server/utils/index.js

@@ -0,0 +1,6 @@
+/**
+ * Server 工具函数集合
+ */
+
+export * from "./time";
+export * from "./schedule";

package/dist/server/utils/product.d.ts

@@ -0,0 +1,18 @@
+import { ProductData } from '../../modules/Product/types';
+import { FormattedProductData, LoadProductsPriceData, ProductFormatterContext } from '../modules/products/types';
+/**
+ * 将价格数据应用到商品列表（高性能版本）
+ * 通过预构建 Map 索引，将时间复杂度从 O(n×m) 优化到 O(n+m)
+ * @param products 商品列表
+ * @param priceData 价格数据
+ * @returns 应用价格后的商品列表
+ */
+export declare function applyPriceDataToProducts(products: ProductData[], priceData: LoadProductsPriceData[]): ProductData[];
+export declare const getIsSessionProduct: (product: ProductData) => boolean;
+/**
+ * 将详情值数据应用到商品列表
+ * @param products 商品列表
+ * @param context 格式化器上下文
+ * @returns 应用详情值后的商品列表
+ */
+export declare function applyDetailValueToProducts(products: ProductData[], context: ProductFormatterContext): FormattedProductData[];

package/dist/server/utils/product.js

@@ -0,0 +1,339 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import Decimal from 'decimal.js';
+import { getScheduleStartEndTimePoints } from "../modules/schedule/utils";
+import { getUniqueId } from "../../modules/Cart/utils";
+
+/**
+ * 构建价格数据的 Map 索引结构
+ * 使用三层 Map 实现 O(1) 查询，大幅提升性能
+ * @param priceData 价格数据数组
+ * @returns 三层 Map 索引：商品、variant、bundle
+ */
+function buildPriceIndexMap(priceData) {
+  // 1. 商品主价格 Map: productId -> priceInfo
+  var priceMap = new Map(priceData.map(function (p) {
+    return [p.id, p];
+  }));
+
+  // 2. Variant 价格 Map: productId -> (variantId -> variantPriceInfo)
+  var variantMap = new Map();
+  priceData.forEach(function (p) {
+    if (p.variant && p.variant.length > 0) {
+      var variantById = new Map(p.variant.map(function (v) {
+        return [v.id, v];
+      }));
+      variantMap.set(p.id, variantById);
+    }
+  });
+
+  // 3. Bundle 价格 Map: productId -> (groupId -> (itemId -> itemPriceInfo))
+  var bundleMap = new Map();
+  priceData.forEach(function (p) {
+    if (p.bundle_group && p.bundle_group.length > 0) {
+      var groupMap = new Map();
+      p.bundle_group.forEach(function (bg) {
+        var itemMap = new Map(bg.bundle_item.map(function (bi) {
+          return [bi.id, bi];
+        }));
+        groupMap.set(bg.id, itemMap);
+      });
+      bundleMap.set(p.id, groupMap);
+    }
+  });
+  return {
+    priceMap: priceMap,
+    variantMap: variantMap,
+    bundleMap: bundleMap
+  };
+}
+
+/**
+ * 将价格数据应用到商品列表（高性能版本）
+ * 通过预构建 Map 索引，将时间复杂度从 O(n×m) 优化到 O(n+m)
+ * @param products 商品列表
+ * @param priceData 价格数据
+ * @returns 应用价格后的商品列表
+ */
+export function applyPriceDataToProducts(products, priceData) {
+  // 如果没有价格数据，直接返回原商品
+  if (!priceData || priceData.length === 0) {
+    console.log('[applyPriceDataToProducts] 没有价格数据，返回原商品');
+    return products;
+  }
+
+  // 预先构建 Map 索引（O(m) 时间）
+  var _buildPriceIndexMap = buildPriceIndexMap(priceData),
+    priceMap = _buildPriceIndexMap.priceMap,
+    variantMap = _buildPriceIndexMap.variantMap,
+    bundleMap = _buildPriceIndexMap.bundleMap;
+  console.log("[applyPriceDataToProducts] \u5DF2\u6784\u5EFA\u4EF7\u683C\u7D22\u5F15\uFF0C\u5171 ".concat(priceMap.size, " \u4E2A\u5546\u54C1\u4EF7\u683C"));
+
+  // 应用价格到商品（O(n) 时间）
+  var updatedProducts = products.map(function (product) {
+    // O(1) 查询商品价格
+    var priceInfo = priceMap.get(product.id);
+    if (!priceInfo) {
+      return product;
+    }
+
+    // 深拷贝商品对象
+    var updatedProduct = _objectSpread({}, product);
+
+    // 1. 更新主价格（转换为 string 类型）
+    updatedProduct.price = priceInfo.price;
+    updatedProduct.base_price = priceInfo.base_price;
+
+    // 2. 更新 variant 价格
+    if (updatedProduct.variant && updatedProduct.variant.length > 0) {
+      var productVariantMap = variantMap.get(product.id);
+      if (productVariantMap) {
+        updatedProduct.variant = updatedProduct.variant.map(function (v) {
+          var priceVariant = productVariantMap.get(v.id); // O(1)
+          if (priceVariant) {
+            return _objectSpread(_objectSpread({}, v), {}, {
+              price: String(priceVariant.price),
+              base_price: String(priceVariant.base_price)
+            });
+          }
+          return v;
+        });
+      }
+    }
+
+    // 3. 更新 bundle_groups 价格
+    if (updatedProduct.bundle_groups && updatedProduct.bundle_groups.length > 0) {
+      var productBundleMap = bundleMap.get(product.id);
+      if (productBundleMap) {
+        updatedProduct.bundle_groups = updatedProduct.bundle_groups.map(function (bg) {
+          var groupItemMap = productBundleMap.get(bg.id); // O(1)
+          if (!groupItemMap) return bg;
+          return _objectSpread(_objectSpread({}, bg), {}, {
+            bundle_item: bg.bundle_item.map(function (bi) {
+              var priceBi = groupItemMap.get(bi.id); // O(1)
+              if (priceBi) {
+                // 处理 markdown 类型
+                var price = priceBi.price;
+                if (priceBi.price_type === 'markdown') {
+                  price = new Decimal(price || 0).mul(-1).toNumber();
+                }
+                return _objectSpread(_objectSpread({}, bi), {}, {
+                  price: String(price),
+                  base_price: String(priceBi.base_price)
+                });
+              }
+              return bi;
+            })
+          });
+        });
+      }
+    }
+    return updatedProduct;
+  });
+  console.log("[applyPriceDataToProducts] \u5DF2\u5E94\u7528\u4EF7\u683C\u5230 ".concat(updatedProducts.length, " \u4E2A\u5546\u54C1"));
+  return updatedProducts;
+}
+export var getIsSessionProduct = function getIsSessionProduct(product) {
+  return ['session_product', 'session_ticket'].includes(product.extension_type);
+};
+
+/**
+ * 获取是否打开详情弹窗
+ * @param product 商品
+ * @param context 格式化器上下文
+ * @returns 是否打开详情弹窗
+ */
+var getIsOpenDetailModal = function getIsOpenDetailModal(product, context) {
+  /** 是否为套餐组商品 */
+  var isBundleProduct = product.bundle_group_count > 0;
+
+  /** 是否为选项组商品 */
+  var isOptionProduct = product.option_group_count > 0;
+
+  /** 是否为组合规格商品 */
+  var isVariantProduct = product.is_variant > 0;
+
+  /** 是否为日程商品 */
+  var isSessionProduct = getIsSessionProduct(product);
+
+  // 获取商品关联的日程时间段
+  var scheduleTimeSlots = [];
+  if (isSessionProduct && product['schedule.ids'] && context.scheduleModule) {
+    var scheduleIds = product['schedule.ids'];
+    // 从 context 中获取完整的 scheduleList，然后过滤出商品关联的 schedule
+    var productSchedules = context.scheduleModule.getScheduleByIds(scheduleIds);
+    // 获取当前日期的所有时间段
+    scheduleTimeSlots = getScheduleStartEndTimePoints(context.schedule_date, productSchedules);
+  }
+
+  // 是否打开详情弹窗 套餐组、选项组、组合规格、日程商品、日程时间段大于1个 打开详情弹窗
+  var isOpenDetailModal = isBundleProduct || isOptionProduct || isVariantProduct || scheduleTimeSlots.length > 1;
+  return {
+    isOpenDetailModal: isOpenDetailModal,
+    scheduleTimeSlots: scheduleTimeSlots
+  };
+};
+var formatDataKey = function formatDataKey(data) {
+  var _data$option, _data$bundle;
+  var _data = _objectSpread({}, data);
+  var key = "".concat(_data.product_id);
+  var rowKey = key;
+
+  // 组合规格
+  if (_data.product_variant_id) {
+    var str = "_".concat(_data.product_variant_id);
+    key += str;
+    rowKey += str;
+  }
+
+  // 单规格
+  if (_data !== null && _data !== void 0 && (_data$option = _data.option) !== null && _data$option !== void 0 && _data$option.length) {
+    var _iterator = _createForOfIteratorHelper(_data.option),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var item = _step.value;
+        var _str = "_".concat(item.option_group_id, "_").concat(item.product_option_item_id);
+        key += _str;
+        rowKey += "".concat(_str, "_").concat(item.quantity || item.num);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+
+  // 套餐
+  if (_data !== null && _data !== void 0 && (_data$bundle = _data.bundle) !== null && _data$bundle !== void 0 && _data$bundle.length) {
+    var _iterator2 = _createForOfIteratorHelper(_data.bundle),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _item = _step2.value;
+        var _str2 = "_".concat(_item.group_id, "_").concat(_item.bundle_product_id);
+        key += _str2;
+        rowKey += "".concat(_str2, "_").concat(_item.quantity || _item.num);
+        // 如果有单规格
+        if (_item !== null && _item !== void 0 && _item.option) {
+          var _iterator3 = _createForOfIteratorHelper(_item.option),
+            _step3;
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              var opt = _step3.value;
+              var _str3 = "_".concat(opt.option_group_id, "_").concat(opt.product_option_item_id);
+              key += _str3;
+              rowKey += "".concat(_str3, "_").concat(opt.quantity || opt.num);
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  }
+
+  // session time
+  if (_data !== null && _data !== void 0 && _data.session) {
+    var _data$session;
+    var _str4 = "_".concat(_data === null || _data === void 0 || (_data$session = _data.session) === null || _data$session === void 0 ? void 0 : _data$session.key);
+    key += _str4;
+    rowKey += _str4;
+  }
+  if (_data !== null && _data !== void 0 && _data.schedule) {
+    var _data$schedule;
+    var _str5 = "_".concat(_data === null || _data === void 0 || (_data$schedule = _data.schedule) === null || _data$schedule === void 0 ? void 0 : _data$schedule.key);
+    key += _str5;
+    rowKey += _str5;
+  }
+  _data.key = key;
+  _data.rowKey = rowKey;
+  return _data;
+};
+
+/**
+ * 生成购物车详情值
+ * @param product 商品
+ * @param context 格式化器上下文
+ * @returns 购物车详情值
+ */
+var genCartDetailValue = function genCartDetailValue(product, scheduleTimeSlots) {
+  var params = {
+    product_id: product === null || product === void 0 ? void 0 : product.id,
+    option: [],
+    bundle: [],
+    product_variant_id: 0,
+    quantity: 1,
+    unique: getUniqueId(),
+    session: null
+  };
+  if (scheduleTimeSlots.length) {
+    params.session = scheduleTimeSlots.map(function (item) {
+      return _objectSpread(_objectSpread({}, item), {}, {
+        unique: getUniqueId()
+      });
+    })[0];
+  }
+  if (product !== null && product !== void 0 && product.service_times) {
+    params.service_times = product === null || product === void 0 ? void 0 : product.service_times;
+  }
+
+  // 票务订单需要返回对应的扩展属性
+  if (product !== null && product !== void 0 && product.machine_code) {
+    params.machine_code = product.machine_code;
+  }
+  if (product !== null && product !== void 0 && product['schedule.ids']) {
+    params.schedule_id = product['schedule.ids'];
+  }
+
+  // 协议id
+  if (product !== null && product !== void 0 && product.policy) {
+    params.policy_id = product === null || product === void 0 ? void 0 : product.policy;
+  }
+
+  // appointment预约商品
+  if (product !== null && product !== void 0 && product.duration) {
+    params.duration = product.duration;
+  }
+  return formatDataKey(params);
+};
+
+/**
+ * 将详情值数据应用到商品列表
+ * @param products 商品列表
+ * @param context 格式化器上下文
+ * @returns 应用详情值后的商品列表
+ */
+export function applyDetailValueToProducts(products, context) {
+  var newProducts = products.map(function (product) {
+    /** 是否打开详情弹窗 套餐组、选项组、组合规格、日程商品、日程时间段大于1个 打开详情弹窗 */
+    var _getIsOpenDetailModal = getIsOpenDetailModal(product, context),
+      isOpenDetailModal = _getIsOpenDetailModal.isOpenDetailModal,
+      scheduleTimeSlots = _getIsOpenDetailModal.scheduleTimeSlots;
+    var cartDetailValue = null;
+    if (!isOpenDetailModal) {
+      // 生成购物车详情值
+      cartDetailValue = genCartDetailValue(product, scheduleTimeSlots);
+    }
+    return _objectSpread(_objectSpread({}, product), {}, {
+      // 是否打开详情弹窗
+      isOpenDetailModal: isOpenDetailModal,
+      // 购物车详情值
+      cartDetailValue: cartDetailValue
+    });
+  });
+  return newProducts;
+}

package/dist/server/utils/schedule.d.ts

@@ -0,0 +1,14 @@
+import type { ScheduleItem } from '../../modules/Schedule/types';
+import type { MenuData } from '../modules/menu/types';
+/**
+ * 从餐牌列表中提取所有 schedule IDs
+ * @param menus 餐牌列表
+ * @returns 去重后的日程ID数组
+ */
+export declare function extractScheduleIdsFromMenus(menus: MenuData[]): number[];
+/**
+ * 从日程列表中提取所有时间点
+ * @param schedules 日程列表
+ * @returns 排序后的时间点数组，格式为 ["10:00", "12:00", "14:00", "18:00"]
+ */
+export declare function extractTimePointsFromSchedules(schedules: ScheduleItem[]): string[];

package/dist/server/utils/schedule.js

@@ -0,0 +1,108 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { extractTimeFromDateTime, sortTimePoints } from "./time";
+/**
+ * 从餐牌列表中提取所有 schedule IDs
+ * @param menus 餐牌列表
+ * @returns 去重后的日程ID数组
+ */
+export function extractScheduleIdsFromMenus(menus) {
+  var scheduleIds = menus.reduce(function (ids, menu) {
+    if (menu.schedule && Array.isArray(menu.schedule)) {
+      return [].concat(_toConsumableArray(ids), _toConsumableArray(menu.schedule));
+    }
+    return ids;
+  }, []);
+
+  // 去重
+  return Array.from(new Set(scheduleIds));
+}
+
+/**
+ * 从日程列表中提取所有时间点
+ * @param schedules 日程列表
+ * @returns 排序后的时间点数组，格式为 ["10:00", "12:00", "14:00", "18:00"]
+ */
+export function extractTimePointsFromSchedules(schedules) {
+  var timePointsSet = new Set();
+  var _iterator = _createForOfIteratorHelper(schedules),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var schedule = _step.value;
+      switch (schedule.type) {
+        case 'standard':
+          // 标准类型：从 start_time 和 end_time 中提取时间部分
+          if (schedule.start_time) {
+            var startTime = extractTimeFromDateTime(schedule.start_time);
+            if (startTime) timePointsSet.add(startTime);
+          }
+          if (schedule.end_time) {
+            var endTime = extractTimeFromDateTime(schedule.end_time);
+            if (endTime) timePointsSet.add(endTime);
+          }
+          break;
+        case 'time-slots':
+          // 时间段类型：从 time_slot 数组中提取时间
+          if (schedule.time_slot && Array.isArray(schedule.time_slot)) {
+            var _iterator2 = _createForOfIteratorHelper(schedule.time_slot),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var slot = _step2.value;
+                if (slot.start_time) {
+                  timePointsSet.add(slot.start_time);
+                }
+                if (slot.end_time) {
+                  timePointsSet.add(slot.end_time);
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+          }
+          break;
+        case 'designation':
+          // 指定日期类型：从 designation 中提取时间
+          if (schedule.designation) {
+            var designations = Array.isArray(schedule.designation) ? schedule.designation : [schedule.designation];
+            var _iterator3 = _createForOfIteratorHelper(designations),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var des = _step3.value;
+                if (des.start_time) {
+                  timePointsSet.add(des.start_time);
+                }
+                if (des.end_time) {
+                  timePointsSet.add(des.end_time);
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+          }
+          break;
+        default:
+          console.warn("[ScheduleUtils] \u672A\u77E5\u7684\u65E5\u7A0B\u7C7B\u578B: ".concat(schedule.type));
+      }
+    }
+
+    // 转换为数组并排序
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  var timePoints = Array.from(timePointsSet);
+  return sortTimePoints(timePoints);
+}

package/dist/server/utils/time.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 从日期时间字符串中提取时间部分
+ * @param dateTime 日期时间字符串，格式如 "2024-01-01 10:00:00"
+ * @returns 时间字符串，格式如 "10:00"
+ */
+export declare function extractTimeFromDateTime(dateTime: string): string | null;
+/**
+ * 将时间字符串转换为分钟数（用于排序）
+ * @param timeStr 时间字符串，格式如 "10:00" 或 "14:30"
+ * @returns 从00:00开始的分钟数
+ */
+export declare function timeStringToMinutes(timeStr: string): number;
+/**
+ * 对时间点数组进行排序
+ * @param timePoints 时间点数组
+ * @returns 排序后的时间点数组
+ */
+export declare function sortTimePoints(timePoints: string[]): string[];

package/dist/server/utils/time.js

@@ -0,0 +1,53 @@
+import dayjs from 'dayjs';
+
+/**
+ * 从日期时间字符串中提取时间部分
+ * @param dateTime 日期时间字符串，格式如 "2024-01-01 10:00:00"
+ * @returns 时间字符串，格式如 "10:00"
+ */
+export function extractTimeFromDateTime(dateTime) {
+  if (!dateTime) return null;
+
+  // 使用 dayjs 解析日期时间
+  var date = dayjs(dateTime);
+  if (!date.isValid()) {
+    console.warn("[TimeUtils] \u65E0\u6548\u7684\u65E5\u671F\u65F6\u95F4\u683C\u5F0F: ".concat(dateTime));
+    return null;
+  }
+
+  // 返回 HH:mm 格式的时间
+  return date.format('HH:mm');
+}
+
+/**
+ * 将时间字符串转换为分钟数（用于排序）
+ * @param timeStr 时间字符串，格式如 "10:00" 或 "14:30"
+ * @returns 从00:00开始的分钟数
+ */
+export function timeStringToMinutes(timeStr) {
+  if (!timeStr) return 0;
+
+  // 使用 dayjs 解析时间字符串
+  // 由于只有时间没有日期，我们添加一个固定日期来解析
+  var date = dayjs("2000-01-01 ".concat(timeStr), 'YYYY-MM-DD HH:mm');
+  if (!date.isValid()) {
+    console.warn("[TimeUtils] \u65E0\u6548\u7684\u65F6\u95F4\u683C\u5F0F: ".concat(timeStr));
+    return 0;
+  }
+
+  // 计算从00:00开始的分钟数
+  return date.hour() * 60 + date.minute();
+}
+
+/**
+ * 对时间点数组进行排序
+ * @param timePoints 时间点数组
+ * @returns 排序后的时间点数组
+ */
+export function sortTimePoints(timePoints) {
+  return timePoints.sort(function (a, b) {
+    var timeA = timeStringToMinutes(a);
+    var timeB = timeStringToMinutes(b);
+    return timeA - timeB;
+  });
+}

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

@@ -324,22 +324,6 @@ export declare class BookingByStepImpl extends BaseModule implements Module {
         success: boolean;
         minAvailableCount: number;
     };
-    /**
-     * 将 ProductData 转换为 CartItem，但不添加到购物车
-     * 参考 addProductToCart 方法的实现
-     */
-    private convertProductToCartItem;
-    checkMaxDurationCapacityForDetailNums({ product, date, account, }: {
-        product: ProductData;
-        date?: {
-            startTime: string;
-            endTime: string;
-        } | null;
-        account?: Account | null;
-    }): {
-        success: boolean;
-        minAvailableCount: number;
-    };
     setOtherData(key: string, value: any): void;
     getOtherData(key: string): any;
     getProductTypeById(id: number): Promise<"normal" | "duration" | "session">;