@pisell/core 1.0.14 → 1.0.16

package/es/applicationManager/application.js

@@ -10,17 +10,42 @@ function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _d
 function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
 function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * 应用接口类型定义
+ * @description 描述应用中单个页面、组件或功能的接口结构
+ */
+
+/**
+ * 应用数据类型定义
+ * @description 描述完整应用的数据结构，包含应用的基本信息、接口、功能等
+ */
+
+/**
+ * 应用管理类
+ * @description 负责管理单个应用的生命周期，包括接口、组件、功能的初始化和管理
+ * @class Application
+ * @author zhiwei.Wang
+ */
 export var Application = /*#__PURE__*/function () {
+  /**
+   * 构造函数
+   * @description 初始化应用实例，设置基本属性并初始化接口和功能
+   * @param {ApplicationData} options - 应用配置数据
+   * @param {App} app - 应用实例引用
+   */
   function Application(options, app) {
     _classCallCheck(this, Application);
+    /** 应用配置数据 */
     _defineProperty(this, "options", void 0);
+    /** 应用名称 */
     _defineProperty(this, "name", void 0);
-    // 应用内的interface
+    /** 应用内的页面接口映射表，以页面名称为键 */
     _defineProperty(this, "interfaces", new Map());
-    // 应用内的组件
+    /** 应用内的组件映射表，以组件编码为键 */
     _defineProperty(this, "components", new Map());
-    // 应用内的函数, 比如跳转登录页面的方法
+    /** 应用内的功能函数映射表，比如跳转登录页面的方法等 */
     _defineProperty(this, "functions", new Map());
+    /** 应用实例引用 */
     _defineProperty(this, "app", void 0);
     this.options = options;
     this.name = options.app_name;
@@ -28,67 +53,127 @@ export var Application = /*#__PURE__*/function () {
     this.initInterfaces(options.interfaces);
     this.initFunctions(options.functions);
   }
+
+  /**
+   * 应用添加后的内部处理方法
+   * @description 在应用被添加到应用管理器后执行的内部逻辑，包括加载多语言配置和执行用户自定义的afterAdd方法
+   * @param {Application} application - 被添加的应用实例
+   * @returns {Promise<void>}
+   * @private
+   */
   _createClass(Application, [{
-    key: "afterAdd",
-    value: function () {
-      var _afterAdd = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(application) {
+    key: "_afterAdd",
+    value: (function () {
+      var _afterAdd2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(application) {
         return _regeneratorRuntime().wrap(function _callee$(_context) {
           while (1) switch (_context.prev = _context.next) {
             case 0:
               if (application.options.locales) {
                 this.app.locales.loadLibraryByUrl(application.options.locales);
               }
-            case 1:
+              _context.prev = 1;
+              _context.next = 4;
+              return this.afterAdd(this);
+            case 4:
+              _context.next = 9;
+              break;
+            case 6:
+              _context.prev = 6;
+              _context.t0 = _context["catch"](1);
+              console.log(_context.t0);
+            case 9:
             case "end":
               return _context.stop();
           }
-        }, _callee, this);
+        }, _callee, this, [[1, 6]]);
       }));
-      function afterAdd(_x) {
-        return _afterAdd.apply(this, arguments);
+      function _afterAdd(_x) {
+        return _afterAdd2.apply(this, arguments);
       }
-      return afterAdd;
+      return _afterAdd;
     }()
+    /**
+     * 应用加载前的内部处理方法
+     * @description 在应用开始加载前执行的内部逻辑，调用用户自定义的beforeLoad方法
+     * @returns {Promise<void>}
+     * @private
+     */
+    )
   }, {
-    key: "beforeLoad",
-    value: function () {
-      var _beforeLoad = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    key: "_beforeLoad",
+    value: (function () {
+      var _beforeLoad2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
         return _regeneratorRuntime().wrap(function _callee2$(_context2) {
           while (1) switch (_context2.prev = _context2.next) {
             case 0:
+              _context2.prev = 0;
+              _context2.next = 3;
+              return this.beforeLoad(this);
+            case 3:
+              _context2.next = 8;
+              break;
+            case 5:
+              _context2.prev = 5;
+              _context2.t0 = _context2["catch"](0);
+              console.log(_context2.t0);
+            case 8:
             case "end":
               return _context2.stop();
           }
-        }, _callee2);
+        }, _callee2, this, [[0, 5]]);
       }));
-      function beforeLoad() {
-        return _beforeLoad.apply(this, arguments);
+      function _beforeLoad() {
+        return _beforeLoad2.apply(this, arguments);
       }
-      return beforeLoad;
+      return _beforeLoad;
     }()
+    /**
+     * 应用加载的内部处理方法
+     * @description 执行应用的实际加载逻辑，将应用中的所有接口注册为路由
+     * @returns {Promise<void>}
+     * @private
+     */
+    )
   }, {
-    key: "load",
-    value: function () {
-      var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+    key: "_load",
+    value: (function () {
+      var _load2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
         var _this = this;
         return _regeneratorRuntime().wrap(function _callee3$(_context3) {
           while (1) switch (_context3.prev = _context3.next) {
             case 0:
+              _context3.prev = 0;
               // 将interface 生成路由
               this.interfaces.forEach(function (item, key) {
-                _this.app.router.add(item.router, item);
+                _this.app.router.add((item === null || item === void 0 ? void 0 : item.router) || '', item);
               });
-            case 1:
+              _context3.next = 4;
+              return this.load(this);
+            case 4:
+              _context3.next = 9;
+              break;
+            case 6:
+              _context3.prev = 6;
+              _context3.t0 = _context3["catch"](0);
+              console.log(_context3.t0);
+            case 9:
             case "end":
               return _context3.stop();
           }
-        }, _callee3, this);
+        }, _callee3, this, [[0, 6]]);
       }));
