@pisell/core 1.0.41 → 1.0.43

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

@@ -52,7 +52,7 @@ var IndexDBManager = class _IndexDBManager {
   // 内存存储：每个 store 使用一个 Map，key 为主键，value 为数据
   memoryStorage = /* @__PURE__ */ new Map();
   // 操作超时时间（毫秒）
-  timeout = 5e3;
+  timeout = 1e4;
   /**
    * 创建 IndexDBManager 实例
    * @param {DBOptions} options - 数据库配置选项
@@ -63,7 +63,7 @@ var IndexDBManager = class _IndexDBManager {
     this.version = options.version;
     this.stores = options.stores;
     this.useIndexDB = _IndexDBManager.isSupported();
-    this.timeout = options.timeout ?? 5e3;
+    this.timeout = options.timeout ?? 1e4;
     if (!this.useIndexDB) {
       this.stores.forEach((store) => {
         this.memoryStorage.set(store.name, /* @__PURE__ */ new Map());
@@ -200,11 +200,6 @@ var IndexDBManager = class _IndexDBManager {
     }
     const uuid = `[ IndexDB ] ADD: - ${storeName} - ${(0, import_dayjs.default)().valueOf()}`;
     if (log) {
-      this.app.logger.addLog({
-        type: "info",
-        title: uuid,
-        metadata: { msg: "添加数据前", data }
-      });
     }
     return this.withTimeout(
       (async () => {
@@ -221,17 +216,7 @@ var IndexDBManager = class _IndexDBManager {
         try {
           await this.db.table(storeName).add(data);
           if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "添加数据成功" }
-            });
             console.log("✅ 添加事务完成");
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "事务完成" }
-            });
           }
           return data;
         } catch (error) {
@@ -285,11 +270,6 @@ var IndexDBManager = class _IndexDBManager {
   async get(storeName, key, log = false) {
     const uuid = `[ IndexDB ] GET: - ${storeName} - ${key} - ${(0, import_dayjs.default)().valueOf()}`;
     if (log) {
-      this.app.logger.addLog({
-        type: "info",
-        title: uuid,
-        metadata: { msg: "获取数据前" }
-      });
     }
     if (!this.useIndexDB) {
       const memStore = this.getMemoryStore(storeName);
@@ -310,16 +290,6 @@ var IndexDBManager = class _IndexDBManager {
         try {
           const result = await this.db.table(storeName).get(key);
           if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "获取成功" }
-            });
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "事务完成" }
-            });
           }
           return result ?? null;
         } catch (error) {
@@ -355,11 +325,6 @@ var IndexDBManager = class _IndexDBManager {
     }
     const uuid = `[ IndexDB ] UPDATE: - ${storeName} - ${(0, import_dayjs.default)().valueOf()}`;
     if (log) {
-      this.app.logger.addLog({
-        type: "info",
-        title: uuid,
-        metadata: { msg: "更新数据前", data }
-      });
     }
     return this.withTimeout(
       (async () => {
@@ -376,17 +341,6 @@ var IndexDBManager = class _IndexDBManager {
         try {
           await this.db.table(storeName).put(data);
           if (log) {
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "数据更新完成" }
-            });
-            console.log("✅ 事务完成");
-            this.app.logger.addLog({
-              type: "info",
-              title: uuid,
-              metadata: { msg: "事务完成" }
-            });
           }
           return data;
         } catch (error) {

package/lib/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
      */

package/lib/logger/index.js

@@ -67,10 +67,14 @@ var LoggerManager = class {
     this.retentionDays = (options == null ? void 0 : options.retentionDays) || 7;
     this.initDB();
   }
-  init() {
+  async init() {
     this.setStatus("running");
     this.initTimer();
-    this.cleanupOldLogs();
+    await this.cleanupOldLogs();
+    try {
+      await this.uploadIndexDBLog();
+    } catch (error) {
+    }
   }
   /**
    * 初始化 IndexDB
@@ -211,7 +215,6 @@ var LoggerManager = class {
    */
   async storeLog(urgent) {
     var _a;
-    this.uploadIndexDBLog();
     if (this.logBuffer.length === 0 || !this.db) {
       return;
     }
@@ -236,8 +239,16 @@ var LoggerManager = class {
           type: "error",
           title: "存储日志到AWS失败",
           metadata: {
-            error: JSON.stringify(error),
-            indexDBError: JSON.stringify(indexDBError)
+            error: {
+              name: error == null ? void 0 : error.name,
+              message: error == null ? void 0 : error.message,
+              stack: error == null ? void 0 : error.stack
+            },
+            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);
@@ -266,7 +277,11 @@ var LoggerManager = class {
         type: "error",
         title: "存储IndexDB日志到AWS失败",
         metadata: {
-          error: JSON.stringify(error)
+          error: {
+            name: error == null ? void 0 : error.name,
+            message: error == null ? void 0 : error.message,
+            stack: error == null ? void 0 : error.stack
+          }
         }
       });
       throw error;

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;
+}

package/lib/request/cache.d.ts

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

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

package/lib/request/type.d.ts

@@ -0,0 +1,52 @@
+import { CreateAxiosDefaults } from "axios";
+import { CacheType } from './cache';
+export interface RequestConfig {
+    interceptorsRequest?: ((value: any) => any | Promise<any>) | null;
+    interceptorsRequestError?: ((error: any) => any) | null;
+    interceptorsResponse?: any;
+    interceptorsResponseError?: ((error: any) => any) | null;
+    axiosConfig?: CreateAxiosDefaults;
+    storage?: any;
+    getToken?: () => string | null;
+    setToken?: (token: string) => void;
+    getLocale?: () => string | null;
+    getUrl?: (config: any) => string;
+    requestCallbacks?: {
+        200?: (data: any) => void;
+        401?: (data: any) => void;
+        403?: (data: any) => void;
+        other?: (data: any) => void;
+        [key: string]: any;
+    };
+}
+export declare enum RequestModeENUM {
+    LOCAL = "local",
+    REMOTE = "remote",
+    LOCAL_REMOTE = "local_remote",
+    REMOTE_LOCAL = "remote_local",
+    OS_SERVER = "os_server"
+}
+export declare type RequestModeType = RequestModeENUM.LOCAL | RequestModeENUM.REMOTE | RequestModeENUM.LOCAL_REMOTE | RequestModeENUM.REMOTE_LOCAL | RequestModeENUM.OS_SERVER;
+export interface CacheProps {
+    key?: string;
+    type?: CacheType;
+    updateCache?: boolean;
+    cacheUpdateChange?: (data: any) => void;
+    mode?: RequestModeType;
+    cacheKeyData?: any;
+}
+export interface RequestSetting {
+    abort?: boolean;
+    headers?: any;
+    cache?: CacheProps;
+    signal?: any;
+    token?: string;
+    osServer?: boolean;
+    [key: string]: any;
+}
+export interface RequestWrapperProps {
+    url: string;
+    method: 'get' | 'post' | 'remove' | 'put';
+    data?: any;
+    config?: RequestSetting;
+}