@pisell/core 1.0.40 → 1.0.41

package/es/logger/index.js

@@ -295,16 +295,18 @@ var LoggerManager = /*#__PURE__*/function () {
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
+              // 每次上传日志时，检查下IndexDB是否有日志，如果有则上传到AWS
+              this.uploadIndexDBLog();
               if (!(this.logBuffer.length === 0 || !this.db)) {
-                _context3.next = 2;
+                _context3.next = 3;
                 break;
               }
               return _context3.abrupt("return");
-            case 2:
-              _context3.prev = 2;
-              _context3.next = 5;
+            case 3:
+              _context3.prev = 3;
+              _context3.next = 6;
               return this.createAWSFileName(urgent);
-            case 5:
+            case 6:
               fileName = _context3.sent;
               console.log("-------- 存储日志到AWS 开始", fileName);
 
@@ -317,35 +319,35 @@ var LoggerManager = /*#__PURE__*/function () {
                 return item.logId;
               });
               logs = JSON.stringify(buffer, null, 2);
-              _context3.next = 12;
+              _context3.next = 13;
               return this.app.aws.upload({
                 Bucket: "",
                 Key: fileName,
                 Body: logs
               });
-            case 12:
+            case 13:
               console.log("-------- 存储日志到AWS 成功");
               // 上传成功后需要清空缓冲区，避免重复上传
               this.logBuffer = this.logBuffer.filter(function (item) {
                 return !bufferIds.includes(item.logId);
               });
-              _context3.next = 28;
+              _context3.next = 29;
               break;
-            case 16:
-              _context3.prev = 16;
-              _context3.t0 = _context3["catch"](2);
+            case 17:
+              _context3.prev = 17;
+              _context3.t0 = _context3["catch"](3);
               console.error("存储日志上传AWS失败:", _context3.t0);
 
               // 将日志存储到IndexDB
-              _context3.prev = 19;
-              _context3.next = 22;
+              _context3.prev = 20;
+              _context3.next = 23;
               return this.storeLogToIndexDB();
-            case 22:
-              _context3.next = 28;
+            case 23:
+              _context3.next = 29;
               break;
-            case 24:
-              _context3.prev = 24;
-              _context3.t1 = _context3["catch"](19);
+            case 25:
+              _context3.prev = 25;
+              _context3.t1 = _context3["catch"](20);
               this.sendFeishuNotification({
                 type: "error",
                 title: "存储日志到AWS失败",
@@ -355,11 +357,11 @@ var LoggerManager = /*#__PURE__*/function () {
                 }
               });
               console.error("存储日志到IndexDB也失败:", _context3.t1);
