@pisell/core 0.0.2

package/lib/app/index.js

@@ -0,0 +1,76 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/app/index.tsx
+var app_exports = {};
+__export(app_exports, {
+  AppProvider: () => AppProvider,
+  default: () => app_default,
+  getApp: () => getApp,
+  useApp: () => useApp
+});
+module.exports = __toCommonJS(app_exports);
+var import_react = __toESM(require("react"));
+var import_app = __toESM(require("./app"));
+var AppContext = (0, import_react.createContext)(void 0);
+var AppProvider = ({ children, options }) => {
+  const [globalData, setGlobalData] = (0, import_react.useState)({});
+  const app = (0, import_react.useRef)(import_app.default.getInstance(options));
+  (0, import_react.useEffect)(() => {
+    app.current.install();
+    return () => {
+      app.current.unInstall();
+    };
+  }, []);
+  const _setGlobalData = (data) => {
+    setGlobalData((prev) => ({ ...prev, ...data }));
+    app.current.setGlobalData(data);
+  };
+  return /* @__PURE__ */ import_react.default.createElement(
+    AppContext.Provider,
+    {
+      value: { globalData, setGlobalData: _setGlobalData, app: app.current }
+    },
+    children
+  );
+};
+var useApp = () => {
+  const context = (0, import_react.useContext)(AppContext);
+  if (!context) {
+    throw new Error();
+  }
+  return context;
+};
+var getApp = import_app.default.getInstance;
+var app_default = import_app.default;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppProvider,
+  getApp,
+  useApp
+});

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/application.js

@@ -0,0 +1,280 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/applicationManager/application.tsx
+var application_exports = {};
+__export(application_exports, {
+  Application: () => Application
+});
+module.exports = __toCommonJS(application_exports);
+var import_react = __toESM(require("react"));
+var Application = class {
+  /** 应用配置数据 */
+  options;
+  /** 应用名称 */
+  name;
+  /** 应用内的页面接口映射表，以页面名称为键 */
+  interfaces = /* @__PURE__ */ new Map();
+  /** 应用内的组件映射表，以组件编码为键 */
+  components = /* @__PURE__ */ new Map();
+  /** 应用内的功能函数映射表，比如跳转登录页面的方法等 */
+  functions = /* @__PURE__ */ new Map();
+  /** 应用实例引用 */
+  app;
+  /**
+   * 构造函数
+   * @description 初始化应用实例，设置基本属性并初始化接口和功能
+   * @param {ApplicationData} options - 应用配置数据
+   * @param {App} app - 应用实例引用
+   */
+  constructor(options, app) {
+    this.options = options;
+    this.name = options.app_name;
+    this.app = app;
+    this.initInterfaces(options.interfaces);
+    this.initFunctions(options.functions);
+  }
+  /**
+   * 应用添加后的内部处理方法
+   * @description 在应用被添加到应用管理器后执行的内部逻辑，包括加载多语言配置和执行用户自定义的afterAdd方法
+   * @param {Application} application - 被添加的应用实例
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _afterAdd(application) {
+    if (application.options.locales) {
+      this.app.locales.loadLibraryByUrl(application.options.locales);
+    }
+    try {
+      await this.afterAdd(this);
+    } catch (err) {
+      console.log(err);
+    }
+  }
+  /**
+   * 应用加载前的内部处理方法
+   * @description 在应用开始加载前执行的内部逻辑，调用用户自定义的beforeLoad方法
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _beforeLoad() {
+    try {
+      await this.beforeLoad(this);
+    } catch (err) {
+      console.log(err);
+    }
+  }
+  /**
+   * 应用加载的内部处理方法
+   * @description 执行应用的实际加载逻辑，将应用中的所有接口注册为路由
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _load() {
+    try {
+      this.interfaces.forEach((item, key) => {
+        if (((item == null ? void 0 : item.router) || "").indexOf("/native/") === -1) {
+          this.app.router.add((item == null ? void 0 : item.router) || "", item);
+        }
+      });
+      await this.load(this);
+    } catch (err) {
+      console.log(err);
+    }
+  }
+  /**
+   * 初始化应用接口
+   * @description 遍历应用配置中的接口列表，根据类别将它们分别设置到对应的映射表中
+   * @param {ApplicationData['interfaces']} interfaces - 接口配置数组
+   * @returns {void}
+   */
+  initInterfaces(interfaces) {
+    interfaces.forEach(async (interfaceItem) => {
+      let _interface = await this.loadInterface(interfaceItem);
+      if (interfaceItem.category === "page") {
+        this.setInterface(interfaceItem.page_code, _interface);
+      }
+      if (interfaceItem.category === "component") {
+        this.setComponent(interfaceItem.page_code, _interface);
+      }
+      if (interfaceItem.category === "function") {
+        this.setFunction(interfaceItem.page_code, _interface);
+      }
+    });
+  }
+  /**
+   * 初始化应用功能函数
+   * @description 遍历应用配置中的功能列表，将它们设置到功能映射表中
+   * @param {ApplicationData['functions']} functions - 功能配置数组，可选
+   * @returns {void}
+   */
+  initFunctions(functions) {
+    (functions || []).forEach(async (functionItem) => {
+      this.setFunction(functionItem.function_code, functionItem);
+    });
+  }
+  /**
+   * 加载接口组件
+   * @description 根据接口类型加载对应的组件，支持低代码和普通代码两种类型
+   * @param {ApplicationInterface} interfaceItem - 接口配置项
+   * @returns {Promise<ApplicationInterface>} 加载后的接口配置
+   */
+  async loadInterface(interfaceItem) {
+    if (interfaceItem.Component) {
+      return interfaceItem;
+    }
+    if (interfaceItem.page_type === "low_code") {
+    }
+    if (interfaceItem.page_type === "code") {
+    }
+    return interfaceItem;
+  }
+  /**
+   * 设置页面
+   * @description 将页面接口添加到接口映射表中
+   * @param {string} code - 页面编码
+   * @param {ApplicationInterface} interfaceItem - 接口配置项
+   * @returns {void}
+   */
+  setInterface(code, interfaceItem) {
+    this.interfaces.set(code, interfaceItem);
+  }
+  /**
+   * 设置组件
+   * @description 将组件添加到组件映射表中
+   * @param {string} code - 组件编码
+   * @param {ApplicationInterface} component - 组件配置项
+   * @returns {void}
+   */
+  setComponent(code, component) {
+    const Component = (props) => {
+      const ref = (0, import_react.useRef)();
+      const Com = component == null ? void 0 : component.Component;
+      return /* @__PURE__ */ import_react.default.createElement(
+        Com,
+        {
+          ...props,
+          ref: (_ref) => {
+            ref.current = _ref;
+            console.log("组件ref执行了");
+            this.components.set(code, {
+              ...this.getComponent(code),
+              ref: ref.current
+            });
+          }
+        }
+      );
+    };
+    this.components.set(code, {
+      ...component,
+      Component: component.autoRender ? Component : component.Component
+    });
+  }
+  /**
+   * 设置功能函数
+   * @description 将功能函数添加到功能映射表中
+   * @param {string} code - 功能编码
+   * @param {ApplicationInterface} functionItem - 功能配置项
+   * @returns {void}
+   */
+  setFunction(code, functionItem) {
+    this.functions.set(code, functionItem);
+  }
+  /**
+   * 获取页面
+   * @description 根据编码从接口映射表中获取页面接口
+   * @param {string} code - 页面编码
+   * @returns {ApplicationInterface | undefined} 接口配置项或undefined
+   */
+  getInterface(code) {
+    return this.interfaces.get(code);
+  }
+  /**
+   * 获取组件
+   * @description 根据编码从组件映射表中获取组件
+   * @param {string} code - 组件编码
+   * @returns {any | undefined} 组件或undefined
+   */
+  getComponent(code) {
+    return this.components.get(code);
+  }
+  /**
+   * 获取功能函数
+   * @description 根据编码从功能映射表中获取功能函数
+   * @param {string} code - 功能编码
+   * @returns {any | undefined} 功能函数或undefined
+   */
+  getFunction(code) {
+    return this.functions.get(code);
+  }
+  /**
+   * 执行功能函数
+   * @description 根据编码执行对应的功能函数，自动注入应用实例并合并参数
+   * @param {string} code - 功能编码
+   * @param {any} params - 传递给功能函数的参数对象，可选
+   * @param {...any} args - 传递给功能函数的其他参数
+   * @returns {any} 功能函数的执行结果
+   */
+  runFunction(code, params, ...args) {
+    var _a;
+    const _params = {
+      app: this.app,
+      ...params
+    };
+    return (_a = this.getFunction(code)) == null ? void 0 : _a.code(_params, ...args);
+  }
+  /**
+   * 应用添加后触发的钩子函数
+   * @description 在应用被添加到应用管理器后触发，可被子类覆盖以实现自定义逻辑
+   * @param {Application} application - 被添加的应用实例
+   * @returns {Promise<void>}
+   * @author zhiwei.Wang
+   */
+  async afterAdd(application) {
+  }
+  /**
+   * 应用加载前触发的钩子函数
+   * @description 在应用开始加载前触发，可被子类覆盖以实现自定义预处理逻辑
+   * @returns {Promise<void>}
+   * @author zhiwei.Wang
+   */
+  async beforeLoad(application) {
+  }
+  /**
+   * 应用加载完成后触发的钩子函数
+   * @description 在应用完成加载后触发，可被子类覆盖以实现自定义后处理逻辑
+   * @returns {Promise<void>}
+   * @author zhiwei.Wang
+   */
+  async load(application) {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Application
+});

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

