@pisell/core 1.0.0 → 1.0.2

package/lib/applicationManager/application.js

@@ -0,0 +1,110 @@
+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 __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 Application = class {
+  constructor(options, app) {
+    // 应用内的interface
+    this.interfaces = /* @__PURE__ */ new Map();
+    // 应用内的组件
+    this.components = /* @__PURE__ */ new Map();
+    // 应用内的函数, 比如跳转登录页面的方法
+    this.functions = /* @__PURE__ */ new Map();
+    this.options = options;
+    this.name = options.app_name;
+    this.app = app;
+    this.initInterfaces(options.interfaces);
+    this.initFunctions(options.functions);
+  }
+  async afterAdd(application) {
+    if (application.options.locales) {
+      this.app.locales.loadLibraryByUrl(application.options.locales);
+    }
+  }
+  async beforeLoad() {
+  }
+  async load() {
+    this.interfaces.forEach((item, key) => {
+      this.app.router.add(item.router, item);
+    });
+  }
+  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);
+      }
+    });
+  }
+  initFunctions(functions) {
+    (functions || []).forEach(async (functionItem) => {
+      this.setFunction(functionItem.function_code, functionItem);
+    });
+  }
+  async loadInterface(interfaceItem) {
+    if (interfaceItem.Component) {
+      return interfaceItem;
+    }
+    if (interfaceItem.page_type === "low_code") {
+    }
+    if (interfaceItem.page_type === "code") {
+    }
+    return interfaceItem;
+  }
+  setInterface(code, interfaceItem) {
+    this.interfaces.set(code, interfaceItem);
+  }
+  setComponent(code, component) {
+    this.components.set(code, component);
+  }
+  setFunction(code, functionItem) {
+    this.functions.set(code, functionItem);
+  }
+  getInterface(code) {
+    return this.interfaces.get(code);
+  }
+  getComponent(code) {
+    return this.components.get(code);
+  }
+  getFunction(code) {
+    return this.functions.get(code);
+  }
+  runFunction(code, params, ...args) {
+    var _a;
+    const _params = {
+      app: this.app,
+      ...params
+    };
+    return (_a = this.getFunction(code)) == null ? void 0 : _a.code(_params, ...args);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Application
+});

package/lib/applicationManager/index.d.ts

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

package/lib/applicationManager/index.js

@@ -0,0 +1,76 @@
+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 __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");
+var ApplicationManager = class {
+  constructor(applicationList = [], app) {
+    this.applicationList = applicationList;
+    this.app = app;
+    this.applications = /* @__PURE__ */ new Map();
+    this.app = app;
+    if (applicationList == null ? void 0 : applicationList.length) {
+      this.init(applicationList);
+    }
+  }
+  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 plugin of this.applications.values()) {
+      await plugin.beforeLoad();
+    }
+    for (const plugin of this.applications.values()) {
+      await plugin.load();
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApplicationManager
+});

package/lib/config.d.ts

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

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

@@ -0,0 +1,64 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cookie/index.ts
+var cookie_exports = {};
+__export(cookie_exports, {
+  default: () => cookie_default
+});
+module.exports = __toCommonJS(cookie_exports);
+function setCookie(name, value, domain) {
+  let expires = "";
+  let cookieDomain = "";
+  if (domain) {
+    cookieDomain = "; domain=" + domain;
+  }
+  document.cookie = name + "=" + (value || "") + expires + cookieDomain + "; path=/";
+}
+function getCookie(name) {
+  const nameEQ = name + "=";
+  const ca = document.cookie.split(";");
+  for (let i = 0; i < ca.length; i++) {
+    let c = ca[i];
+    while (c.charAt(0) === " ")
+      c = c.substring(1, c.length);
+    if (c.indexOf(nameEQ) === 0)
+      return c.substring(nameEQ.length, c.length);
+  }
+  return null;
+}
+function deleteCookie(name, domain) {
+  let cookieDomain = "";
+  if (domain) {
+    cookieDomain = "; domain=" + domain;
+  }
+  document.cookie = name + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC" + cookieDomain + "; path=/;";
+}
+function checkCookie(name) {
+  return getCookie(name) !== null;
+}
+function updateCookie(name, value, domain) {
+  setCookie(name, value, domain);
+}
+var cookie_default = {
+  setCookie,
+  getCookie,
+  deleteCookie,
+  checkCookie,
+  updateCookie
+};

