@pisell/core 1.0.41 → 1.0.43

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("../request").RequestSetting | undefined) => Promise<any>;
+        post: (url: string, data: any, config: import("../request").RequestSetting | undefined) => Promise<any>;
+        put: (url: string, data: any, config: import("../request").RequestSetting | undefined) => Promise<any>;
+        remove: (url: string, data: any, config: import("../request").RequestSetting | undefined) => Promise<any>;
+        custom: (url: string, config: import("../request").RequestSetting | undefined) => any;
+        setConfig: (newConfig: Partial<import("../request").RequestConfig>) => void;
+        getConfig: () => import("../request").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/applicationManager/application.d.ts

@@ -0,0 +1,197 @@
+import App from '../app';
+import { LoadLibraryByUrlParams } from '../locales/type';
+import { MenuItem } from '../menuManager/index';
+/**
+ * 应用接口类型定义
+ * @description 描述应用中单个页面、组件或功能的接口结构
+ */
+export declare 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 declare 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/history/index.d.ts

@@ -0,0 +1,23 @@
+import { LocationDescriptor } from "history";
+import type { History as HistoryType } from "history";
+import { useHistory, useLocation, useParams } from "react-router-dom";
+import App from "../app";
+export interface HistoryOptions {
+    basename?: string;
+    interceptor?: (path: LocationDescriptor<unknown>, state: any, next: () => void) => void;
+}
+export declare class History {
+    instance: HistoryType<unknown>;
+    useHistory: typeof useHistory;
+    useLocation: typeof useLocation;
+    useParams: typeof useParams;
+    app: App;
+    interceptor?: (path: LocationDescriptor<unknown>, state: unknown, next: () => void) => void;
+    constructor(app: App, options?: HistoryOptions);
+    push: HistoryType["push"];
+    replace: HistoryType["replace"];
+    reload: () => void;
+    reloadTo: (path: string) => void;
+    externalPage: (path: string) => void;
+    goLogin: () => any;
+}

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/indexDB/index.js