@@ -0,0 +1,88 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/applicationManager/index.tsx
+var applicationManager_exports = {};
+__export(applicationManager_exports, {
+  ApplicationManager: () => ApplicationManager
+});
+module.exports = __toCommonJS(applicationManager_exports);
+var import_application = require("./application");
+__reExport(applicationManager_exports, require("./application"), module.exports);
+var ApplicationManager = class {
+  constructor(applicationList = [], app) {
+    this.applicationList = applicationList;
+    this.app = app;
+    this.app = app;
+    if (applicationList == null ? void 0 : applicationList.length) {
+      this.init(applicationList);
+    }
+  }
+  applications = /* @__PURE__ */ new Map();
+  async init(applicationList) {
+    return new Promise(async (res, req) => {
+      applicationList.forEach(
+        async (application) => {
+          if (typeof application === "object") {
+            application = new import_application.Application(
+              application,
+              this.app
+            );
+          }
+          await this.add(application);
+        }
+      );
+      await this.load();
+      res(true);
+    });
+  }
+  async add(application) {
+    this.applications.set(application.name, application);
+    await application._afterAdd(application);
+  }
+  get(appName) {
+    let application = this.applications.get(appName);
+    return application;
+  }
+  remove(appName) {
+    this.applications.delete(appName);
+  }
+  async load() {
+    for (const application of this.applications.values()) {
+      await application._beforeLoad();
+    }
+    for (const application of this.applications.values()) {
+      await application._load();
+    }
+  }
+  /**
+   * 循环所有的应用, 找出所有的components进行渲染
+   * @returns
+   */
+  getAllComponents() {
+    return Array.from(this.applications.values()).flatMap(
+      (application) => Array.from(application.components.values())
+    ).filter((component) => component.autoRender).map((component) => component.Component);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationManager,
+  ...require("./application")
+});

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