package/lib/css/global.less

@@ -0,0 +1,73 @@
+.disabled-select {
+  -webkit-user-select: none;
+  /* Safari */
+  -moz-user-select: none;
+  /* Firefox */
+  -ms-user-select: none;
+  /* IE10+/Edge */
+  user-select: none;
+  /* Standard syntax */
+}
+
+ion-segment-button {
+  font-weight: 600;
+  --color-checked: var(--ion-color-primary);
+}
+
+.tab-bar {
+  //height: 78px;
+  --background: #fff;
+  padding: 10px 0;
+
+  .tab-bar-icon {
+    margin-bottom: 6px;
+    //font-size: 24px;
+  }
+
+  .tab-bar-name {
+    font-size: 12px;
+    font-style: normal;
+    font-weight: 600;
+    line-height: 18px;
+    /* 150% */
+  }
+}
+
+ul {
+  padding: 0;
+  margin: 0;
+}
+
+li {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+
+
+/*默认滚动条样式*/
+::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: #f1f1f1;
+  border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb {
+  background: #c1c1c1;
+  border-radius: 4px;
+
+  &:hover {
+    background: #a8a8a8;
+  }
+}
+
+html.plt-mobile ion-app {
+  -webkit-user-select: auto;
+  -moz-user-select: auto;
+  -ms-user-select: auto;
+  user-select: auto;
+}

package/lib/css/index.less

@@ -0,0 +1,31 @@
+/* Core CSS required for Ionic components to work properly */
+@import "@ionic/react/css/core.css";
+
+/* Basic CSS for apps built with Ionic */
+@import "@ionic/react/css/normalize.css";
+@import "@ionic/react/css/structure.css";
+@import "@ionic/react/css/typography.css";
+
+/* Optional CSS utils that can be commented out */
+@import "@ionic/react/css/padding.css";
+@import "@ionic/react/css/float-elements.css";
+@import "@ionic/react/css/text-alignment.css";
+@import "@ionic/react/css/text-transformation.css";
+@import "@ionic/react/css/flex-utils.css";
+@import "@ionic/react/css/display.css";
+
+/**
+ * Ionic Dark Mode
+ * -----------------------------------------------------
+ * For more info, please see:
+ * https://ionicframework.com/docs/theming/dark-mode
+ */
+
+/* @import '@ionic/react/css/palettes/dark.always.css'; */
+/* @import '@ionic/react/css/palettes/dark.class.css'; */
+// @import "@ionic/react/css/palettes/dark.system.css";
+
+/* Theme variables */
+@import "./variables.css";
+
+@import "./global.less";

package/lib/css/variables.css

@@ -0,0 +1,84 @@
+/* For information on how to create your own theme, please see:
+http://ionicframework.com/docs/theming/ */
+
+:root {
+  --ion-platform: ios;
+  --ion-color-primary: #5D3F9F;
+  --ion-color-primary-rgb: 93,63,159;
+  --ion-color-primary-contrast: #ffffff;
+  --ion-color-primary-contrast-rgb: 255,255,255;
+  --ion-color-primary-shade: #52378c;
+  --ion-color-primary-tint: #6d52a9;
+
+  --ion-color-secondary: #7f56da;
+  --ion-color-secondary-rgb: 127,86,218;
+  --ion-color-secondary-contrast: #ffffff;
+  --ion-color-secondary-contrast-rgb: 255,255,255;
+  --ion-color-secondary-shade: #704cc0;
+  --ion-color-secondary-tint: #8c67de;
+
+  --ion-color-tertiary: #eee5ff;
+  --ion-color-tertiary-rgb: 238,229,255;
+  --ion-color-tertiary-contrast: #000000;
+  --ion-color-tertiary-contrast-rgb: 0,0,0;
+  --ion-color-tertiary-shade: #d1cae0;
+  --ion-color-tertiary-tint: #f0e8ff;
+
+  /** success **/
+  --ion-color-success: #2dd36f;
+  --ion-color-success-rgb: 45, 211, 111;
+  --ion-color-success-contrast: #ffffff;
+  --ion-color-success-contrast-rgb: 255, 255, 255;
+  --ion-color-success-shade: #28ba62;
+  --ion-color-success-tint: #42d77d;
+
+  /** warning **/
+  --ion-color-warning: #ffc409;
+  --ion-color-warning-rgb: 255, 196, 9;
+  --ion-color-warning-contrast: #000000;
+  --ion-color-warning-contrast-rgb: 0, 0, 0;
+  --ion-color-warning-shade: #e0ac08;
+  --ion-color-warning-tint: #ffca22;
+
+  /** danger **/
+  --ion-color-danger: #eb445a;
+  --ion-color-danger-rgb: 235, 68, 90;
+  --ion-color-danger-contrast: #ffffff;
+  --ion-color-danger-contrast-rgb: 255, 255, 255;
+  --ion-color-danger-shade: #cf3c4f;
+  --ion-color-danger-tint: #ed576b;
+
+  /** dark **/
+  --ion-color-dark: #222428;
+  --ion-color-dark-rgb: 34, 36, 40;
+  --ion-color-dark-contrast: #ffffff;
+  --ion-color-dark-contrast-rgb: 255, 255, 255;
+  --ion-color-dark-shade: #1e2023;
+  --ion-color-dark-tint: #383a3e;
+
+  /** medium **/
+  --ion-color-medium: #92949c;
+  --ion-color-medium-rgb: 146, 148, 156;
+  --ion-color-medium-contrast: #ffffff;
+  --ion-color-medium-contrast-rgb: 255, 255, 255;
+  --ion-color-medium-shade: #808289;
+  --ion-color-medium-tint: #9d9fa6;
+
+  /** light **/
+  --ion-color-light: #f4f5f8;
+  --ion-color-light-rgb: 244, 245, 248;
+  --ion-color-light-contrast: #000000;
+  --ion-color-light-contrast-rgb: 0, 0, 0;
+  --ion-color-light-shade: #d7d8da;
+  --ion-color-light-tint: #f5f6f9;
+
+  --ion-toolbar-background: #ffffff;
+
+
+  --theme-color: var(--ion-color-primary);
+
+  --ion-text-color: var(--ion-color-dark);
+
+  --theme-a-color: #7F56DA;
+
+}

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

@@ -0,0 +1,35 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data/index.ts
+var data_exports = {};
+__export(data_exports, {
+  Data: () => Data
+});
+module.exports = __toCommonJS(data_exports);
+var Data = class {
+  constructor(app) {
+    this.app = app;
+    this.storage = app.storage;
+    this.store = app.models;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Data
+});

package/lib/{locales → history}/config.d.ts

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

package/lib/history/config.js

@@ -0,0 +1,41 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/history/config.ts
+var config_exports = {};
+__export(config_exports, {
+  defaultConfig: () => defaultConfig,
+  getConfig: () => getConfig,
+  setConfig: () => setConfig
+});
+module.exports = __toCommonJS(config_exports);
+var defaultConfig = {};
+var config = {
+  ...defaultConfig
+};
+var setConfig = (newConfig) => {
+  config = { ...config, ...newConfig };
+  return config;
+};
+var getConfig = () => config;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defaultConfig,
+  getConfig,
+  setConfig
+});

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

