@pisell/core 0.0.2

package/lib/logger/index.js

@@ -0,0 +1,476 @@
+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/logger/index.ts
+var logger_exports = {};
+__export(logger_exports, {
+  default: () => logger_default
+});
+module.exports = __toCommonJS(logger_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_feishu = require("./feishu");
+var LoggerManager = class {
+  // 私有属性
+  logBuffer = [];
+  // 日志缓冲区
+  timer = null;
+  // 定时器
+  checkInterval;
+  // 检查间隔时间（毫秒）
+  prefix = "app";
+  // 日志文件前缀
+  metadata;
+  db = null;
+  // IndexDB 实例
+  app;
+  feishuConfig;
+  retentionDays;
+  // 日志保留天数
+  metadataFunction;
+  status = "running";
+  // 日志管理器状态
+  /**
+   * 构造函数
+   * @param prefix 日志前缀
+   * @param checkInterval 检查间隔时间，默认5分钟
+   */
+  constructor(app, options) {
+    this.prefix = (options == null ? void 0 : options.prefix) || "app";
+    this.checkInterval = (options == null ? void 0 : options.checkInterval) || 5 * 60 * 1e3;
+    this.app = app;
+    this.feishuConfig = options == null ? void 0 : options.feishuConfig;
+    this.retentionDays = (options == null ? void 0 : options.retentionDays) || 7;
+    this.initDB();
+  }
+  async init() {
+    this.setStatus("running");
+    this.initTimer();
+    this.cleanupOldLogs();
+  }
+  /**
+   * 初始化 IndexDB
+   */
+  async initDB() {
+    if (this.app.dbManager) {
+      this.db = this.app.dbManager;
+    }
+  }
+  /**
+   * 设置元数据
+   * @param metadata 元数据
+   */
+  setMetadata(metadata) {
+    this.metadata = metadata;
+  }
+  setMetadataFunction(metadataFunction) {
+    this.metadataFunction = metadataFunction;
+  }
+  /**
+   * 初始化定时器
+   */
+  initTimer() {
+    this.timer = setInterval(() => {
+      if (this.logBuffer.length > 0) {
+        this.storeLog();
+      }
+    }, this.checkInterval);
+  }
+  setStatus(status) {
+    this.status = status;
+  }
+  stop() {
+    this.setStatus("stop");
+    if (this.timer) {
+      clearInterval(this.timer);
+    }
+  }
+  /**
+   * 添加日志
+   * @param log 日志项
+   */
+  addLog(log) {
+    if (this.status === "stop") {
+      return;
+    }
+    const { feishu, ...restLog } = log || {};
+    const logItem = {
+      ...restLog,
+      date: log.date || (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss"),
+      metadata: JSON.stringify(log.metadata || {}),
+      // 以时间戳生成logId
+      logId: (0, import_dayjs.default)().valueOf()
+    };
+    console.log("---- 行为日志", logItem);
+    this.logBuffer.push(logItem);
+    if (log.type === "error" || log.type === "warning") {
+      this.sendFeishuNotification({ ...logItem || {}, feishu });
+      this.storeLog(log.type === "error");
+    }
+  }
+  /**
+   * 发送飞书通知
+   * @param log 日志项
+   */
+  sendFeishuNotification(log) {
+    var _a;
+    if (this.feishuConfig) {
+      const _metadata = ((_a = this.metadataFunction) == null ? void 0 : _a.call(this)) || {};
+      const content = [
+        { key: "日志类型", value: log.type },
+        { key: "日志时间", value: log.date || (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss") },
+        { key: "日志来源", value: JSON.stringify({ ...this.metadata || {}, ..._metadata }) }
+      ];
+      if (log.feishu) {
+        content.push({ key: "日志内容", value: JSON.stringify(log.feishu || {}) });
+      } else {
+        content.push({ key: "日志内容", value: JSON.stringify(log.metadata || {}) });
+      }
+      (0, import_feishu.sendWarningLog)({
+        title: log.title,
+        content,
+        webhook: this.feishuConfig.webhook
+      });
+      console.log("-------- 发送飞书通知", log);
+    }
+  }
+  /**
+   * 创建日志文件名
+   * @returns 日志文件名
+   */
+  createFileName(date) {
+    const _date = date || (0, import_dayjs.default)().format("YYYY-MM-DD-HH");
+    const fileName = `${this.prefix}_${_date}.log`;
+    return fileName;
+  }
+  /**
+   * 创建AWS日志文件名
+   * @param isManual 紧急上传
+   * @returns 日志文件名
+   */
+  async createAWSFileName(urgent) {
+    var _a, _b, _c, _d;
+    const _date = (0, import_dayjs.default)().format("YYYY-MM-DD");
+    let _hour = (0, import_dayjs.default)().format("HH:mm");
+    if (urgent) {
+      _hour = `${(0, import_dayjs.default)().format("HH:mm")} [ urgent ] ${(0, import_dayjs.default)().valueOf()}`;
+    }
+    if ((_b = (_a = this.app) == null ? void 0 : _a.getPlugin("aws")) == null ? void 0 : _b.createFileName) {
+      return (_d = (_c = this.app) == null ? void 0 : _c.getPlugin("aws")) == null ? void 0 : _d.createFileName({
+        date: _date,
+        hour: _hour,
+        isManual: false
+      });
+    }
+    let fileName = `logs/${"pisell"}/${_date}/${_hour}`;
+    return `${fileName}.json`;
+  }
+  /**
+   * 创建日志文件
+   * @param _fileName 文件名
+   * @returns 日志文件对象
+   */
+  createFile(_fileName) {
+    const _date = (0, import_dayjs.default)().format("YYYY-MM-DD-HH");
+    const fileName = _fileName || this.createFileName(_date);
+    return {
+      fileName,
+      date: _date,
+      fileContent: {
+        metadata: this.metadata,
+        logs: []
+      }
+    };
+  }
+  /**
+   * 存储日志到持久化存储
+   */
+  async storeLog(urgent) {
+    var _a;
+    if (this.logBuffer.length === 0 || !this.db) {
+      return;
+    }
+    try {
+      const fileName = await this.createAWSFileName(urgent);
+      console.log("-------- 存储日志到AWS 开始", fileName);
+      const buffer = (_a = this.logBuffer) == null ? void 0 : _a.map((item) => {
+        return {
+          ...item || {},
+          metadata: JSON.parse(item.metadata || "{}")
+        };
+      });
+      const bufferIds = buffer.map((item) => item.logId);
+      const logs = JSON.stringify(buffer, null, 2);
+      await this.app.aws.upload({ Bucket: "", Key: fileName, Body: logs });
+      this.addLog({
+        type: "info",
+        title: "存储日志到AWS 成功",
+        metadata: {
+          fileName,
+          "本地上传的ids": bufferIds,
+          "实例下的ids": this.logBuffer.map((item) => item.logId)
+        }
+      });
+      console.log("-------- 存储日志到AWS 成功");
+      this.logBuffer = this.logBuffer.filter((item) => !bufferIds.includes(item.logId));
+    } catch (error) {
+      console.error("存储日志上传AWS失败:", error);
+      this.addLog({
+        type: "info",
+        title: "存储日志到AWS失败",
+        metadata: {
+          error: {
+            name: error == null ? void 0 : error.name,
+            message: error == null ? void 0 : error.message,
+            stack: error == null ? void 0 : error.stack
+          }
+        }
+      });
+      try {
+        await this.storeLogToIndexDB();
+      } catch (indexDBError) {
+        this.sendFeishuNotification({
+          type: "error",
+          title: "将日志存储到IndexDB失败",
+          metadata: {
+            indexDBError: {
+              name: indexDBError == null ? void 0 : indexDBError.name,
+              message: indexDBError == null ? void 0 : indexDBError.message,
+              stack: indexDBError == null ? void 0 : indexDBError.stack
+            }
+          }
+        });
+        console.error("存储日志到IndexDB也失败:", indexDBError);
+      }
+    }
+  }
+  async uploadIndexDBLog() {
+    var _a, _b;
+    try {
+      this.addLog({
+        type: "info",
+        title: "准备将IndexDB中的日志上传到AWS"
+      });
+      if (!this.db) {
+        return;
+      }
+      let logFile = await ((_a = this.db) == null ? void 0 : _a.getAll("logs"));
+      if (!logFile || (logFile == null ? void 0 : logFile.length) === 0) {
+        return;
+      }
+      const awsFileName = await this.createAWSFileName(true);
+      const logs = JSON.stringify(logFile, null, 2);
+      await this.app.aws.upload({ Bucket: "", Key: awsFileName, Body: logs });
+      console.log("-------- 存储日志到AWS 成功");
+      await ((_b = this.db) == null ? void 0 : _b.clear("logs"));
+      console.log("-------- 清空IndexDB日志成功");
+    } catch (error) {
+      console.log("-------- 存储日志到IndexDB 失败", error);
+      this.addLog({
+        type: "info",
+        title: "存储IndexDB日志到AWS失败",
+        metadata: {
+          error: {
+            name: error == null ? void 0 : error.name,
+            message: error == null ? void 0 : error.message,
+            stack: error == null ? void 0 : error.stack
+          }
+        }
+      });
+      throw error;
+    }
+  }
+  async storeLogToIndexDB() {
+    var _a, _b, _c;
+    try {
+      const fileName = this.createFileName();
+      console.log("storeLog", fileName);
+      const buffer = this.logBuffer || [];
+      let logFile = await ((_a = this.db) == null ? void 0 : _a.get("logs", fileName));
+      if (!logFile) {
+        logFile = this.createFile(fileName);
+        await ((_b = this.db) == null ? void 0 : _b.add("logs", logFile));
+      }
+      logFile.fileContent.logs = [...logFile.fileContent.logs, ...buffer];
+      await ((_c = this.db) == null ? void 0 : _c.update("logs", logFile));
+      console.log("-------- 存储日志到IndexDB", { fileName, logFile });
+      const bufferIds = buffer.map((item) => item.logId);
+      this.logBuffer = this.logBuffer.filter((item) => !bufferIds.includes(item.logId));
+    } catch (error) {
+      console.log("-------- 存储日志到IndexDB 失败", error);
+      throw error;
+    }
+  }
+  /**
+   * 清理旧日志，只保留最近指定天数的日志
+   */
+  async cleanupOldLogs() {
+    if (!this.db) {
+      return;
+    }
+    try {
+      this.addLog({
+        type: "info",
+        title: "准备清理旧日志，开始获取所有日志文件"
+      });
+      const logFiles = await this.getLogFiles();
+      this.addLog({
+        type: "info",
+        title: "获取旧日志成功",
+        metadata: {
+          logFilesCount: logFiles == null ? void 0 : logFiles.length
+        }
+      });
+      const cutoffDate = (0, import_dayjs.default)().subtract(this.retentionDays, "day").format("YYYY-MM-DD");
+      const filesToDelete = (logFiles || []).filter((file) => file.date < cutoffDate);
+      console.log(`-------- 清理旧日志，保留 ${this.retentionDays} 天内的日志，截止日期: ${cutoffDate}`);
+      for (const file of filesToDelete) {
+        await this.db.delete("logs", file.fileName);
+        console.log(`-------- 删除旧日志文件: ${file.fileName}, 日期: ${file.date}`);
+      }
+      if (filesToDelete.length > 0) {
+        console.log(`-------- 共清理 ${filesToDelete.length} 个旧日志文件`);
+      }
+      this.addLog({
+        type: "info",
+        title: "清理旧日志成功",
+        metadata: {
+          filesToDelete
+        }
+      });
+      this.uploadIndexDBLog();
+    } catch (error) {
+      this.addLog({
+        type: "error",
+        title: "清理旧日志失败！",
+        metadata: {
+          error: {
+            name: error == null ? void 0 : error.name,
+            message: error == null ? void 0 : error.message,
+            stack: error == null ? void 0 : error.stack
+          }
+        }
+      });
+      console.error("清理旧日志失败:", error);
+    }
+  }
+  /**
+   * 获取日志文件列表
+   * @returns 日志文件列表
+   */
+  async getLogFiles() {
+    if (!this.db) {
+      return [];
+    }
+    try {
+      return await this.db.getAll("logs");
+    } catch (error) {
+      this.addLog({
+        type: "error",
+        title: "获取本地日志文件列表失败"
+      });
+      console.error("获取日志文件列表失败:", error);
+      return [];
+    }
+  }
+  /**
+   * 获取指定日志文件的内容
+   * @param fileName 日志文件名
+   * @returns 日志文件内容
+   */
+  async getLogFile(fileName) {
+    if (!this.db) {
+      return null;
+    }
+    try {
+      return await this.db.get("logs", fileName);
+    } catch (error) {
+      console.error("获取日志文件内容失败:", error);
+      return null;
+    }
+  }
+  /**
+   * 清空指定日志文件
+   * @param fileName 日志文件名，不指定则清空所有日志
+   * @returns 是否成功
+   */
+  async clearLogs(fileName) {
+    if (!this.db) {
+      return false;
+    }
+    try {
+      if (fileName) {
+        await this.db.delete("logs", fileName);
+      } else {
+        await this.db.clear("logs");
+      }
+      return true;
+    } catch (error) {
+      console.error("清空日志失败:", error);
+      return false;
+    }
+  }
+  /**
+   * 设置日志保留天数
+   * @param days 保留天数
+   */
+  setRetentionDays(days) {
+    if (days > 0) {
+      this.retentionDays = days;
+      console.log(`-------- 设置日志保留天数为 ${days} 天`);
+    } else {
+      console.error("日志保留天数必须大于0");
+    }
+  }
+  /**
+   * 手动触发清理旧日志
+   */
+  async manualCleanup() {
+    this.addLog({
+      type: "info",
+      title: "manualCleanup 手动触发清理旧日志"
+    });
+    await this.cleanupOldLogs();
+  }
+  /**
+   * 销毁实例
+   */
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.logBuffer.length > 0) {
+      this.storeLog();
+    }
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+  }
+};
+var logger_default = LoggerManager;

package/lib/menuManager/hooks.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+import { MenuItem } from "./index";
+export declare const isHttp: (url: string) => boolean;
+export interface MenuContextType {
+    selectedKeys: string[];
+    openKeys: string[];
+    setOpenKeys: (keys: string[]) => void;
+    handleClick: (key: string) => void;
+    menuItems: MenuItem[];
+    getShowChildren: (children: MenuItem[]) => MenuItem[];
+    setMenuItems: (items: MenuItem[]) => void;
+}
+export declare const MenuProvider: React.FC<{
+    children: React.ReactNode;
+    menus: MenuItem[];
+}>;
+export declare const useMenu: () => MenuContextType;

package/lib/menuManager/hooks.js

@@ -0,0 +1,135 @@
+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/menuManager/hooks.tsx
+var hooks_exports = {};
+__export(hooks_exports, {
+  MenuProvider: () => MenuProvider,
+  isHttp: () => isHttp,
+  useMenu: () => useMenu
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_react = __toESM(require("react"));
+var import_app = require("../app");
+var isHttp = (url) => {
+  return /^http(s)?:\/\//.test(url);
+};
+function handleRouteParams(targetPath, currentPath) {
+  if (!targetPath.includes(":")) {
+    return targetPath;
+  }
+  const currentParams = {};
+  const pathSegments = currentPath.split("/");
+  const targetSegments = targetPath.split("/");
+  targetSegments.forEach((segment, index) => {
+    if (segment.startsWith(":")) {
+      const paramName = segment.slice(1);
+      currentParams[paramName] = pathSegments[index] || "";
+    }
+  });
+  return targetPath.replace(/:(\w+)/g, (match, key) => {
+    var _a;
+    return ((_a = currentParams[key]) == null ? void 0 : _a.toString()) || match;
+  });
+}
+var MenuContext = (0, import_react.createContext)(void 0);
+var MenuProvider = ({ children, menus }) => {
+  const { app } = (0, import_app.useApp)();
+  const menuManager = app.menuManager;
+  const location = app.history.useLocation();
+  const [selectedKeys, setSelectedKeys] = (0, import_react.useState)([]);
+  const [openKeys, setOpenKeys] = (0, import_react.useState)([]);
+  const [menuItems, setMenuItems] = (0, import_react.useState)(menus);
+  (0, import_react.useEffect)(() => {
+    app.menuManager.set(menuItems);
+  }, [menuItems]);
+  (0, import_react.useEffect)(() => {
+    const pathname = location.pathname;
+    if (!pathname) {
+      return;
+    }
+    const currentMenuItem = menuManager.findMenuItemByPath(menuItems, pathname);
+    if (currentMenuItem) {
+      setSelectedKeys([currentMenuItem.key]);
+      const parent = menuManager.findParent(menuItems, currentMenuItem.key);
+      if (parent) {
+        const _children = menuManager.getShowChildren(parent.children || []);
+        if (_children == null ? void 0 : _children.length) {
+          setOpenKeys((prevKeys) => [.../* @__PURE__ */ new Set([...prevKeys, parent.key])]);
+        } else {
+          setSelectedKeys([parent.key]);
+        }
+      }
+    }
+  }, [location, menuItems]);
+  const handleClick = (key) => {
+    try {
+      if (!key) {
+        return;
+      }
+      if (isHttp(key)) {
+        window.open(key, "_blank");
+        return;
+      }
+      const newPath = handleRouteParams(key, location.pathname);
+      if (newPath !== location.pathname) {
+        app.history.push(newPath);
+      }
+    } catch (error) {
+      console.error("Menu navigation error:", error);
+    }
+  };
+  return /* @__PURE__ */ import_react.default.createElement(
+    MenuContext.Provider,
+    {
+      value: {
+        selectedKeys,
+        openKeys,
+        setOpenKeys,
+        handleClick,
+        menuItems,
+        getShowChildren: menuManager.getShowChildren,
+        setMenuItems
+      }
+    },
+    children
+  );
+};
+var useMenu = () => {
+  const context = (0, import_react.useContext)(MenuContext);
+  if (context === void 0) {
+    throw new Error("useMenu must be used within a MenuProvider");
+  }
+  return context;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MenuProvider,
+  isHttp,
+  useMenu
+});

package/lib/menuManager/index.d.ts

@@ -0,0 +1,28 @@
+import React from 'react';
+import App from '../app';
+export interface MenuItem {
+    key: string;
+    label: string;
+    path: string;
+    children?: MenuItem[];
+    icon?: string | React.ReactNode;
+    hide?: boolean;
+}
+export declare class MenuManager {
+    private menuItems;
+    private menuMaps;
+    private app;
+    useMenu: () => import("./hooks").MenuContextType;
+    MenuProvider: React.FC<{
+        children: React.ReactNode;
+        menus: MenuItem[];
+    }>;
+    constructor(items: MenuItem[], app: App);
+    set(items: MenuItem[]): void;
+    getMenus(): MenuItem[];
+    getMenuMaps(): void;
+    findMenuItemByPath(items: MenuItem[], path: string): MenuItem | null;
+    findParent(items: MenuItem[], key: string, parent?: MenuItem | null): MenuItem | null;
+    getShowChildren(items: MenuItem[]): MenuItem[];
+    findMenuItemByKey(items: MenuItem[], key: string): MenuItem | null;
+}