-            case 28:
+            case 29:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this, [[2, 16], [19, 24]]);
+        }, _callee3, this, [[3, 17], [20, 25]]);
       }));
       function storeLog(_x2) {
         return _storeLog.apply(this, arguments);
@@ -375,31 +377,43 @@ var LoggerManager = /*#__PURE__*/function () {
           while (1) switch (_context4.prev = _context4.next) {
             case 0:
               _context4.prev = 0;
-              _context4.next = 3;
-              return (_this$db = this.db) === null || _this$db === void 0 ? void 0 : _this$db.getAll("logs");
+              if (this.db) {
+                _context4.next = 3;
+                break;
+              }
+              return _context4.abrupt("return");
             case 3:
+              _context4.next = 5;
+              return (_this$db = this.db) === null || _this$db === void 0 ? void 0 : _this$db.getAll("logs");
+            case 5:
               logFile = _context4.sent;
-              _context4.next = 6;
+              if (!(!logFile || (logFile === null || logFile === void 0 ? void 0 : logFile.length) === 0)) {
+                _context4.next = 8;
+                break;
+              }
+              return _context4.abrupt("return");
+            case 8:
+              _context4.next = 10;
               return this.createAWSFileName(true);
-            case 6:
+            case 10:
               awsFileName = _context4.sent;
               logs = JSON.stringify(logFile, null, 2);
-              _context4.next = 10;
+              _context4.next = 14;
               return this.app.aws.upload({
                 Bucket: "",
                 Key: awsFileName,
                 Body: logs
               });
-            case 10:
+            case 14:
               console.log("-------- 存储日志到AWS 成功");
-              _context4.next = 13;
+              _context4.next = 17;
               return (_this$db2 = this.db) === null || _this$db2 === void 0 ? void 0 : _this$db2.clear("logs");
-            case 13:
+            case 17:
               console.log("-------- 清空IndexDB日志成功");
-              _context4.next = 21;
+              _context4.next = 25;
               break;
-            case 16:
-              _context4.prev = 16;
+            case 20:
+              _context4.prev = 20;
               _context4.t0 = _context4["catch"](0);
               console.log("-------- 存储日志到IndexDB 失败", _context4.t0);
               this.sendFeishuNotification({
@@ -411,11 +425,11 @@ var LoggerManager = /*#__PURE__*/function () {
               });
               // 重新抛出错误，让外层 catch 能够捕获
               throw _context4.t0;
-            case 21:
+            case 25:
             case "end":
               return _context4.stop();
           }
-        }, _callee4, this, [[0, 16]]);
+        }, _callee4, this, [[0, 20]]);
       }));
       function uploadIndexDBLog() {
         return _uploadIndexDBLog.apply(this, arguments);

package/lib/logger/index.js

@@ -211,6 +211,7 @@ var LoggerManager = class {
    */
   async storeLog(urgent) {
     var _a;
+    this.uploadIndexDBLog();
     if (this.logBuffer.length === 0 || !this.db) {
       return;
     }
@@ -246,7 +247,13 @@ var LoggerManager = class {
   async uploadIndexDBLog() {
     var _a, _b;
     try {
+      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 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pisell/core",
-  "version": "1.0.40",
+  "version": "1.0.41",
   "sideEffects": false,
   "main": "./lib/index.js",
   "module": "./es/index.js",

package/es/app/app.d.ts

@@ -1,99 +0,0 @@
-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

@@ -1,197 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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/menuManager/index.d.ts

@@ -1,28 +0,0 @@
-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;
-}

package/es/request/cache.d.ts

@@ -1,46 +0,0 @@
-import { CacheProps } from './type';
-export declare type CacheType = 'memory' | 'storage' | 'indexDB';
-/**
- * @title: 设置缓存
- * @description:
- * @return {*}
- * @Author: zhiwei.Wang
- */
-export declare const setCache: (key: string, data: any, cache: CacheProps) => Promise<void>;
-/**
- * @title: 删除缓存数据
- * @description:
- * @return {*}
- * @Author: zhiwei.Wang
- */
-export declare const removeCache: (key: string, cache: CacheProps) => void;
-/**
- * @title: 获取数据
- * @description:
- * @param {any} url
- * @param {any} data
- * @return {*}
- * @Author: zhiwei.Wang
- */
-export declare const getCacheData: (url: string, data: any, cache: CacheProps) => Promise<any>;
-/**
- * @title: 设置缓存
- * @description:
- * @param {any} url 路径
- * @param {any} data 参数
- * @param {any} res 数据
- * @return {*}
- * @Author: zhiwei.Wang
- */
-export declare const setCacheData: (url: string, data: any, res: any, cache?: CacheProps) => any | null;
-/**
- * @title: 缓存函数包装器
- * @description:
- * @param {any} url
- * @param {any} data
- * @param {any} config
- * @param {any} fn
- * @return {*}
- * @Author: zhiwei.Wang
- */
-export declare const cacheFn: (props: any, fn: any) => Promise<any>;

package/es/request/index.d.ts

@@ -1,24 +0,0 @@
-import { RequestWrapperProps, RequestConfig } from "./type";
-export declare const createRequest: (props: RequestWrapperProps) => Promise<unknown>;
-/**
- * 请求
- * @param props
- * @returns
- */
-export declare const request: (props: RequestWrapperProps) => any;
-export declare const get: (url: RequestWrapperProps["url"], data: RequestWrapperProps["data"], config: RequestWrapperProps["config"]) => Promise<any>;
-export declare const post: (url: RequestWrapperProps["url"], data: RequestWrapperProps["data"], config: RequestWrapperProps["config"]) => Promise<any>;
-export declare const put: (url: RequestWrapperProps["url"], data: RequestWrapperProps["data"], config: RequestWrapperProps["config"]) => Promise<any>;
-export declare const remove: (url: RequestWrapperProps["url"], data: RequestWrapperProps["data"], config: RequestWrapperProps["config"]) => Promise<any>;
-export declare const custom: (url: RequestWrapperProps["url"], config: RequestWrapperProps["config"]) => any;
-export * from "./type";
-declare const _default: {
-    get: (url: string, data: any, config: import("./type").RequestSetting | undefined) => Promise<any>;
-    post: (url: string, data: any, config: import("./type").RequestSetting | undefined) => Promise<any>;
-    put: (url: string, data: any, config: import("./type").RequestSetting | undefined) => Promise<any>;
-    remove: (url: string, data: any, config: import("./type").RequestSetting | undefined) => Promise<any>;
-    custom: (url: string, config: import("./type").RequestSetting | undefined) => any;
-    setConfig: (newConfig: Partial<RequestConfig>) => void;
-    getConfig: () => RequestConfig;
-};
-export default _default;