@pisell/core 1.0.47 → 1.0.49

package/es/app/app.d.ts

@@ -0,0 +1,99 @@
+import { RouterManager } from '../routes';
+import { ApplicationManager } from '../applicationManager';
+import { History, HistoryOptions } from '../history';
+import { Data } from '../data';
+import { Locales, LocalesOptions } from '../locales';
+import { Storage, StorageOptions } from '../storage';
+import { MenuManager } from '../menuManager';
+import LoggerManager, { LoggerOptions } from '../logger';
+import { TasksManager } from '../tasks';
+import IndexDBManager, { DBOptions } from '../indexDB';
+import CMD, { CMDOptions } from "../cmd";
+import AWS, { AWSOptions } from "../aws";
+declare global {
+    interface Window {
+        app: App;
+    }
+}
+export interface Bootstrap {
+    hooks: {
+        [key: string]: () => Promise<void>;
+    };
+}
+export interface AppOptions {
+    logger?: LoggerOptions;
+    db?: DBOptions;
+    constants?: any;
+    history?: HistoryOptions;
+    storage?: StorageOptions;
+    locales?: LocalesOptions;
+    cmd?: CMDOptions;
+    aws?: AWSOptions;
+    getPisellos?: () => any;
+}
+declare class App {
+    private static instance;
+    private plugins;
+    globalData: any;
+    router: RouterManager;
+    applicationManager: ApplicationManager;
+    history: History;
+    data: Data;
+    hooks: import("../hooks").HooksExport;
+    locales: Locales;
+    models: {
+        getStore: () => import("../models").Store;
+        StoreProvider: typeof import("react-redux").Provider;
+        setConfig: (models: any[]) => void;
+    };
+    request: {
+        get: (url: string, data: any, config: import("@").RequestSetting | undefined) => Promise<any>;
+        post: (url: string, data: any, config: import("@").RequestSetting | undefined) => Promise<any>;
+        put: (url: string, data: any, config: import("@").RequestSetting | undefined) => Promise<any>;
+        remove: (url: string, data: any, config: import("@").RequestSetting | undefined) => Promise<any>;
+        custom: (url: string, config: import("@").RequestSetting | undefined) => any;
+        setConfig: (newConfig: Partial<import("@").RequestConfig>) => void;
+        getConfig: () => import("@").RequestConfig;
+    };
+    storage: Storage;
+    menuManager: MenuManager;
+    cookie: {
+        setCookie: (name: string, value: string, domain?: string | undefined) => void;
+        getCookie: (name: string) => string | null;
+        deleteCookie: (name: string, domain?: string | undefined) => void;
+        checkCookie: (name: string) => boolean;
+        updateCookie: (name: string, value: string, domain?: string | undefined) => void;
+    };
+    website: {
+        setTitle: (title: string) => void;
+        setIcon: (paramsIcon: string) => void;
+        setAppleWebAppTitle: (title: string) => void;
+    };
+    logger: LoggerManager;
+    pubsub: import("../pubsub").PubSub;
+    cmd: CMD;
+    aws: AWS;
+    tasksManager: TasksManager;
+    getPisellos: any;
+    bootstrap?: Bootstrap;
+    dbManager: IndexDBManager | null;
+    constants: {
+        channel: string;
+        [key: string]: string;
+    };
+    private constructor();
+    static getInstance(options?: AppOptions): App;
+    setGlobalData(globalData: any): void;
+    usePlugin(name: string, plugin: any): void;
+    usePlugins(plugins: {
+        name: string;
+        plugin: any;
+    }[]): void;
+    getPlugin(name: string): any;
+    getGlobalData(): any;
+    install(): void;
+    unInstall(): void;
+    setBootstrap(bootstrap: Bootstrap): void;
+    getBootstrap(): Bootstrap | undefined;
+}
+export default App;

