@pisell/core 1.0.0 → 1.0.1

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: any;
+    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 {
+}

package/lib/history/type.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/type.ts
+var type_exports = {};
+module.exports = __toCommonJS(type_exports);

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

@@ -0,0 +1,44 @@
+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/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  default: () => hooks_default
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_useLowCode = __toESM(require("./useLowCode"));
+var import_useDelayedValue = __toESM(require("./useDelayedValue"));
+var import_useStore = __toESM(require("./useStore"));
+var import_useDispatch = __toESM(require("./useDispatch"));
+var hooks_default = {
+  useLowCode: import_useLowCode.default,
+  useDelayedValue: import_useDelayedValue.default,
+  useStore: import_useStore.default,
+  useDispatch: import_useDispatch.default
+};

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

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

package/lib/hooks/useDelayedValue/index.js

@@ -0,0 +1,36 @@
+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/hooks/useDelayedValue/index.ts
+var useDelayedValue_exports = {};
+__export(useDelayedValue_exports, {
+  default: () => useDelayedValue_default
+});
+module.exports = __toCommonJS(useDelayedValue_exports);
+var import_react = require("react");
+function useDelayedValue(value, timeout = 200) {
+  const [delayedValue, setDelayedValue] = (0, import_react.useState)(value);
+  (0, import_react.useEffect)(() => {
+    const timer = setTimeout(() => {
+      setDelayedValue(value);
+    }, timeout);
+    return () => clearTimeout(timer);
+  }, [value, timeout]);
+  return delayedValue;
+}
+var useDelayedValue_default = useDelayedValue;

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

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

package/lib/hooks/useDispatch/index.js

@@ -0,0 +1,26 @@
+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/hooks/useDispatch/index.ts
+var useDispatch_exports = {};
+__export(useDispatch_exports, {
+  default: () => useDispatch_default
+});
+module.exports = __toCommonJS(useDispatch_exports);
+var import_react_redux = require("react-redux");
+var useDispatch_default = import_react_redux.useDispatch;

package/lib/hooks/useLowCode/index.d.ts

@@ -0,0 +1,13 @@
+export interface useLowCodeProps {
+    onChange: (e: any) => void;
+    onReady: (e: any) => void;
+}
+export interface useLowCodeResult {
+    lowcodeRef: {
+        onReady: (e: any) => void;
+        onChange: (e: any) => void;
+    };
+    setState: (values: any, callback?: any) => any;
+}
+declare const useLowCode: (props: Partial<useLowCodeProps>) => useLowCodeResult;
+export default useLowCode;

package/lib/hooks/useLowCode/index.js

@@ -0,0 +1,75 @@
+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/hooks/useLowCode/index.tsx
+var useLowCode_exports = {};
+__export(useLowCode_exports, {
+  default: () => useLowCode_default
+});
+module.exports = __toCommonJS(useLowCode_exports);
+var import_react = require("react");
+var useLowCode = (props) => {
+  const { onChange, onReady } = props;
+  const lowcodeRef = (0, import_react.useRef)(null);
+  const cacheState = (0, import_react.useRef)(null);
+  const _onReady = (e) => {
+    try {
+      lowcodeRef.current = e;
+      const val = onReady && onReady(e);
+      if (cacheState.current) {
+        _setState(cacheState.current.values, cacheState.current.callback);
+        cacheState.current = null;
+      }
+      return val;
+    } catch (err) {
+      console.error(err);
+    }
+  };
+  const _onChange = (e) => {
+    onChange && onChange(e);
+  };
+  const _setState = (values, callback) => {
+    try {
+      if (lowcodeRef.current) {
+        lowcodeRef.current.setState(values, callback);
+        return;
+      }
+      if (cacheState.current) {
+        cacheState.current = {
+          values: {
+            ...cacheState.current.values,
+            ...values
+          },
+          callback
+        };
+      } else {
+        cacheState.current = { values, callback };
+      }
+    } catch (err) {
+      console.error(err);
+    }
+  };
+  return {
+    lowcodeRef: {
+      onReady: _onReady,
+      onChange: _onChange
+    },
+    setState: _setState
+  };
+};
+var useLowCode_default = useLowCode;

package/lib/hooks/useStore/index.d.ts

