@pisell/core 1.0.0 → 1.0.2

package/lib/logger/feishu.js

@@ -0,0 +1,52 @@
+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);
+
+// src/logger/feishu.ts
+var feishu_exports = {};
+__export(feishu_exports, {
+  sendWarningLog: () => sendWarningLog
+});
+module.exports = __toCommonJS(feishu_exports);
+var createFeishuMessageContent = (contentArr) => {
+  return JSON.stringify(
+    contentArr.map((item) => {
+      return [
+        { tag: "text", text: `${item.key}: ` },
+        { tag: "text", text: `${item.value}` }
+      ];
+    })
+  );
+};
+var sendWarningLog = async ({ title, content, webhook }) => {
+  const contentStr = createFeishuMessageContent(content);
+  const response = await fetch(webhook, {
+    headers: {
+      "Content-Type": "application/json"
+    },
+    method: "POST",
+    body: JSON.stringify({
+      msg_type: "post",
+      content: `{"post":{"zh_cn":{"title":"${title}","content":${contentStr}}}}`
+    })
+  });
+  return await response.json();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  sendWarningLog
+});

package/lib/logger/index.d.ts

@@ -0,0 +1,122 @@
+import App from "../app";
+export type LogConsoleType = "info" | "warning" | "error" | "debug";
+/**
+ * 日志项接口
+ */
+interface LogItem {
+    type: LogConsoleType;
+    title: string;
+    date?: string;
+    metadata?: any;
+}
+interface LogFile {
+    fileName: string;
+    date: string;
+    fileContent: LogFileContent;
+}
+interface LogFileContent {
+    metadata: any;
+    logs: LogItem[];
+}
+export interface LoggerOptions {
+    prefix?: string;
+    checkInterval?: number;
+    feishuConfig?: any;
+    retentionDays?: number;
+}
+/**
+ * 日志管理器类
+ */
+declare class LoggerManager {
+    private logBuffer;
+    private timer;
+    private checkInterval;
+    private prefix;
+    private metadata;
+    private db;
+    private app;
+    private feishuConfig;
+    private retentionDays;
+    private metadataFunction;
+    /**
+     * 构造函数
+     * @param prefix 日志前缀
+     * @param checkInterval 检查间隔时间，默认5分钟
+     */
+    constructor(app: App, options?: LoggerOptions);
+    init(): void;
+    /**
+     * 初始化 IndexDB
+     */
+    private initDB;
+    /**
+     * 设置元数据
+     * @param metadata 元数据
+     */
+    setMetadata(metadata: any): void;
+    setMetadataFunction(metadataFunction: () => any): void;
+    /**
+     * 初始化定时器
+     */
+    initTimer(): void;
+    /**
+     * 添加日志
+     * @param log 日志项
+     */
+    addLog(log: LogItem): void;
+    /**
+     * 发送飞书通知
+     * @param log 日志项
+     */
+    private sendFeishuNotification;
+    /**
+     * 创建日志文件名
+     * @returns 日志文件名
+     */
+    private createFileName;
+    /**
+     * 创建日志文件
+     * @param _fileName 文件名
+     * @returns 日志文件对象
+     */
+    private createFile;
+    /**
+     * 存储日志到持久化存储
+     */
+    private storeLog;
+    /**
+     * 清理旧日志，只保留最近指定天数的日志
+     */
+    private cleanupOldLogs;
+    /**
+     * 获取日志文件列表
+     * @returns 日志文件列表
+     */
+    getLogFiles(): Promise<LogFile[]>;
+    /**
+     * 获取指定日志文件的内容
+     * @param fileName 日志文件名
+     * @returns 日志文件内容
+     */
+    getLogFile(fileName: string): Promise<LogFile | null>;
+    /**
+     * 清空指定日志文件
+     * @param fileName 日志文件名，不指定则清空所有日志
+     * @returns 是否成功
+     */
+    clearLogs(fileName?: string): Promise<boolean>;
+    /**
+     * 设置日志保留天数
+     * @param days 保留天数
+     */
+    setRetentionDays(days: number): void;
+    /**
+     * 手动触发清理旧日志
+     */
+    manualCleanup(): Promise<void>;
+    /**
+     * 销毁实例
+     */
+    destroy(): void;
+}
+export default LoggerManager;

package/lib/logger/index.js

@@ -0,0 +1,288 @@
+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 {
+  /**
+   * 构造函数
+   * @param prefix 日志前缀
+   * @param checkInterval 检查间隔时间，默认5分钟
+   */
+  constructor(app, options) {
+    // 私有属性
+    this.logBuffer = [];
+    // 日志缓冲区
+    this.timer = null;
+    // 检查间隔时间（毫秒）
+    this.prefix = "app";
+    this.db = null;
+    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();
+  }
+  init() {
+    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);
+  }
+  /**
+   * 添加日志
+   * @param log 日志项
+   */
+  addLog(log) {
+    const logItem = {
+      ...log,
+      date: log.date || (0, import_dayjs.default)().format("YYYY-MM-DD HH:mm:ss"),
+      metadata: JSON.stringify(log.metadata || "{}")
+    };
+    console.log("---- 行为日志", logItem);
+    if (log.type === "error") {
+      this.sendFeishuNotification(logItem);
+    }
+    this.logBuffer.push(logItem);
+  }
+  /**
+   * 发送飞书通知
+   * @param log 日志项
+   */
+  sendFeishuNotification(log) {
+    var _a;
+    if (this.feishuConfig) {
+      const _metadata = ((_a = this.metadataFunction) == null ? void 0 : _a.call(this)) || {};
+      (0, import_feishu.sendWarningLog)({
+        title: log.title,
+        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 }) },
+          { key: "日志内容", value: JSON.stringify(log.metadata) }
+        ],
+        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;
+  }
+  /**
+   * 创建日志文件
+   * @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() {
+    if (this.logBuffer.length === 0 || !this.db) {
+      return;
+    }
+    const fileName = this.createFileName();
+    try {
+      let logFile = await this.db.get("logs", fileName);
+      if (!logFile) {
+        logFile = this.createFile(fileName);
+        await this.db.add("logs", logFile);
+      }
+      logFile.fileContent.logs = [...logFile.fileContent.logs, ...this.logBuffer];
+      await this.db.update("logs", logFile);
+      console.log("-------- 存储日志", {
+        fileName,
+        logFile
+      });
+    } catch (error) {
+      console.error("存储日志到IndexDB失败:", error);
+    }
+    this.logBuffer = [];
+  }
+  /**
+   * 清理旧日志，只保留最近指定天数的日志
+   */
+  async cleanupOldLogs() {
+    if (!this.db) {
+      return;
+    }
+    try {
+      const logFiles = await this.getLogFiles();
+      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} 个旧日志文件`);
+      }
+    } catch (error) {
+      console.error("清理旧日志失败:", error);
+    }
+  }
+  /**
+   * 获取日志文件列表
+   * @returns 日志文件列表
+   */
+  async getLogFiles() {
+    if (!this.db) {
+      return [];
+    }
+    try {
+      return await this.db.getAll("logs");
+    } catch (error) {
+      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() {
+    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;
+}