-      function load() {
-        return _load.apply(this, arguments);
+      function _load() {
+        return _load2.apply(this, arguments);
       }
-      return load;
+      return _load;
     }()
+    /**
+     * 初始化应用接口
+     * @description 遍历应用配置中的接口列表，根据类别将它们分别设置到对应的映射表中
+     * @param {ApplicationData['interfaces']} interfaces - 接口配置数组
+     * @returns {void}
+     */
+    )
   }, {
     key: "initInterfaces",
     value: function initInterfaces(interfaces) {
@@ -103,13 +188,13 @@ export var Application = /*#__PURE__*/function () {
                 return _this2.loadInterface(interfaceItem);
               case 2:
                 _interface = _context4.sent;
-                if (interfaceItem.category === "page") {
+                if (interfaceItem.category === 'page') {
                   _this2.setInterface(interfaceItem.page_code, _interface);
                 }
-                if (interfaceItem.category === "component") {
+                if (interfaceItem.category === 'component') {
                   _this2.setComponent(interfaceItem.page_code, _interface);
                 }
-                if (interfaceItem.category === "function") {
+                if (interfaceItem.category === 'function') {
                   _this2.setFunction(interfaceItem.page_code, _interface);
                 }
               case 6:
@@ -123,6 +208,13 @@ export var Application = /*#__PURE__*/function () {
         };
       }());
     }
+
+    /**
+     * 初始化应用功能函数
+     * @description 遍历应用配置中的功能列表，将它们设置到功能映射表中
+     * @param {ApplicationData['functions']} functions - 功能配置数组，可选
+     * @returns {void}
+     */
   }, {
     key: "initFunctions",
     value: function initFunctions(functions) {
@@ -144,9 +236,16 @@ export var Application = /*#__PURE__*/function () {
         };
       }());
     }
+
+    /**
+     * 加载接口组件
+     * @description 根据接口类型加载对应的组件，支持低代码和普通代码两种类型
+     * @param {ApplicationInterface} interfaceItem - 接口配置项
+     * @returns {Promise<ApplicationInterface>} 加载后的接口配置
+     */
   }, {
     key: "loadInterface",
-    value: function () {
+    value: (function () {
       var _loadInterface = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(interfaceItem) {
         return _regeneratorRuntime().wrap(function _callee6$(_context6) {
           while (1) switch (_context6.prev = _context6.next) {
@@ -157,10 +256,10 @@ export var Application = /*#__PURE__*/function () {
               }
               return _context6.abrupt("return", interfaceItem);
             case 2:
-              if (interfaceItem.page_type === "low_code") {
+              if (interfaceItem.page_type === 'low_code') {
                 // TODO: load low code interface
               }
-              if (interfaceItem.page_type === "code") {
+              if (interfaceItem.page_type === 'code') {
                 // TODO: load code interface
               }
               return _context6.abrupt("return", interfaceItem);
@@ -175,36 +274,89 @@ export var Application = /*#__PURE__*/function () {
       }
       return loadInterface;
     }()
+    /**
+     * 设置页面
+     * @description 将页面接口添加到接口映射表中
+     * @param {string} code - 页面编码
+     * @param {ApplicationInterface} interfaceItem - 接口配置项
+     * @returns {void}
+     */
+    )
   }, {
     key: "setInterface",
     value: function setInterface(code, interfaceItem) {
       this.interfaces.set(code, interfaceItem);
     }
+
+    /**
+     * 设置组件
+     * @description 将组件添加到组件映射表中
+     * @param {string} code - 组件编码
+     * @param {ApplicationInterface} component - 组件配置项
+     * @returns {void}
+     */
   }, {
     key: "setComponent",
     value: function setComponent(code, component) {
       this.components.set(code, component);
     }
+
+    /**
+     * 设置功能函数
+     * @description 将功能函数添加到功能映射表中
+     * @param {string} code - 功能编码
+     * @param {ApplicationInterface} functionItem - 功能配置项
+     * @returns {void}
+     */
   }, {
     key: "setFunction",
     value: function setFunction(code, functionItem) {
       this.functions.set(code, functionItem);
     }
+
+    /**
+     * 获取页面
+     * @description 根据编码从接口映射表中获取页面接口
+     * @param {string} code - 页面编码
+     * @returns {ApplicationInterface | undefined} 接口配置项或undefined
+     */
   }, {
     key: "getInterface",
     value: function getInterface(code) {
       return this.interfaces.get(code);
     }
+
+    /**
+     * 获取组件
+     * @description 根据编码从组件映射表中获取组件
+     * @param {string} code - 组件编码
+     * @returns {any | undefined} 组件或undefined
+     */
   }, {
     key: "getComponent",
     value: function getComponent(code) {
       return this.components.get(code);
     }
+
+    /**
+     * 获取功能函数
+     * @description 根据编码从功能映射表中获取功能函数
+     * @param {string} code - 功能编码
+     * @returns {any | undefined} 功能函数或undefined
+     */
   }, {
     key: "getFunction",
     value: function getFunction(code) {
       return this.functions.get(code);
     }
+    /**
+     * 执行功能函数
+     * @description 根据编码执行对应的功能函数，自动注入应用实例并合并参数
+     * @param {string} code - 功能编码
+     * @param {any} params - 传递给功能函数的参数对象，可选
+     * @param {...any} args - 传递给功能函数的其他参数
+     * @returns {any} 功能函数的执行结果
+     */
   }, {
     key: "runFunction",
     value: function runFunction(code, params) {
@@ -218,6 +370,79 @@ export var Application = /*#__PURE__*/function () {
       }
       return (_this$getFunction = this.getFunction(code)) === null || _this$getFunction === void 0 ? void 0 : _this$getFunction.code.apply(_this$getFunction, [_params].concat(args));
     }
+
+    /**
+     * 应用添加后触发的钩子函数
+     * @description 在应用被添加到应用管理器后触发，可被子类覆盖以实现自定义逻辑
+     * @param {Application} application - 被添加的应用实例
+     * @returns {Promise<void>}
+     * @author zhiwei.Wang
+     */
+  }, {
+    key: "afterAdd",
+    value: (function () {
+      var _afterAdd3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(application) {
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7);
+      }));
+      function afterAdd(_x5) {
+        return _afterAdd3.apply(this, arguments);
+      }
+      return afterAdd;
+    }()
+    /**
+     * 应用加载前触发的钩子函数
+     * @description 在应用开始加载前触发，可被子类覆盖以实现自定义预处理逻辑
+     * @returns {Promise<void>}
+     * @author zhiwei.Wang
+     */
+    )
+  }, {
+    key: "beforeLoad",
+    value: (function () {
+      var _beforeLoad3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(application) {
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function beforeLoad(_x6) {
+        return _beforeLoad3.apply(this, arguments);
+      }
+      return beforeLoad;
+    }()
+    /**
+     * 应用加载完成后触发的钩子函数
+     * @description 在应用完成加载后触发，可被子类覆盖以实现自定义后处理逻辑
+     * @returns {Promise<void>}
+     * @author zhiwei.Wang
+     */
+    )
+  }, {
+    key: "load",
+    value: (function () {
+      var _load3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(application) {
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9);
+      }));
+      function load(_x7) {
+        return _load3.apply(this, arguments);
+      }
+      return load;
+    }())
   }]);
   return Application;
 }();