@@ -0,0 +1,6 @@
+import { ModelsState } from "../../models";
+declare const useStore: <T extends "tasks" | "global", D extends keyof ModelsState[T]>(props: {
+    models: T;
+    key?: D | undefined;
+}) => D extends undefined ? ModelsState[T] : ModelsState[T][D];
+export default useStore;

package/lib/hooks/useStore/index.js

@@ -0,0 +1,33 @@
+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/hooks/useStore/index.ts
+var useStore_exports = {};
+__export(useStore_exports, {
+  default: () => useStore_default
+});
+module.exports = __toCommonJS(useStore_exports);
+var import_react_redux = require("react-redux");
+var useStore = (props) => {
+  const models = (0, import_react_redux.useSelector)((state) => state[props.models]);
+  if (props.key !== void 0) {
+    return models == null ? void 0 : models[props.key];
+  }
+  return models;
+};
+var useStore_default = useStore;

package/lib/index.d.ts

@@ -1,2 +1,8 @@
-export { default as date } from './date';
+export { default as storage } from './storage';
+export { default as request } from './request';
+export { default as hooks } from './hooks';
 export { default as locales } from './locales';
+export { default as models } from './models';
+export { default as pubsub } from './pubsub';
+export { default as socket } from './socket';
+export * from './app';

package/lib/index.js

@@ -16,6 +16,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 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-
@@ -29,14 +30,31 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  date: () => import_date.default,
-  locales: () => import_locales.default
+  hooks: () => import_hooks.default,
+  locales: () => import_locales.default,
+  models: () => import_models.default,
+  pubsub: () => import_pubsub.default,
+  request: () => import_request.default,
+  socket: () => import_socket.default,
+  storage: () => import_storage.default
 });
 module.exports = __toCommonJS(src_exports);
-var import_date = __toESM(require("./date"));
+var import_storage = __toESM(require("./storage"));
+var import_request = __toESM(require("./request"));
+var import_hooks = __toESM(require("./hooks"));
 var import_locales = __toESM(require("./locales"));
+var import_models = __toESM(require("./models"));
+var import_pubsub = __toESM(require("./pubsub"));
+var import_socket = __toESM(require("./socket"));
+__reExport(src_exports, require("./app"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  date,
-  locales
+  hooks,
+  locales,
+  models,
+  pubsub,
+  request,
+  socket,
+  storage,
+  ...require("./app")
 });

package/lib/indexDB/index.d.ts