@@ -0,0 +1,58 @@
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/history/index.ts
+var history_exports = {};
+__export(history_exports, {
+  History: () => History
+});
+module.exports = __toCommonJS(history_exports);
+var import_history = require("history");
+var import_react_router_dom = require("react-router-dom");
+var History = class {
+  constructor(app, options) {
+    this.useHistory = import_react_router_dom.useHistory;
+    this.useLocation = import_react_router_dom.useLocation;
+    this.useParams = import_react_router_dom.useParams;
+    this.push = (path, state) => {
+      this.instance.push(path, state);
+    };
+    this.replace = (path, state) => {
+      this.instance.replace(path, state);
+    };
+    this.reload = () => {
+      window.location.reload();
+    };
+    this.reloadTo = (path) => {
+      window.location.href = path;
+    };
+    this.externalPage = (path) => {
+      window.open(path);
+    };
+    this.goLogin = () => {
+      var _a, _b;
+      return (_b = (_a = this.app.applicationManager.get("login")) == null ? void 0 : _a.runFunction) == null ? void 0 : _b.call(_a, "goLogin");
+    };
+    this.app = app;
+    this.instance = (0, import_history.createBrowserHistory)({ basename: (options == null ? void 0 : options.basename) || "/" });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  History
+});

package/lib/history/type.d.ts

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