package/es/applicationManager/index.d.ts

@@ -0,0 +1,18 @@
+import APP from '../app';
+import { Application, ApplicationData } 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/applicationManager/index.js

@@ -43,7 +43,7 @@ export var ApplicationManager = /*#__PURE__*/function () {
                             return _regeneratorRuntime().wrap(function _callee$(_context) {
                               while (1) switch (_context.prev = _context.next) {
                                 case 0:
-                                  if (_typeof(application) === "object") {
+                                  if (_typeof(application) === 'object') {
                                     application = new Application(application, _this.app);
                                   }
                                   _context.next = 3;
@@ -92,7 +92,7 @@ export var ApplicationManager = /*#__PURE__*/function () {
             case 0:
               this.applications.set(application.name, application);
               _context4.next = 3;
-              return application.afterAdd(application);
+              return application._afterAdd(application);
             case 3:
             case "end":
               return _context4.stop();
@@ -119,7 +119,7 @@ export var ApplicationManager = /*#__PURE__*/function () {
     key: "load",
     value: function () {
       var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
-        var _iterator, _step, plugin, _iterator2, _step2, _plugin;
+        var _iterator, _step, application, _iterator2, _step2, _application;
         return _regeneratorRuntime().wrap(function _callee5$(_context5) {
           while (1) switch (_context5.prev = _context5.next) {
             case 0:
@@ -131,9 +131,9 @@ export var ApplicationManager = /*#__PURE__*/function () {
                 _context5.next = 9;
                 break;
               }
-              plugin = _step.value;
+              application = _step.value;
               _context5.next = 7;
-              return plugin.beforeLoad();
+              return application._beforeLoad();
             case 7:
               _context5.next = 3;
               break;
@@ -157,9 +157,9 @@ export var ApplicationManager = /*#__PURE__*/function () {
                 _context5.next = 26;
                 break;
               }
-              _plugin = _step2.value;
+              _application = _step2.value;
               _context5.next = 24;
-              return _plugin.load();
+              return _application._load();
             case 24:
               _context5.next = 20;
               break;
@@ -185,6 +185,21 @@ export var ApplicationManager = /*#__PURE__*/function () {
       }
       return load;
     }()
+    /**
+     * 循环所有的应用, 找出所有的components进行渲染
+     * @returns
+     */
+  }, {
+    key: "getAllComponents",
+    value: function getAllComponents() {
+      return Array.from(this.applications.values()).flatMap(function (application) {
+        return Array.from(application.components.values());
+      }).filter(function (component) {
+        return component.autoRender;
+      }).map(function (component) {
+        return component.Component;
+      });
+    }
   }]);
   return ApplicationManager;
 }();

package/es/aws/index.d.ts

@@ -0,0 +1,16 @@
+import { S3ClientConfig, PutObjectCommandInput } from '@aws-sdk/client-s3';
+import App from '../app';
+export interface AWSOptions extends S3ClientConfig {
+    s3Config: S3ClientConfig;
+    bucketName?: string;
+}
+export interface UploadParams extends PutObjectCommandInput {
+}
+declare class AWS {
+    private s3Client?;
+    private app;
+    private config?;
+    constructor(app: App, options?: AWSOptions);
+    upload(params: UploadParams): Promise<import("@aws-sdk/client-s3").PutObjectCommandOutput | undefined>;
+}
+export default AWS;

package/es/cmd/const.d.ts

@@ -0,0 +1,11 @@
+export declare enum CMDCoreEnum {
+    CMD_CONNECT,
+    CMD_DISCONNECT,
+    CMD_RECONNECT,
+    CMD_MESSAGE,
+    CMD_ERROR
+}
+declare const _default: {
+    CMDCoreEnum: typeof CMDCoreEnum;
+};
+export default _default;

package/es/cmd/index.d.ts

@@ -0,0 +1,13 @@
+import App from "../app";
+import { CMDCoreEnum } from "./const";
+export interface CMDOptions {
+    socketUrl?: string;
+}
+declare class CMD {
+    private app;
+    private options?;
+    constructor(app: App, options?: CMDOptions);
+    init(): void;
+}
+export { CMDCoreEnum };
+export default CMD;

package/es/cmd/type.d.ts

@@ -0,0 +1,5 @@
+export interface CDMItem {
+    key: string;
+    code: string;
+    [key: string]: any;
+}

package/es/config.d.ts

@@ -0,0 +1,3 @@
+import { CoreConfig } from './type';
+export declare const setConfig: (newConfig: Partial<CoreConfig>) => void;
+export declare const getConfig: () => CoreConfig;

package/es/cookie/index.d.ts

@@ -0,0 +1,13 @@
+declare function setCookie(name: string, value: string, domain?: string): void;
+declare function getCookie(name: string): string | null;
+declare function deleteCookie(name: string, domain?: string): void;
+declare function checkCookie(name: string): boolean;
+declare function updateCookie(name: string, value: string, domain?: string): void;
+declare const _default: {
+    setCookie: typeof setCookie;
+    getCookie: typeof getCookie;
+    deleteCookie: typeof deleteCookie;
+    checkCookie: typeof checkCookie;
+    updateCookie: typeof updateCookie;
+};
+export default _default;

package/es/data/index.d.ts

@@ -0,0 +1,8 @@
+import { Storage } from '../storage';
+import App from '../app';
+export declare class Data {
+    private app;
+    storage: Storage;
+    store: any;
+    constructor(app: App);
+}

package/es/history/config.d.ts

@@ -0,0 +1,24 @@
+import { HistoryConfig } from './type';
+/**
+ * @title: 默认配置
+ * @description:
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const defaultConfig: HistoryConfig;
+/**
+ * @title: 设置配置
+ * @description:
+ * @param {Partial} newConfig
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const setConfig: (newConfig: Partial<HistoryConfig>) => HistoryConfig;
+/**
+ * @title: 获取配置
+ * @description:
+ * @param {*} HistoryConfig
+ * @return {*}
+ * @Author: zhiwei.Wang
+ */
+export declare const getConfig: () => HistoryConfig;

package/es/history/index.d.ts

@@ -0,0 +1,20 @@
+import type { History as HistoryType } from "history";
+import { useHistory, useLocation, useParams } from "react-router-dom";
+import App from "../app";
+export interface HistoryOptions {
+    basename?: string;
+}
+export declare class History {
+    instance: HistoryType<unknown>;
+    useHistory: typeof useHistory;
+    useLocation: typeof useLocation;
+    useParams: typeof useParams;
+    app: App;
+    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/history/type.d.ts

@@ -0,0 +1,2 @@
+export interface HistoryConfig {
+}

package/es/hooks/index.d.ts

@@ -0,0 +1,12 @@
+import useLowCode from './useLowCode';
+import useDelayedValue from './useDelayedValue';
+import useStore from './useStore';
+import useDispatch from './useDispatch';
+export interface HooksExport {
+    useLowCode: typeof useLowCode;
+    useDelayedValue: typeof useDelayedValue;
+    useStore: typeof useStore;
+    useDispatch: typeof useDispatch;
+}
+declare const _default: HooksExport;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare function useDelayedValue<T>(value: T, timeout?: number): T;
+export default useDelayedValue;

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

@@ -0,0 +1,2 @@
+import { useDispatch } from "react-redux";
+export default useDispatch;