@pisell/core 0.0.2

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,38 @@
+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 {
+  app;
+  storage;
+  store;
+  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/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
+});

package/lib/history/index.d.ts

@@ -0,0 +1,26 @@
+import { LocationDescriptor } from "history";
+import type { History as HistoryType } from "history";
+import { useHistory, useLocation, useParams } from "react-router-dom";
+import App from "../app";
+export interface HistoryOptions {
+    basename?: string;
+    interceptor?: (path: LocationDescriptor<unknown>, state: any, next: () => void) => void;
+}
+export declare class History {
+    instance: HistoryType<unknown>;
+    useHistory: typeof useHistory;
+    useLocation: typeof useLocation;
+    useParams: typeof useParams;
+    app: App;
+    interceptor?: (path: LocationDescriptor<unknown>, state: unknown, next: () => void) => void;
+    constructor(app: App, options?: HistoryOptions);
+    push: HistoryType["push"];
+    replace: HistoryType["replace"];
+    reload: () => void;
+    reloadTo: (path: string) => void;
+    externalPage: (path: string) => void;
+    goLogin: () => any;
+    getQuery: () => {
+        [k: string]: string;
+    };
+}

package/lib/history/index.js

@@ -0,0 +1,99 @@
+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 {
+  instance;
+  useHistory = import_react_router_dom.useHistory;
+  useLocation = import_react_router_dom.useLocation;
+  useParams = import_react_router_dom.useParams;
+  app;
+  interceptor;
+  constructor(app, options) {
+    this.app = app;
+    this.instance = (0, import_history.createBrowserHistory)({ basename: (options == null ? void 0 : options.basename) || "/" });
+    this.interceptor = options == null ? void 0 : options.interceptor;
+  }
+  push = (path, state) => {
+    if (this.interceptor) {
+      return this.interceptor(path, state, () => {
+        this.instance.push(path, state);
+      });
+    }
+    this.instance.push(path, state);
+  };
+  replace = (path, state) => {
+    if (this.interceptor) {
+      return this.interceptor(path, state, () => {
+        this.instance.replace(path, state);
+      });
+    }
+    this.instance.replace(path, state);
+  };
+  reload = () => {
+    window.location.reload();
+  };
+  reloadTo = (path) => {
+    if (this.interceptor) {
+      return this.interceptor(path, {}, () => {
+        window.location.href = path;
+      });
+    }
+    window.location.href = path;
+  };
+  externalPage = (path) => {
+    if (this.interceptor) {
+      return this.interceptor(path, {}, () => {
+        window.open(path);
+      });
+    }
+    window.open(path);
+  };
+  goLogin = () => {
+    var _a, _b;
+    return (_b = (_a = this.app.applicationManager.get("login")) == null ? void 0 : _a.runFunction) == null ? void 0 : _b.call(_a, "goLogin");
+  };
+  getQuery = () => {
+    try {
+      const search = this.instance.location.search;
+      const params = new URLSearchParams(search);
+      const obj = Object.fromEntries(params.entries());
+      return obj;
+    } catch (err) {
+      this.app.logger.addLog({
+        type: "error",
+        title: "获取query参数失败",
+        metadata: {
+          data: err
+        }
+      });
+    }
+    return {};
+  };
+};
+// 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 "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

@@ -0,0 +1,8 @@
+export { default as request } from './request';
+export { default as hooks } from './hooks';
+export { default as models } from './models';
+export { default as pubsub } from './pubsub';
+export { default as socket } from './socket';
+export * from './applicationManager';
+export * from './app';
+export * from './communicationManager';

package/lib/index.js

@@ -0,0 +1,58 @@
+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 __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-
+  // 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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  hooks: () => import_hooks.default,
+  models: () => import_models.default,
+  pubsub: () => import_pubsub.default,
+  request: () => import_request.default,
+  socket: () => import_socket.default
+});
+module.exports = __toCommonJS(src_exports);
+var import_request = __toESM(require("./request"));
+var import_hooks = __toESM(require("./hooks"));
+var import_models = __toESM(require("./models"));
+var import_pubsub = __toESM(require("./pubsub"));
+var import_socket = __toESM(require("./socket"));
+__reExport(src_exports, require("./applicationManager"), module.exports);
+__reExport(src_exports, require("./app"), module.exports);
+__reExport(src_exports, require("./communicationManager"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hooks,
+  models,
+  pubsub,
+  request,
+  socket,
+  ...require("./applicationManager"),
+  ...require("./app"),
+  ...require("./communicationManager")
+});