@@ -0,0 +1,176 @@
+/**
+ * IndexDB 管理器模块
+ *
+ * 这个模块提供了对浏览器 IndexedDB 的简单封装，并在不支持 IndexedDB 的环境中
+ * 自动降级使用 localStorage 作为备选存储方案。
+ */
+/**
+ * 数据库配置选项接口
+ * @interface DBOptions
+ * @property {string} dbName - 数据库名称
+ * @property {number} version - 数据库版本号
+ * @property {Array} stores - 存储对象配置数组
+ * @property {string} stores[].name - 存储对象名称
+ * @property {string} stores[].keyPath - 主键路径
+ * @property {Array} [stores[].indexes] - 索引配置数组（可选）
+ * @property {string} stores[].indexes[].name - 索引名称
+ * @property {string} stores[].indexes[].keyPath - 索引键路径
+ * @property {IDBIndexParameters} [stores[].indexes[].options] - 索引选项（可选）
+ */
+export interface DBOptions {
+    dbName: string;
+    version: number;
+    stores: {
+        name: string;
+        keyPath: string;
+        indexes?: {
+            name: string;
+            keyPath: string;
+            options?: IDBIndexParameters;
+        }[];
+    }[];
+}
+/**
+ * IndexDB 管理器类
+ * 提供对 IndexedDB 的简单封装，支持自动降级到 localStorage
+ * @class IndexDBManager
+ */
+declare class IndexDBManager {
+    /**
+     * 检查环境是否支持 IndexedDB
+     * @returns {boolean} 是否支持 IndexedDB
+     * @private
+     */
+    private static isSupported;
+    private db;
+    private dbName;
+    private version;
+    private stores;
+    private useIndexDB;
+    /**
+     * 创建 IndexDBManager 实例
+     * @param {DBOptions} options - 数据库配置选项
+     */
+    constructor(options: DBOptions);
+    /**
+     * 初始化数据库连接
+     * 如果环境不支持 IndexedDB，将自动使用 localStorage
+     * @returns {Promise<boolean>} 连接是否成功
+     */
+    connect(): Promise<boolean>;
+    /**
+     * 生成用于 localStorage 的存储键
+     * @param {string} storeName - 存储对象名称
+     * @param {string|number} [key] - 可选的键值
+     * @returns {string} 格式化的存储键
+     * @private
+     */
+    private getStorageKey;
+    /**
+     * 添加数据到指定的存储对象
+     * @param {string} storeName - 存储对象名称
+     * @param {T} data - 要添加的数据
+     * @returns {Promise<T>} 添加的数据
+     * @template T
+     */
+    add<T>(storeName: string, data: T): Promise<T>;
+    /**
+     * 获取指定存储对象中的数据
+     * @param {string} storeName - 存储对象名称
+     * @param {string|number} key - 数据主键
+     * @returns {Promise<T|null>} 获取的数据，不存在则返回 null
+     * @template T
+     */
+    get<T>(storeName: string, key: string | number): Promise<T | null>;
+    /**
+     * 更新指定存储对象中的数据
+     * @param {string} storeName - 存储对象名称
+     * @param {T} data - 要更新的数据
+     * @returns {Promise<T>} 更新后的数据
+     * @template T
+     */
+    update<T>(storeName: string, data: T): Promise<T>;
+    /**
+     * 删除指定存储对象中的数据
+     * @param {string} storeName - 存储对象名称
+     * @param {string|number} key - 数据主键
+     * @returns {Promise<boolean>} 删除是否成功
+     */
+    delete(storeName: string, key: string | number): Promise<boolean>;
+    /**
+     * 获取指定存储对象中的所有数据
+     * @param {string} storeName - 存储对象名称
+     * @returns {Promise<T[]>} 数据数组
+     * @template T
+     */
+    getAll<T>(storeName: string): Promise<T[]>;
+    /**
+     * 清空指定存储对象中的所有数据
+     * @param {string} storeName - 存储对象名称
+     * @returns {Promise<boolean>} 清空是否成功
+     */
+    clear(storeName: string): Promise<boolean>;
+    /**
+     * 关闭数据库连接
+     * 在不再需要使用数据库时调用，释放资源
+     */
+    close(): void;
+    /**
+     * 获取当前使用的存储方式
+     * @returns {'indexDB'|'localStorage'} 当前使用的存储方式
+     */
+    getCurrentStorage(): 'indexDB' | 'localStorage';
+}
+/**
+ * 使用示例:
+ *
+ * // 1. 创建数据库配置
+ * const dbOptions: DBOptions = {
+ *   dbName: 'myApp',
+ *   version: 1,
+ *   stores: [
+ *     {
+ *       name: 'users',
+ *       keyPath: 'id',
+ *       indexes: [
+ *         { name: 'email', keyPath: 'email', options: { unique: true } }
+ *       ]
+ *     },
+ *     {
+ *       name: 'products',
+ *       keyPath: 'id'
+ *     }
+ *   ]
+ * };
+ *
+ * // 2. 创建并连接数据库
+ * const db = new IndexDBManager(dbOptions);
+ * await db.connect();
+ *
+ * // 3. 添加数据
+ * const user = { id: '1', name: '张三', email: 'zhangsan@example.com' };
+ * await db.add('users', user);
+ *
+ * // 4. 获取数据
+ * const retrievedUser = await db.get('users', '1');
+ *
+ * // 5. 更新数据
+ * user.name = '张三 (已更新)';
+ * await db.update('users', user);
+ *
+ * // 6. 获取所有数据
+ * const allUsers = await db.getAll('users');
+ *
+ * // 7. 删除数据
+ * await db.delete('users', '1');
+ *
+ * // 8. 清空存储对象
+ * await db.clear('users');
+ *
+ * // 9. 关闭数据库连接
+ * db.close();
+ *
+ * // 10. 检查当前使用的存储方式
+ * const storageType = db.getCurrentStorage(); // 'indexDB' 或 'localStorage'
+ */
+export default IndexDBManager;