package/es/app/index.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import App, { AppOptions } from "./app";
-declare type AppContextType = {
+type AppContextType = {
     globalData: any;
     setGlobalData: React.Dispatch<React.SetStateAction<any>>;
     app: App;

package/es/applicationManager/application.d.ts

@@ -0,0 +1,197 @@
+import App from '../app';
+import { LoadLibraryByUrlParams } from '../locales/type';
+import { MenuItem } from '../menuManager/index';
+/**
+ * 应用接口类型定义
+ * @description 描述应用中单个页面、组件或功能的接口结构
+ */
+export type ApplicationInterface = {
+    page_type: 'low_code' | 'code';
+    page_id: number | string;
+    page_code: string;
+    page_version?: string;
+    page_name: string;
+    router: string;
+    category: 'page' | 'component' | 'function';
+    Component?: any;
+    children?: any;
+    layout?: string;
+    originalUrl?: string;
+    routeConfig?: {
+        cache?: boolean;
+        preload?: boolean;
+        prerender?: boolean;
+        priority?: 'high' | 'normal' | 'low';
+    };
+    autoRender?: boolean;
+};
+/**
+ * 应用数据类型定义
+ * @description 描述完整应用的数据结构，包含应用的基本信息、接口、功能等
+ */
+export type ApplicationData = {
+    /** 应用唯一标识 */
+    app_id: number;
+    /** 应用名称 */
+    app_name: string;
+    /** 应用类型：系统应用或自定义应用 */
+    app_type: 'system' | 'custom';
+    /** 应用包含的接口列表 */
+    interfaces: ApplicationInterface[];
+    /** 应用包含的功能列表，可选 */
+    functions?: any[];
+    /** 应用的菜单配置 */
+    menu?: {
+        [key: string]: MenuItem[];
+    };
+    /** 多语言配置，可选 */
+    locales?: LoadLibraryByUrlParams;
+    /** 其他扩展属性 */
+    [key: string]: any;
+};
+/**
+ * 应用管理类
+ * @description 负责管理单个应用的生命周期，包括接口、组件、功能的初始化和管理
+ * @class Application
+ * @author zhiwei.Wang
+ */
+export declare class Application {
+    /** 应用配置数据 */
+    options: ApplicationData;
+    /** 应用名称 */
+    name: ApplicationData['app_name'];
+    /** 应用内的页面接口映射表，以页面名称为键 */
+    interfaces: Map<ApplicationInterface['page_name'], ApplicationInterface>;
+    /** 应用内的组件映射表，以组件编码为键 */
+    components: Map<string, any>;
+    /** 应用内的功能函数映射表，比如跳转登录页面的方法等 */
+    functions: Map<string, any>;
+    /** 应用实例引用 */
+    app: App;
+    /**
+     * 构造函数
+     * @description 初始化应用实例，设置基本属性并初始化接口和功能
+     * @param {ApplicationData} options - 应用配置数据
+     * @param {App} app - 应用实例引用
+     */
+    constructor(options: ApplicationData, app: App);
+    /**
+     * 应用添加后的内部处理方法
+     * @description 在应用被添加到应用管理器后执行的内部逻辑，包括加载多语言配置和执行用户自定义的afterAdd方法
+     * @param {Application} application - 被添加的应用实例
+     * @returns {Promise<void>}
+     * @private
+     */
+    _afterAdd(application: Application): Promise<void>;
+    /**
+     * 应用加载前的内部处理方法
+     * @description 在应用开始加载前执行的内部逻辑，调用用户自定义的beforeLoad方法
+     * @returns {Promise<void>}
+     * @private
+     */
+    _beforeLoad(): Promise<void>;
+    /**
+     * 应用加载的内部处理方法
+     * @description 执行应用的实际加载逻辑，将应用中的所有接口注册为路由
+     * @returns {Promise<void>}
+     * @private
+     */
+    _load(): Promise<void>;
+    /**
+     * 初始化应用接口
+     * @description 遍历应用配置中的接口列表，根据类别将它们分别设置到对应的映射表中
+     * @param {ApplicationData['interfaces']} interfaces - 接口配置数组
+     * @returns {void}
+     */
+    initInterfaces(interfaces: ApplicationData['interfaces']): void;
+    /**
+     * 初始化应用功能函数
+     * @description 遍历应用配置中的功能列表，将它们设置到功能映射表中
+     * @param {ApplicationData['functions']} functions - 功能配置数组，可选
+     * @returns {void}
+     */
+    initFunctions(functions: ApplicationData['functions']): void;
+    /**
+     * 加载接口组件
+     * @description 根据接口类型加载对应的组件，支持低代码和普通代码两种类型
+     * @param {ApplicationInterface} interfaceItem - 接口配置项
+     * @returns {Promise<ApplicationInterface>} 加载后的接口配置
+     */
+    loadInterface(interfaceItem: ApplicationInterface): Promise<ApplicationInterface>;
+    /**
+     * 设置页面
+     * @description 将页面接口添加到接口映射表中
+     * @param {string} code - 页面编码
+     * @param {ApplicationInterface} interfaceItem - 接口配置项
+     * @returns {void}
+     */
+    setInterface(code: string, interfaceItem: ApplicationInterface): void;
+    /**
+     * 设置组件
+     * @description 将组件添加到组件映射表中
+     * @param {string} code - 组件编码
+     * @param {ApplicationInterface} component - 组件配置项
+     * @returns {void}
+     */
+    setComponent(code: string, component: ApplicationInterface): void;
+    /**
+     * 设置功能函数
+     * @description 将功能函数添加到功能映射表中
+     * @param {string} code - 功能编码
+     * @param {ApplicationInterface} functionItem - 功能配置项
+     * @returns {void}
+     */
+    setFunction(code: string, functionItem: ApplicationInterface): void;
+    /**
+     * 获取页面
+     * @description 根据编码从接口映射表中获取页面接口
+     * @param {string} code - 页面编码
+     * @returns {ApplicationInterface | undefined} 接口配置项或undefined
+     */
+    getInterface(code: string): ApplicationInterface | undefined;
+    /**
+     * 获取组件
+     * @description 根据编码从组件映射表中获取组件
+     * @param {string} code - 组件编码
+     * @returns {any | undefined} 组件或undefined
+     */
+    getComponent(code: string): any;
+    /**
+     * 获取功能函数
+     * @description 根据编码从功能映射表中获取功能函数
+     * @param {string} code - 功能编码
+     * @returns {any | undefined} 功能函数或undefined
+     */
+    getFunction(code: string): any;
+    /**
+     * 执行功能函数
+     * @description 根据编码执行对应的功能函数，自动注入应用实例并合并参数
+     * @param {string} code - 功能编码
+     * @param {any} params - 传递给功能函数的参数对象，可选
+     * @param {...any} args - 传递给功能函数的其他参数
+     * @returns {any} 功能函数的执行结果
+     */
+    runFunction(code: string, params?: any, ...args: any): any;
+    /**
+     * 应用添加后触发的钩子函数
+     * @description 在应用被添加到应用管理器后触发，可被子类覆盖以实现自定义逻辑
+     * @param {Application} application - 被添加的应用实例
+     * @returns {Promise<void>}
+     * @author zhiwei.Wang
+     */
+    afterAdd(application: Application): Promise<void>;
+    /**
+     * 应用加载前触发的钩子函数
+     * @description 在应用开始加载前触发，可被子类覆盖以实现自定义预处理逻辑
+     * @returns {Promise<void>}
+     * @author zhiwei.Wang
+     */
+    beforeLoad(application: Application): Promise<void>;
+    /**
+     * 应用加载完成后触发的钩子函数
+     * @description 在应用完成加载后触发，可被子类覆盖以实现自定义后处理逻辑
+     * @returns {Promise<void>}
+     * @author zhiwei.Wang
+     */
+    load(application: Application): Promise<void>;
+}

package/es/applicationManager/index.d.ts

@@ -0,0 +1,19 @@
+import APP from '../app';
+import { Application, ApplicationData } from './application';
+export * from "./application";
+export declare class ApplicationManager {
+    applicationList: Application[];
+    protected app: APP;
+    applications: Map<string, Application>;
+    constructor(applicationList: Application[], app: APP);
+    init(applicationList: Application[] | ApplicationData[]): Promise<unknown>;
+    add(application: Application): Promise<void>;
+    get(appName: Application['name']): Application | undefined;
+    remove(appName: Application['name']): void;
+    load(): Promise<void>;
+    /**
+     * 循环所有的应用, 找出所有的components进行渲染
+     * @returns
+     */
+    getAllComponents(): any[];
+}

package/es/cmd/const.d.ts

@@ -1,9 +1,9 @@
 export declare enum CMDCoreEnum {
-    CMD_CONNECT,
-    CMD_DISCONNECT,
-    CMD_RECONNECT,
-    CMD_MESSAGE,
-    CMD_ERROR
+    CMD_CONNECT = "cmd.connect",
+    CMD_DISCONNECT = "cmd.disconnect",
+    CMD_RECONNECT = "cmd.reconnect",
+    CMD_MESSAGE = "cmd.message",
+    CMD_ERROR = "cmd.error"
 }
 declare const _default: {
     CMDCoreEnum: typeof CMDCoreEnum;

package/es/hooks/useStore/index.d.ts

@@ -1,6 +1,6 @@
 import { ModelsState } from "../../models";
 declare const useStore: <T extends "global", D extends keyof ModelsState[T]>(props: {
     models: T;
-    key?: D | undefined;
+    key?: D;
 }) => D extends undefined ? ModelsState[T] : ModelsState[T][D];
 export default useStore;

package/es/index.d.ts

@@ -0,0 +1,7 @@
+export { default as request } from './request';
+export { default as hooks } from './hooks';
+export { default as models } from './models';
+export { default as pubsub } from './pubsub';
+export { default as socket } from './socket';
+export * from './applicationManager';
+export * from './app';

package/es/locales/type.d.ts

@@ -1,5 +1,5 @@
-export declare type Locale = 'original' | 'en' | 'zh-CN' | 'zh-HK' | string;
-export declare type MultiLanguage = {
+export type Locale = 'original' | 'en' | 'zh-CN' | 'zh-HK' | string;
+export type MultiLanguage = {
     [key in Locale]: string;
 };
 export interface LibraryItem {
@@ -16,4 +16,4 @@ export interface LocaleConfig {
         [key in Locale]: LibraryItem;
     };
 }
-export declare type LoadLibraryByUrlParams = (string | Promise<LibraryItem> | (() => Promise<LibraryItem>) | LibraryItem)[];
+export type LoadLibraryByUrlParams = (string | Promise<LibraryItem> | (() => Promise<LibraryItem>) | LibraryItem)[];

package/es/logger/index.d.ts

@@ -0,0 +1,135 @@
+import App from "../app";
+export type LogConsoleType = "info" | "warning" | "error" | "debug";
+/**
+ * 日志项接口
+ */
+interface LogItem {
+    logId?: string | number;
+    type: LogConsoleType;
+    title: string;
+    date?: string;
+    metadata?: any;
+    feishu?: 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;
+    private status;
+    /**
+     * 构造函数
+     * @param prefix 日志前缀
+     * @param checkInterval 检查间隔时间，默认5分钟
+     */
+    constructor(app: App, options?: LoggerOptions);
+    init(): Promise<void>;
+    /**
+     * 初始化 IndexDB
+     */
+    private initDB;
+    /**
+     * 设置元数据
+     * @param metadata 元数据
+     */
+    setMetadata(metadata: any): void;
+    setMetadataFunction(metadataFunction: () => any): void;
+    /**
+     * 初始化定时器
+     */
+    initTimer(): void;
+    private setStatus;
+    stop(): void;
+    /**
+     * 添加日志
+     * @param log 日志项
+     */
+    addLog(log: LogItem): void;
+    /**
+     * 发送飞书通知
+     * @param log 日志项
+     */
+    private sendFeishuNotification;
+    /**
+     * 创建日志文件名
+     * @returns 日志文件名
+     */
+    private createFileName;
+    /**
+     * 创建AWS日志文件名
+     * @param isManual 紧急上传
+     * @returns 日志文件名
+     */
+    createAWSFileName(urgent?: boolean): Promise<any>;
+    /**
+     * 创建日志文件
+     * @param _fileName 文件名
+     * @returns 日志文件对象
+     */
+    private createFile;
+    /**
+     * 存储日志到持久化存储
+     */
+    storeLog(urgent?: boolean): Promise<void>;
+    uploadIndexDBLog(): Promise<void>;
+    private storeLogToIndexDB;
+    /**
+     * 清理旧日志，只保留最近指定天数的日志
+     */
+    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/es/logger/index.js

@@ -340,37 +340,54 @@ var LoggerManager = /*#__PURE__*/function () {
                 Body: logs
               });
             case 13:
+              this.addLog({
+                type: "info",
+                title: "存储日志到AWS 成功",
+                metadata: {
+                  fileName: fileName,
+                  '本地上传的ids': bufferIds,
+                  '实例下的ids': this.logBuffer.map(function (item) {
+                    return item.logId;
+                  })
+                }
+              });
               console.log("-------- 存储日志到AWS 成功");
               // 上传成功后需要清空缓冲区，避免重复上传
               this.logBuffer = this.logBuffer.filter(function (item) {
                 return !bufferIds.includes(item.logId);
               });
-              _context4.next = 29;
+              _context4.next = 31;
               break;
-            case 17:
-              _context4.prev = 17;
+            case 18:
+              _context4.prev = 18;
               _context4.t0 = _context4["catch"](3);
               console.error("存储日志上传AWS失败:", _context4.t0);
+              this.addLog({
+                type: "info",
+                title: "存储日志到AWS失败",
+                metadata: {
+                  error: {
+                    name: _context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.name,
+                    message: _context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.message,
+                    stack: _context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.stack
+                  }
+                }
+              });
 
               // 将日志存储到IndexDB
-              _context4.prev = 20;
-              _context4.next = 23;
+              _context4.prev = 22;
+              _context4.next = 25;
               return this.storeLogToIndexDB();
-            case 23:
-              _context4.next = 29;
-              break;
             case 25:
-              _context4.prev = 25;
-              _context4.t1 = _context4["catch"](20);
+              _context4.next = 31;
+              break;
+            case 27:
+              _context4.prev = 27;
+              _context4.t1 = _context4["catch"](22);
               this.sendFeishuNotification({
                 type: "error",
-                title: "存储日志到AWS失败",
+                title: "将日志存储到IndexDB失败",
                 metadata: {
-                  error: {
-                    name: _context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.name,
-                    message: _context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.message,
-                    stack: _context4.t0 === null || _context4.t0 === void 0 ? void 0 : _context4.t0.stack
-                  },
                   indexDBError: {
                     name: _context4.t1 === null || _context4.t1 === void 0 ? void 0 : _context4.t1.name,
                     message: _context4.t1 === null || _context4.t1 === void 0 ? void 0 : _context4.t1.message,
@@ -379,11 +396,11 @@ var LoggerManager = /*#__PURE__*/function () {
                 }
               });
               console.error("存储日志到IndexDB也失败:", _context4.t1);
-            case 29:
+            case 31:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[3, 17], [20, 25]]);
+        }, _callee4, this, [[3, 18], [22, 27]]);
       }));
       function storeLog(_x2) {
         return _storeLog.apply(this, arguments);
@@ -432,26 +449,27 @@ var LoggerManager = /*#__PURE__*/function () {
               return (_this$db2 = this.db) === null || _this$db2 === void 0 ? void 0 : _this$db2.clear("logs");
             case 17:
               console.log("-------- 清空IndexDB日志成功");
-              _context5.next = 25;
+              _context5.next = 24;
               break;
             case 20:
               _context5.prev = 20;
               _context5.t0 = _context5["catch"](0);
               console.log("-------- 存储日志到IndexDB 失败", _context5.t0);
-              this.sendFeishuNotification({
-                type: "error",
-                title: "存储IndexDB日志到AWS失败",
-                metadata: {
-                  error: {
-                    name: _context5.t0 === null || _context5.t0 === void 0 ? void 0 : _context5.t0.name,
-                    message: _context5.t0 === null || _context5.t0 === void 0 ? void 0 : _context5.t0.message,
-                    stack: _context5.t0 === null || _context5.t0 === void 0 ? void 0 : _context5.t0.stack
-                  }
-                }
-              });
+
+              // this.sendFeishuNotification({
+              //   type: "error",
+              //   title: "存储IndexDB日志到AWS失败",
+              //   metadata: {
+              //     error: {
+              //       name: error?.name,
+              //       message: error?.message,
+              //       stack: error?.stack,
+              //     }
+              //   },
+              // });
               // 重新抛出错误，让外层 catch 能够捕获
               throw _context5.t0;
-            case 25:
+            case 24:
             case "end":
               return _context5.stop();
           }

package/es/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;
+}