@pisell/pisellos 0.0.568 → 0.10.1

package/lib/server/modules/resource/types.js

@@ -1,44 +1,35 @@
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/server/modules/resource/types.ts
+var types_exports = {};
+__export(types_exports, {
+  ResourceHooks: () => ResourceHooks
+});
+module.exports = __toCommonJS(types_exports);
+var ResourceHooks = /* @__PURE__ */ ((ResourceHooks2) => {
+  ResourceHooks2["onResourcesLoaded"] = "resource:onResourcesLoaded";
+  ResourceHooks2["onResourcesChanged"] = "resource:onResourcesChanged";
+  ResourceHooks2["onResourcesSyncCompleted"] = "resource:onResourcesSyncCompleted";
+  ResourceHooks2["onBookingsChanged"] = "resource:onBookingsChanged";
+  return ResourceHooks2;
+})(ResourceHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResourceHooks
 });
-exports.ResourceHooks = void 0;
-/**
- * Resource 模块主键类型
- */
-/**
- * Sales / ScheduleEventResource：预约条目内关联资源（仅 ID 与占用，详情由设备端基准数据解析）
- * @see 统一 Sales 数据协议 3.4.1 resources
- */
-/**
- * 资源预订数据结构
- */
-/**
- * 资源数据结构（兼容历史数据）
- */
-/**
- * 查询选项
- */
-/**
- * Resource 模块状态
- */
-/**
- * 与 ResourceDataSource 对齐的分页查询参数
- */
-/**
- * 与 ResourceDataSource 对齐的分页返回结构
- */
-/**
- * ResourceSyncMessage - pubsub 同步消息结构
- */
-/**
- * Resource 模块钩子
- */
-let ResourceHooks = exports.ResourceHooks = /*#__PURE__*/function (ResourceHooks) {
-  ResourceHooks["onResourcesLoaded"] = "resource:onResourcesLoaded";
-  ResourceHooks["onResourcesChanged"] = "resource:onResourcesChanged";
-  ResourceHooks["onResourcesSyncCompleted"] = "resource:onResourcesSyncCompleted";
-  ResourceHooks["onBookingsChanged"] = "resource:onBookingsChanged";
-  return ResourceHooks;
-}({});

package/lib/server/modules/schedule/index.d.ts

@@ -12,6 +12,7 @@ export declare class ScheduleModuleEx extends BaseModule implements Module, Sche
     private store;
     private dbManager;
     private logger;
+    private hasLoadedScheduleList;
     constructor(name?: string, version?: string);
     /**
      * 记录信息日志
@@ -41,6 +42,7 @@ export declare class ScheduleModuleEx extends BaseModule implements Module, Sche
      * 获取所有日程列表
      */
     getScheduleList(): ScheduleItem[];
+    isScheduleListLoaded(): boolean;
     /**
      * 根据 schedule IDs 获取日程数据
      * 使用 Map 快速查询，时间复杂度 O(m)，m 为 ids 数量
@@ -64,15 +66,15 @@ export declare class ScheduleModuleEx extends BaseModule implements Module, Sche
      */
     getDateIsInSchedule(date: string, scheduleList: (ScheduleItem | number)[]): boolean;
     /**
-     * 从 IndexDB 加载日程数据
+     * 从 SQLite 加载日程数据
      * @private
      */
-    private loadScheduleFromIndexDB;
+    private loadScheduleFromSQLite;
     /**
-     * 保存日程数据到 IndexDB
+     * 保存日程数据到 SQLite
      * @private
      */
