@pisell/pisellos 0.0.569 → 0.10.2

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

@@ -1,130 +1,129 @@
-"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/menu/index.ts
+var menu_exports = {};
+__export(menu_exports, {
+  MenuModule: () => MenuModule
 });
-exports.MenuModule = void 0;
-var _lodashEs = require("lodash-es");
-var _BaseModule = require("../../../modules/BaseModule");
-var _types = require("./types");
-/**
- * IndexDB 存储名称
- */
-const INDEXDB_STORE_NAME = 'menu';
-
-/**
- * 餐牌模块 - 用于管理餐牌数据和根据餐牌过滤商品
- */
-class MenuModule extends _BaseModule.BaseModule {
-  defaultName = 'menu';
-  defaultVersion = '1.0.0';
-  request;
-  store;
-  dbManager; // IndexDBManager 实例
-  logger; // LoggerManager 实例
-
+module.exports = __toCommonJS(menu_exports);
+var import_lodash_es = require("lodash-es");
+var import_BaseModule = require("../../../modules/BaseModule");
+var import_types = require("./types");
+var INDEXDB_STORE_NAME = "menu";
+var MenuModule = class extends import_BaseModule.BaseModule {
+  // LoggerManager 实例
   constructor(name, version) {
     super(name, version);
+    this.defaultName = "menu";
+    this.defaultVersion = "1.0.0";
   }
   async initialize(core, options) {
+    var _a;
     this.core = core;
-    this.store = options?.store;
-
-    // 获取依赖的插件
-    this.request = core.getPlugin('request');
+    this.store = options == null ? void 0 : options.store;
+    this.request = core.getPlugin("request");
     if (!this.request) {
-      throw new Error('MenuModule 需要 request 插件支持');
+      throw new Error("MenuModule 需要 request 插件支持");
     }
-    if (Array.isArray(options?.initialState?.menuList)) {
-      this.store.menuList = options?.initialState.menuList;
-      // 同步更新 Map 缓存
+    if (Array.isArray((_a = options == null ? void 0 : options.initialState) == null ? void 0 : _a.menuList)) {
+      this.store.menuList = options == null ? void 0 : options.initialState.menuList;
       this.syncMenuMap();
-      this.core.effects.emit(_types.MenuHooks.onMenuChanged, this.store.menuList);
+      this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
     } else {
       this.store.menuList = [];
-      this.store.map = new Map();
+      this.store.map = /* @__PURE__ */ new Map();
     }
-
-    // 获取并存储 dbManager
-    const appPlugin = core.getPlugin('app');
+    const appPlugin = core.getPlugin("app");
     if (appPlugin) {
       const app = appPlugin.getApp();
       this.dbManager = app.dbManager;
       this.logger = app.logger;
-      if (this.dbManager) {} else {
-        console.warn('[Menu] IndexDB Manager 未找到');
+      if (this.dbManager) {
+        console.log("[Menu] IndexDB Manager 已初始化");
+      } else {
+        console.warn("[Menu] IndexDB Manager 未找到");
       }
     }
-    this.logInfo('模块初始化完成', {
+    this.logInfo("模块初始化完成", {
       hasDbManager: !!this.dbManager,
       hasLogger: !!this.logger,
       initialMenuCount: this.store.menuList.length
     });
   }
-
   /**
    * 加载餐牌列表（从服务器）
    */
   async loadMenuList() {
-    this.logInfo('开始从服务器加载餐牌列表');
+    var _a;
+    this.logInfo("开始从服务器加载餐牌列表");
     const startTime = Date.now();
     try {
-      const response = await this.request.get(`/form/data/v1`, {
-        skip: 1,
-        num: 999,
-        code: 'menu_list'
-      }, {
-        cache: undefined
-      });
-      const menuList = response?.data?.list || [];
+      const response = await this.request.get(
+        `/form/data/v1`,
+        {
+          skip: 1,
+          num: 999,
+          code: "menu_list"
+        },
+        { cache: void 0 }
+      );
+      const menuList = ((_a = response == null ? void 0 : response.data) == null ? void 0 : _a.list) || [];
       const duration = Date.now() - startTime;
-      this.logInfo('从服务器加载餐牌列表成功', {
+      this.logInfo("从服务器加载餐牌列表成功", {
         menuCount: menuList.length,
         duration: `${duration}ms`
       });
-
-      // 保存到 IndexDB
       await this.saveMenuToIndexDB(menuList);
       await this.setMenuList(menuList);
       return menuList;
     } catch (error) {
       const duration = Date.now() - startTime;
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Menu] 加载餐牌数据失败:', error);
-      this.logError('从服务器加载餐牌列表失败', {
+      console.error("[Menu] 加载餐牌数据失败:", error);
+      this.logError("从服务器加载餐牌列表失败", {
         duration: `${duration}ms`,
         error: errorMessage
       });
       return [];
     }
   }
-
   /**
    * 设置餐牌列表
    */
   async setMenuList(menuList) {
     this.store.menuList = menuList;
-    // 同步更新 Map 缓存
     this.syncMenuMap();
-    await this.core.effects.emit(_types.MenuHooks.onMenuLoaded, menuList);
+    await this.core.effects.emit(import_types.MenuHooks.onMenuLoaded, menuList);
   }
-
   /**
    * 获取餐牌列表
    */
   getMenuList() {
     return this.store.menuList;
   }
-
   /**
    * 根据 form_record_id 数组获取餐牌详情
    * 使用 Map 快速查询，时间复杂度 O(m)，m 为 ids 数量
    */
   getMenuByIds(ids) {
     if (!ids || ids.length === 0) {
-      this.logInfo('getMenuByIds: 未提供有效的 ids', {
-        idsCount: 0
-      });
+      this.logInfo("getMenuByIds: 未提供有效的 ids", { idsCount: 0 });
       return [];
     }
     const result = [];
@@ -134,14 +133,13 @@ class MenuModule extends _BaseModule.BaseModule {
         result.push(menu);
       }
     }
-    this.logInfo('getMenuByIds: 查询完成', {
+    this.logInfo("getMenuByIds: 查询完成", {
       requestedCount: ids.length,
       foundCount: result.length,
       notFoundCount: ids.length - result.length
     });
     return result;
   }
-
   /**
    * 同步更新餐牌 Map 缓存
    * 将 menuList 中的餐牌同步到 map，以 form_record_id 为 key
@@ -152,171 +150,151 @@ class MenuModule extends _BaseModule.BaseModule {
     for (const menu of this.store.menuList) {
       this.store.map.set(menu.form_record_id, menu);
     }
+    console.log(`[Menu] Map 缓存已同步，共 ${this.store.map.size} 个餐牌`);
   }
-
   /**
    * 清空缓存
    */
   async clear() {
-    this.logInfo('开始清空缓存', {
+    this.logInfo("开始清空缓存", {
       currentMenuCount: this.store.menuList.length
     });
     this.store.menuList = [];
     this.store.map.clear();
-    this.store.currentMenu = undefined;
-
-    // 同时清空 IndexDB 中的数据
+    this.store.currentMenu = void 0;
     if (this.dbManager) {
       try {
         await this.dbManager.clear(INDEXDB_STORE_NAME);
-        this.logInfo('IndexDB 缓存已清空');
+        console.log("[Menu] IndexDB 缓存已清空");
+        this.logInfo("IndexDB 缓存已清空");
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error('[Menu] 清空 IndexDB 缓存失败:', error);
-        this.logError('清空 IndexDB 缓存失败', {
-          error: errorMessage
-        });
+        console.error("[Menu] 清空 IndexDB 缓存失败:", error);
+        this.logError("清空 IndexDB 缓存失败", { error: errorMessage });
       }
     }
-    this.logInfo('缓存清空完成');
+    console.log("[Menu] 缓存已清空");
+    this.logInfo("缓存清空完成");
   }
-
   /**
    * 从 IndexDB 加载餐牌数据
    * @private
    */
   async loadMenuFromIndexDB() {
     if (!this.dbManager) {
-      this.logWarning('loadMenuFromIndexDB: dbManager 不可用');
+      this.logWarning("loadMenuFromIndexDB: dbManager 不可用");
       return [];
     }
     try {
-      // 直接获取所有餐牌记录
       const menuList = await this.dbManager.getAll(INDEXDB_STORE_NAME);
-      this.logInfo('从 IndexDB 加载餐牌数据', {
-        menuCount: menuList?.length ?? 0
+      this.logInfo("从 IndexDB 加载餐牌数据", {
+        menuCount: (menuList == null ? void 0 : menuList.length) ?? 0
       });
       return menuList || [];
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Menu] 从 IndexDB 读取数据失败:', error);
-      this.logError('从 IndexDB 读取数据失败', {
-        error: errorMessage
-      });
+      console.error("[Menu] 从 IndexDB 读取数据失败:", error);
+      this.logError("从 IndexDB 读取数据失败", { error: errorMessage });
       return [];
     }
   }
-
   /**
    * 保存餐牌数据到 IndexDB
    * @private
    */
   async saveMenuToIndexDB(menuList) {
     if (!this.dbManager) {
-      this.logWarning('saveMenuToIndexDB: dbManager 不可用');
+      this.logWarning("saveMenuToIndexDB: dbManager 不可用");
       return;
     }
-    this.logInfo('开始保存餐牌数据到 IndexDB', {
-      menuCount: menuList.length
-    });
+    this.logInfo("开始保存餐牌数据到 IndexDB", { menuCount: menuList.length });
     try {
-      // 先清空现有的餐牌数据
       await this.dbManager.clear(INDEXDB_STORE_NAME);
-
-      // 逐个保存餐牌（每个餐牌是独立的记录）
-      const savePromises = menuList.map(menu => this.dbManager.add(INDEXDB_STORE_NAME, menu));
+      const savePromises = menuList.map(
+        (menu) => this.dbManager.add(INDEXDB_STORE_NAME, menu)
+      );
       await Promise.all(savePromises);
-      this.logInfo('餐牌数据已保存到 IndexDB', {
-        menuCount: menuList.length
-      });
+      console.log(`[Menu] 已将 ${menuList.length} 条餐牌数据保存到 IndexDB`);
+      this.logInfo("餐牌数据已保存到 IndexDB", { menuCount: menuList.length });
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.error('[Menu] 保存数据到 IndexDB 失败:', error);
-      this.logError('保存数据到 IndexDB 失败', {
+      console.error("[Menu] 保存数据到 IndexDB 失败:", error);
+      this.logError("保存数据到 IndexDB 失败", {
         menuCount: menuList.length,
         error: errorMessage
       });
     }
   }
-
   /**
    * 预加载模块数据（统一接口）
    * 在模块注册后自动调用
    */
   async preload() {
+    console.log("[Menu] 开始预加载数据...");
     const startTime = Date.now();
-    this.logInfo('开始预加载数据');
+    this.logInfo("开始预加载数据");
     try {
-      // 1. 尝试从 IndexDB 加载数据
       const cachedData = await this.loadMenuFromIndexDB();
       if (cachedData && cachedData.length > 0) {
-        // 将缓存数据放入 store
-        this.store.menuList = (0, _lodashEs.cloneDeep)(cachedData);
-        // 同步更新 Map 缓存
+        console.log(`[Menu] 从 IndexDB 加载了 ${cachedData.length} 条餐牌数据`);
+        this.store.menuList = (0, import_lodash_es.cloneDeep)(cachedData);
         this.syncMenuMap();
-        this.core.effects.emit(_types.MenuHooks.onMenuChanged, this.store.menuList);
+        this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
         const duration = Date.now() - startTime;
-        this.logInfo('预加载完成（从 IndexDB）', {
+        this.logInfo("预加载完成（从 IndexDB）", {
           menuCount: cachedData.length,
           duration: `${duration}ms`,
-          source: 'IndexDB'
+          source: "IndexDB"
         });
         return;
       }
-      this.logInfo('IndexDB 中没有缓存数据，准备从服务器加载');
+      console.log("[Menu] IndexDB 中没有缓存数据，从服务器加载...");
+      this.logInfo("IndexDB 中没有缓存数据，准备从服务器加载");
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      console.warn('[Menu] 从 IndexDB 加载数据失败:', error);
-      this.logWarning('从 IndexDB 加载数据失败，准备从服务器加载', {
-        error: errorMessage
-      });
+      console.warn("[Menu] 从 IndexDB 加载数据失败:", error);
+      this.logWarning("从 IndexDB 加载数据失败，准备从服务器加载", { error: errorMessage });
     }
-
-    // 2. 如果 IndexDB 中没有数据，从服务器加载
     const menuList = await this.loadMenuList();
-
-    // 3. 将服务器数据保存到 IndexDB 和 store
     if (menuList && menuList.length > 0) {
       await this.saveMenuToIndexDB(menuList);
-      this.store.menuList = (0, _lodashEs.cloneDeep)(menuList);
-      // 同步更新 Map 缓存
+      this.store.menuList = (0, import_lodash_es.cloneDeep)(menuList);
       this.syncMenuMap();
-      this.core.effects.emit(_types.MenuHooks.onMenuChanged, this.store.menuList);
+      this.core.effects.emit(import_types.MenuHooks.onMenuChanged, this.store.menuList);
       const duration = Date.now() - startTime;
-      this.logInfo('预加载完成（从服务器）', {
+      this.logInfo("预加载完成（从服务器）", {
         menuCount: menuList.length,
         duration: `${duration}ms`,
-        source: 'Server'
+        source: "Server"
       });
     } else {
       const duration = Date.now() - startTime;
-      this.logWarning('预加载完成但未获取到数据', {
+      this.logWarning("预加载完成但未获取到数据", {
         duration: `${duration}ms`
       });
     }
   }
-
   /**
    * 获取模块的路由定义
    * 返回该模块需要注册的 API 路由
    */
   getRoutes() {
     return [
-    // GET /api/menu - 获取所有餐牌
-    {
-      method: 'get',
-      path: '/api/menu',
-      handler: async () => {
-        const menuList = this.getMenuList();
-        return {
-          success: true,
-          data: menuList,
-          total: menuList.length
-        };
+      // GET /api/menu - 获取所有餐牌
+      {
+        method: "get",
+        path: "/api/menu",
+        handler: async () => {
+          const menuList = this.getMenuList();
+          return {
+            success: true,
+            data: menuList,
+            total: menuList.length
+          };
+        }
       }
-    }];
+    ];
   }
-
   /**
    * 记录信息日志
    * @param title 日志标题
@@ -326,16 +304,14 @@ class MenuModule extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'info',
+          type: "info",
           title: `[MenuModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
-
   /**
    * 记录警告日志
    * @param title 日志标题
@@ -345,16 +321,14 @@ class MenuModule extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'warning',
+          type: "warning",
           title: `[MenuModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
-
   /**
    * 记录错误日志
    * @param title 日志标题
@@ -364,14 +338,16 @@ class MenuModule extends _BaseModule.BaseModule {
     try {
       if (this.logger) {
         this.logger.addLog({
-          type: 'error',
+          type: "error",
           title: `[MenuModule] ${title}`,
           metadata: metadata || {}
         });
       }
     } catch {
-      // 日志记录失败不影响主流程
     }
   }
-}
-exports.MenuModule = MenuModule;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuModule
+});

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

@@ -1,20 +1,33 @@
-"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/menu/types.ts
+var types_exports = {};
+__export(types_exports, {
+  MenuHooks: () => MenuHooks
+});
+module.exports = __toCommonJS(types_exports);
+var MenuHooks = /* @__PURE__ */ ((MenuHooks2) => {
+  MenuHooks2["onMenuLoaded"] = "menu:onMenuLoaded";
+  MenuHooks2["onMenuChanged"] = "menu:onMenuChanged";
+  return MenuHooks2;
+})(MenuHooks || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuHooks
 });
-exports.MenuHooks = void 0;
-/**
- * 餐牌模块状态
- */
-/**
- * 餐牌数据结构
- */
-/**
- * 餐牌模块钩子
- */
-let MenuHooks = exports.MenuHooks = /*#__PURE__*/function (MenuHooks) {
-  MenuHooks["onMenuLoaded"] = "menu:onMenuLoaded";
-  MenuHooks["onMenuChanged"] = "menu:onMenuChanged";
-  return MenuHooks;
-}({});