@@ -60,13 +60,13 @@ var IndexDBManager = /*#__PURE__*/function () {
     // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
     _defineProperty(this, "memoryStorage", new Map());
     // 操作超时时间（毫秒）
-    _defineProperty(this, "timeout", 5000);
+    _defineProperty(this, "timeout", 10000);
     this.app = app;
     this.dbName = options.dbName;
     this.version = options.version;
     this.stores = options.stores;
     this.useIndexDB = IndexDBManager.isSupported();
-    this.timeout = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : 5000; // 默认 5 秒超时
+    this.timeout = (_options$timeout = options.timeout) !== null && _options$timeout !== void 0 ? _options$timeout : 10000; // 默认 10 秒超时
 
     // 初始化内存存储的各个 store
     if (!this.useIndexDB) {
@@ -279,14 +279,11 @@ var IndexDBManager = /*#__PURE__*/function () {
             case 8:
               uuid = "[ IndexDB ] ADD: - ".concat(storeName, " - ").concat(dayjs().valueOf());
               if (log) {
-                this.app.logger.addLog({
-                  type: 'info',
-                  title: uuid,
-                  metadata: {
-                    msg: '添加数据前',
-                    data: data
-                  }
-                });
+                // this.app.logger.addLog({
+                //   type: 'info',
+                //   title: uuid,
+                //   metadata: { msg: '添加数据前', data: data }
+                // })
               }
               return _context4.abrupt("return", this.withTimeout(_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
                 return _regeneratorRuntime().wrap(function _callee3$(_context3) {
@@ -313,21 +310,17 @@ var IndexDBManager = /*#__PURE__*/function () {
                       return _this4.db.table(storeName).add(data);
                     case 6:
                       if (log) {
-                        _this4.app.logger.addLog({
-                          type: 'info',
-                          title: uuid,
-                          metadata: {
-                            msg: '添加数据成功'
-                          }
-                        });
+                        // this.app.logger.addLog({
+                        //   type: 'info',
+                        //   title: uuid,
+                        //   metadata: { msg: '添加数据成功' }
+                        // });
                         console.log('✅ 添加事务完成');
-                        _this4.app.logger.addLog({
-                          type: 'info',
-                          title: uuid,
-                          metadata: {
-                            msg: '事务完成'
-                          }
-                        });
+                        // this.app.logger.addLog({
+                        // type: 'info',
+                        // title: uuid,
+                        // metadata: { msg: '事务完成' }
+                        // });
                       }
                       return _context3.abrupt("return", data);
                     case 10:
@@ -448,13 +441,11 @@ var IndexDBManager = /*#__PURE__*/function () {
               log = _args8.length > 2 && _args8[2] !== undefined ? _args8[2] : false;
               uuid = "[ IndexDB ] GET: - ".concat(storeName, " - ").concat(key, " - ").concat(dayjs().valueOf());
               if (log) {
-                this.app.logger.addLog({
-                  type: 'info',
-                  title: uuid,
-                  metadata: {
-                    msg: '获取数据前'
-                  }
-                });
+                // this.app.logger.addLog({
+                //   type: 'info',
+                //   title: uuid,
+                //   metadata: { msg: '获取数据前' }
+                // })
               }
               if (this.useIndexDB) {
                 _context8.next = 6;
@@ -490,20 +481,16 @@ var IndexDBManager = /*#__PURE__*/function () {
                     case 6:
                       result = _context7.sent;
                       if (log) {
-                        _this6.app.logger.addLog({
-                          type: 'info',
-                          title: uuid,
-                          metadata: {
-                            msg: '获取成功'
-                          }
-                        });
-                        _this6.app.logger.addLog({
-                          type: 'info',
-                          title: uuid,
-                          metadata: {
-                            msg: '事务完成'
-                          }
-                        });
+                        // this.app.logger.addLog({
+                        //   type: 'info',
+                        //   title: uuid,
+                        //   metadata: { msg: '获取成功' }
+                        // });
+                        // this.app.logger.addLog({
+                        //   type: 'info',
+                        //   title: uuid,
+                        //   metadata: { msg: '事务完成' }
+                        // });
                       }
                       return _context7.abrupt("return", result !== null && result !== void 0 ? result : null);
                     case 11:
@@ -578,14 +565,11 @@ var IndexDBManager = /*#__PURE__*/function () {
             case 8:
               uuid = "[ IndexDB ] UPDATE: - ".concat(storeName, " - ").concat(dayjs().valueOf());
               if (log) {
-                this.app.logger.addLog({
-                  type: 'info',
-                  title: uuid,
-                  metadata: {
-                    msg: '更新数据前',
-                    data: data
-                  }
-                });
+                // this.app.logger.addLog({
+                //   type: 'info',
+                //   title: uuid,
+                //   metadata: { msg: '更新数据前', data: data }
+                // })
               }
               return _context10.abrupt("return", this.withTimeout(_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
                 return _regeneratorRuntime().wrap(function _callee9$(_context9) {
@@ -611,21 +595,17 @@ var IndexDBManager = /*#__PURE__*/function () {
                       return _this7.db.table(storeName).put(data);
                     case 6:
                       if (log) {
-                        _this7.app.logger.addLog({
-                          type: 'info',
-                          title: uuid,
-                          metadata: {
-                            msg: '数据更新完成'
-                          }
-                        });
-                        console.log('✅ 事务完成');
-                        _this7.app.logger.addLog({
-                          type: 'info',
-                          title: uuid,
-                          metadata: {
-                            msg: '事务完成'
-                          }
-                        });
+                        // this.app.logger.addLog({
+                        //   type: 'info',
+                        //   title: uuid,
+                        //   metadata: { msg: '数据更新完成' }
+                        // });
+                        // console.log('✅ 事务完成');
+                        // this.app.logger.addLog({
+                        //   type: 'info',
+                        //   title: uuid,
+                        //   metadata: { msg: '事务完成' }
+                        // });
                       }
                       return _context9.abrupt("return", data);
                     case 10:

package/es/logger/index.d.ts

@@ -47,7 +47,7 @@ declare class LoggerManager {
      * @param checkInterval 检查间隔时间，默认5分钟
      */
     constructor(app: App, options?: LoggerOptions);
-    init(): void;
+    init(): Promise<void>;
     /**
      * 初始化 IndexDB
      */