-    private saveScheduleToIndexDB;
+    private saveScheduleToSQLite;
     /**
      * 预加载模块数据（统一接口）
      * 在模块注册后自动调用

package/lib/server/modules/schedule/index.js

@@ -1,40 +1,55 @@
-"use strict";
+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);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/server/modules/schedule/index.ts
+var schedule_exports = {};
+__export(schedule_exports, {
+  ScheduleModuleEx: () => ScheduleModuleEx
 });
-exports.ScheduleModuleEx = void 0;
-var _lodashEs = require("lodash-es");
-var _BaseModule = require("../../../modules/BaseModule");
-var _dayjs = _interopRequireDefault(require("dayjs"));
-var _isSameOrBefore = _interopRequireDefault(require("dayjs/plugin/isSameOrBefore"));
-var _isSameOrAfter = _interopRequireDefault(require("dayjs/plugin/isSameOrAfter"));
-var _utils = require("../../../solution/ShopDiscount/utils");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-_dayjs.default.extend(_isSameOrBefore.default);
-_dayjs.default.extend(_isSameOrAfter.default);
-
-/**
- * IndexDB 存储名称
- */
-const INDEXDB_STORE_NAME = 'schedule';
-
-/**
- * Schedule 模块（扩展版本）
- * 在原有基础上添加了 getAvailableScheduleIds 方法
- */
-class ScheduleModuleEx extends _BaseModule.BaseModule {
-  defaultName = 'schedule';
-  defaultVersion = '1.1.0';
-  request;
-  store = {};
-  dbManager; // IndexDBManager 实例
-  logger; // LoggerManager 实例
-
+module.exports = __toCommonJS(schedule_exports);
+var import_lodash_es = require("lodash-es");
+var import_BaseModule = require("../../../modules/BaseModule");
+var import_dayjs = __toESM(require("dayjs"));
+var import_isSameOrBefore = __toESM(require("dayjs/plugin/isSameOrBefore"));
+var import_isSameOrAfter = __toESM(require("dayjs/plugin/isSameOrAfter"));
+var import_utils = require("../../../solution/ShopDiscount/utils");
+import_dayjs.default.extend(import_isSameOrBefore.default);
+import_dayjs.default.extend(import_isSameOrAfter.default);
+var SCHEDULE_STORE_NAME = "schedule";
+var ScheduleModuleEx = class extends import_BaseModule.BaseModule {
   constructor(name, version) {
     super(name, version);
+    this.defaultName = "schedule";
+    this.defaultVersion = "1.1.0";
+    this.store = {};
+    // LoggerManager 实例
+    this.hasLoadedScheduleList = false;
   }
-
   /**
    * 记录信息日志
    * @param title 日志标题
@@ -44,16 +59,14 @@ class ScheduleModuleEx extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'info',
+          type: "info",
           title: `[ScheduleModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
-
   /**
    * 记录警告日志
    * @param title 日志标题
@@ -63,16 +76,14 @@ class ScheduleModuleEx extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'warning',
+          type: "warning",
           title: `[ScheduleModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
-
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -82,77 +93,73 @@ class ScheduleModuleEx extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'error',
+          type: "error",
           title: `[ScheduleModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
   async initialize(core, options) {
     this.core = core;
-
-    // 获取依赖的插件
-    this.request = core.getPlugin('request');
+    this.request = core.getPlugin("request");
     if (!this.request) {
-      throw new Error('ScheduleModule 需要 request 插件支持');
+      throw new Error("ScheduleModule 需要 request 插件支持");
     }
-    this.store = options?.store;
+    this.store = options == null ? void 0 : options.store;
     if (options.initialState) {
       this.store.scheduleList = options.initialState.scheduleList;
-      // 同步更新 Map 缓存
       this.syncScheduleMap();
+      this.hasLoadedScheduleList = Array.isArray(options.initialState.scheduleList);
     } else {
       this.store.scheduleList = [];
-      this.store.map = new Map();
+      this.store.map = /* @__PURE__ */ new Map();
+      this.hasLoadedScheduleList = false;
     }
-
-    // 获取并存储 dbManager 和 logger
-    const appPlugin = core.getPlugin('app');
+    const appPlugin = core.getPlugin("app");
     if (appPlugin) {
       const app = appPlugin.getApp();
-      this.dbManager = app.dbManager;
+      this.dbManager = app.sqlite;
       this.logger = app.logger;
-      if (this.dbManager) {} else {
-        console.warn('[Schedule] IndexDB Manager 未找到');
+      if (this.dbManager) {
+        console.log("[Schedule] SQLite 已初始化");
+      } else {
+        console.warn("[Schedule] SQLite 未找到");
       }
     }
-    this.logInfo('模块初始化完成', {
+    this.logInfo("模块初始化完成", {
       hasDbManager: !!this.dbManager,
       hasLogger: !!this.logger,
       initialScheduleCount: this.store.scheduleList.length
     });
   }
-
   /**
    * 加载当前店铺下所有 schedule（从服务器）
    */
   async loadAllSchedule() {
-    this.logInfo('开始从服务器加载日程列表');
+    var _a;
+    this.logInfo("开始从服务器加载日程列表");
     const startTime = Date.now();
     try {
-      const scheduleList = await this.request.get(`/schedule`, {
-        num: 999
-      }, {
-        cache: undefined
-      });
-      const list = scheduleList.data?.list || [];
+      const scheduleList = await this.request.get(
+        `/schedule`,
+        { num: 999 },
+        { cache: void 0 }
+      );
+      const list = ((_a = scheduleList.data) == null ? void 0 : _a.list) || [];
       const duration = Date.now() - startTime;
-      this.logInfo('从服务器加载日程列表成功', {
+      this.logInfo("从服务器加载日程列表成功", {
         scheduleCount: list.length,
         duration: `${duration}ms`
       });
-
-      // 保存到 IndexDB
-      await this.saveScheduleToIndexDB(list);
+      await this.saveScheduleToSQLite(list);
       this.setScheduleList(list);
       return list;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
-      this.logError('从服务器加载日程列表失败', {
+      this.logError("从服务器加载日程列表失败", {
         duration: `${duration}ms`,
         error: errorMessage
       });
@@ -161,43 +168,42 @@ class ScheduleModuleEx extends _BaseModule.BaseModule {
   }
   setScheduleList(list) {
     this.store.scheduleList = list;
-    // 同步更新 Map 缓存
+    this.hasLoadedScheduleList = true;
     this.syncScheduleMap();
   }
-
   /**
    * 获取所有日程列表
    */
   getScheduleList() {
     return this.store.scheduleList;
   }
-
+  isScheduleListLoaded() {
+    return this.hasLoadedScheduleList;
+  }
   /**
    * 根据 schedule IDs 获取日程数据
    * 使用 Map 快速查询，时间复杂度 O(m)，m 为 ids 数量
    */
   getScheduleByIds(ids) {
     if (!ids || ids.length === 0) {
-      this.logInfo('getScheduleByIds: 未提供有效的 ids', {
-        idsCount: 0
-      });
+      this.logInfo("getScheduleByIds: 未提供有效的 ids", { idsCount: 0 });
       return [];
     }
     const result = [];
+    const scheduleList = this.store.scheduleList || [];
     for (const id of ids) {
-      const schedule = this.store.map.get(id);
+      const schedule = this.store.map.get(id) || scheduleList.find((item) => String(item.id) === String(id));
       if (schedule) {
         result.push(schedule);
       }
     }
-    this.logInfo('getScheduleByIds: 查询完成', {
+    this.logInfo("getScheduleByIds: 查询完成", {
       requestedCount: ids.length,
       foundCount: result.length,
       notFoundCount: ids.length - result.length
     });
     return result;
   }
-
   /**
    * 同步更新日程 Map 缓存
    * 将 scheduleList 中的日程同步到 map，以 id 为 key
@@ -208,33 +214,30 @@ class ScheduleModuleEx extends _BaseModule.BaseModule {
     for (const schedule of this.store.scheduleList) {
       this.store.map.set(schedule.id, schedule);
     }
+    console.log(`[Schedule] Map 缓存已同步，共 ${this.store.map.size} 个日程`);
   }
-
   /**
    * 清除缓存
    */
   async clear() {
-    this.logInfo('开始清空缓存', {
+    this.logInfo("开始清空缓存", {
       currentScheduleCount: this.store.scheduleList.length
     });
     this.store.scheduleList = [];
     this.store.map.clear();
-    // 同时清空 IndexDB 中的数据
     if (this.dbManager) {
       try {
-        await this.dbManager.clear(INDEXDB_STORE_NAME);
-        this.logInfo('IndexDB 缓存已清空');
+        await this.dbManager.clear(SCHEDULE_STORE_NAME);
+        console.log("[Schedule] SQLite 缓存已清空");
+        this.logInfo("SQLite 缓存已清空");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error('[Schedule] 清空 IndexDB 缓存失败:', error);
-        this.logError('清空 IndexDB 缓存失败', {
-          error: errorMessage
-        });
+        console.error("[Schedule] 清空 SQLite 缓存失败:", error);
+        this.logError("清空 SQLite 缓存失败", { error: errorMessage });
       }
     }
-    this.logInfo('缓存清空完成');
+    this.logInfo("缓存清空完成");
   }
-
   /**
    * 判断日期是否在日程范围内
    * @param date 日期
@@ -243,133 +246,129 @@ class ScheduleModuleEx extends _BaseModule.BaseModule {
    */
   getDateIsInSchedule(date, scheduleList) {
     const scheduleListData = [];
-    scheduleList.forEach(item => {
-      if (typeof item === 'number') {
+    scheduleList.forEach((item) => {
+      if (typeof item === "number") {
         scheduleListData.push(...this.getScheduleByIds([item]));
       } else {
         scheduleListData.push(item);
       }
     });
-    const result = (0, _utils.getDateIsInSchedule)(date, scheduleListData);
-    this.logInfo('getDateIsInSchedule: 判断日期是否在日程范围内', {
+    const result = (0, import_utils.getDateIsInSchedule)(date, scheduleListData);
+    this.logInfo("getDateIsInSchedule: 判断日期是否在日程范围内", {
       date,
       scheduleCount: scheduleListData.length,
       isInSchedule: result
     });
     return result;
   }
-
   /**
-   * 从 IndexDB 加载日程数据
+   * 从 SQLite 加载日程数据
    * @private
    */
-  async loadScheduleFromIndexDB() {
+  async loadScheduleFromSQLite() {
     if (!this.dbManager) {
-      this.logWarning('loadScheduleFromIndexDB: dbManager 不可用');
+      this.logWarning("loadScheduleFromSQLite: SQLite 不可用");
       return [];
     }
     try {
-      // 直接获取所有日程记录
-      const scheduleList = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      this.logInfo('从 IndexDB 加载日程数据', {
-        scheduleCount: scheduleList?.length ?? 0
+      const scheduleList = await this.dbManager.getAll(SCHEDULE_STORE_NAME);
+      this.logInfo("从 SQLite 加载日程数据", {
+        scheduleCount: (scheduleList == null ? void 0 : scheduleList.length) ?? 0
       });
       return scheduleList || [];
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Schedule] 从 IndexDB 读取数据失败:', error);
-      this.logError('从 IndexDB 读取数据失败', {
-        error: errorMessage
-      });
+      console.error("[Schedule] 从 SQLite 读取数据失败:", error);
+      this.logError("从 SQLite 读取数据失败", { error: errorMessage });
       return [];
     }
   }
-
   /**
-   * 保存日程数据到 IndexDB
+   * 保存日程数据到 SQLite
    * @private
    */
-  async saveScheduleToIndexDB(scheduleList) {
+  async saveScheduleToSQLite(scheduleList) {
     if (!this.dbManager) {
-      this.logWarning('saveScheduleToIndexDB: dbManager 不可用');
+      this.logWarning("saveScheduleToSQLite: SQLite 不可用");
       return;
     }
-    this.logInfo('开始保存日程数据到 IndexDB', {
-      scheduleCount: scheduleList.length
-    });
+    this.logInfo("开始保存日程数据到 SQLite", { scheduleCount: scheduleList.length });
     try {
-      // 先清空现有的日程数据
-      await this.dbManager.clear(INDEXDB_STORE_NAME);
-
-      // 逐个保存日程（每个日程是独立的记录）
-      const savePromises = scheduleList.map(schedule => this.dbManager.add(INDEXDB_STORE_NAME, schedule));
-      await Promise.all(savePromises);
-      this.logInfo('日程数据已保存到 IndexDB', {
-        scheduleCount: scheduleList.length
-      });
+      await this.dbManager.clear(SCHEDULE_STORE_NAME);
+      if (scheduleList.length > 0) {
+        if (typeof this.dbManager.bulkAdd === "function") {
+          await this.dbManager.bulkAdd(SCHEDULE_STORE_NAME, scheduleList);
+        } else if (typeof this.dbManager.bulkUpdate === "function") {
+          await this.dbManager.bulkUpdate(SCHEDULE_STORE_NAME, scheduleList);
+        } else {
+          await Promise.all(scheduleList.map(
+            (schedule) => this.dbManager.add(SCHEDULE_STORE_NAME, schedule)
+          ));
+        }
+      }
+      console.log(
+        `[Schedule] 已将 ${scheduleList.length} 条日程数据保存到 SQLite`
+      );
+      this.logInfo("日程数据已保存到 SQLite", { scheduleCount: scheduleList.length });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Schedule] 保存数据到 IndexDB 失败:', error);
-      this.logError('保存数据到 IndexDB 失败', {
+      console.error("[Schedule] 保存数据到 SQLite 失败:", error);
+      this.logError("保存数据到 SQLite 失败", {
         scheduleCount: scheduleList.length,
         error: errorMessage
       });
     }
   }
-
   /**
    * 预加载模块数据（统一接口）
    * 在模块注册后自动调用
    */
   async preload() {
+    console.log("[Schedule] 开始预加载数据...");
     const startTime = Date.now();
-    this.logInfo('开始预加载数据');
+    this.logInfo("开始预加载数据");
     try {
-      // 1. 尝试从 IndexDB 加载数据
-      const cachedData = await this.loadScheduleFromIndexDB();
+      const cachedData = await this.loadScheduleFromSQLite();
       if (cachedData && cachedData.length > 0) {
-        // 将缓存数据放入 store
-        this.store.scheduleList = (0, _lodashEs.cloneDeep)(cachedData);
-        // 同步更新 Map 缓存
+        console.log(
+          `[Schedule] 从 SQLite 加载了 ${cachedData.length} 条日程数据`
+        );
+        this.store.scheduleList = (0, import_lodash_es.cloneDeep)(cachedData);
         this.syncScheduleMap();
         const duration = Date.now() - startTime;
-        this.logInfo('预加载完成（从 IndexDB）', {
+        this.logInfo("预加载完成（从 SQLite）", {
           scheduleCount: cachedData.length,
           duration: `${duration}ms`,
-          source: 'IndexDB'
+          source: "SQLite"
         });
         return;
       }
-      this.logInfo('IndexDB 中没有缓存数据，准备从服务器加载');
+      console.log("[Schedule] SQLite 中没有缓存数据，从服务器加载...");
+      this.logInfo("SQLite 中没有缓存数据，准备从服务器加载");
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn('[Schedule] 从 IndexDB 加载数据失败:', error);
-      this.logWarning('从 IndexDB 加载数据失败，准备从服务器加载', {
-        error: errorMessage
-      });
+      console.warn("[Schedule] 从 SQLite 加载数据失败:", error);
+      this.logWarning("从 SQLite 加载数据失败，准备从服务器加载", { error: errorMessage });
     }
-
-    // 2. 如果 IndexDB 中没有数据，从服务器加载
     const scheduleList = await this.loadAllSchedule();
-
-    // 3. 将服务器数据保存到 IndexDB 和 store
     if (scheduleList && scheduleList.length > 0) {
-      await this.saveScheduleToIndexDB(scheduleList);
-      this.store.scheduleList = (0, _lodashEs.cloneDeep)(scheduleList);
-      // 同步更新 Map 缓存
+      this.store.scheduleList = (0, import_lodash_es.cloneDeep)(scheduleList);
       this.syncScheduleMap();
       const duration = Date.now() - startTime;
-      this.logInfo('预加载完成（从服务器）', {
+      this.logInfo("预加载完成（从服务器）", {
         scheduleCount: scheduleList.length,
         duration: `${duration}ms`,
-        source: 'Server'
+        source: "Server"
       });
     } else {
       const duration = Date.now() - startTime;
-      this.logWarning('预加载完成但未获取到数据', {
+      this.logWarning("预加载完成但未获取到数据", {
         duration: `${duration}ms`
       });
     }
   }
-}
-exports.ScheduleModuleEx = ScheduleModuleEx;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ScheduleModuleEx
+});

package/lib/server/modules/schedule/types.js

@@ -1,16 +1,23 @@
-"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
+// src/server/modules/schedule/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("../../../modules/Schedule/types"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("../../../modules/Schedule/types")
 });
-var _types = require("../../../modules/Schedule/types");
-Object.keys(_types).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _types[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function () {
-      return _types[key];
-    }
-  });
-});