@pisell/core 1.0.0 → 1.0.1

package/lib/applicationManager/application.d.ts

@@ -0,0 +1,50 @@
+import App from "../app";
+import { LoadLibraryByUrlParams } from "../locales/type";
+import { MenuItem } from "../menuManager/index";
+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;
+};
+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;
+};
+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;
+    constructor(options: ApplicationData, app: App);
+    afterAdd(application: Application): Promise<void>;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    initInterfaces(interfaces: ApplicationData["interfaces"]): void;
+    initFunctions(functions: ApplicationData["functions"]): void;
+    loadInterface(interfaceItem: ApplicationInterface): Promise<ApplicationInterface>;
+    setInterface(code: string, interfaceItem: ApplicationInterface): void;
+    setComponent(code: string, component: ApplicationInterface): void;
+    setFunction(code: string, functionItem: ApplicationInterface): void;
+    getInterface(code: string): ApplicationInterface | undefined;
+    getComponent(code: string): any;
+    getFunction(code: string): any;
+    runFunction(code: string, params?: any, ...args: any): any;
+}

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,29 @@
+export declare const store: {
+    getStore: () => import("../models").Store;
+    StoreProvider: typeof import("react-redux").Provider;
+    setConfig: (models: any[]) => void;
+};
+export declare const storage: {
+    setStorage: (key: string, value: string) => void;
+    getStorage: (key: string) => string | null;
+    removeStorage: (key: string) => void;
+    createKey: (key: string) => string;
+    setConfig: (newConfig: Partial<import("../storage/type").StorageConfig>) => void;
+    getConfig: () => import("../storage/type").StorageConfig;
+};
+declare const _default: {
+    store: {
+        getStore: () => import("../models").Store;
+        StoreProvider: typeof import("react-redux").Provider;
+        setConfig: (models: any[]) => void;
+    };
+    storage: {
+        setStorage: (key: string, value: string) => void;
+        getStorage: (key: string) => string | null;
+        removeStorage: (key: string) => void;
+        createKey: (key: string) => string;
+        setConfig: (newConfig: Partial<import("../storage/type").StorageConfig>) => void;
+        getConfig: () => import("../storage/type").StorageConfig;
+    };
+};
+export default _default;

package/lib/{date → data}/index.js

@@ -26,25 +26,24 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/date/index.ts
-var date_exports = {};
-__export(date_exports, {
-  default: () => date_default
+// src/data/index.ts
+var data_exports = {};
+__export(data_exports, {
+  default: () => data_default,
+  storage: () => storage,
+  store: () => store
 });
-module.exports = __toCommonJS(date_exports);
-var import_dayjs = __toESM(require("dayjs"));
-var import_config = require("./config");
-var format = (date, locale, format2) => {
-  const config = (0, import_config.getConfig)();
-  const _config = {
-    ...config,
-    locale: locale || config.locale,
-    format: format2 || config.defaultFormats[config.locale]
-  };
-  return (0, import_dayjs.default)(date).format(_config.defaultFormats[_config.locale]);
-};
-var date_default = {
-  getConfig: import_config.getConfig,
-  setConfig: import_config.setConfig,
-  format
+module.exports = __toCommonJS(data_exports);
+var import_models = __toESM(require("../models"));
+var import_storage = __toESM(require("../storage"));
+var store = import_models.default;
+var storage = import_storage.default;
+var data_default = {
+  store,
+  storage
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  storage,
+  store
+});

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