@ibiz-template/core 0.0.3-beta.5 → 0.0.4-beta.2

package/dist/index.esm.js

@@ -0,0 +1,2207 @@
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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
+));
+
+// ../../node_modules/.pnpm/loglevel@1.8.1/node_modules/loglevel/lib/loglevel.js
+var require_loglevel = __commonJS({
+  "../../node_modules/.pnpm/loglevel@1.8.1/node_modules/loglevel/lib/loglevel.js"(exports, module) {
+    (function(root, definition) {
+      "use strict";
+      if (typeof define === "function" && define.amd) {
+        define(definition);
+      } else if (typeof module === "object" && module.exports) {
+        module.exports = definition();
+      } else {
+        root.log = definition();
+      }
+    })(exports, function() {
+      "use strict";
+      var noop = function() {
+      };
+      var undefinedType = "undefined";
+      var isIE = typeof window !== undefinedType && typeof window.navigator !== undefinedType && /Trident\/|MSIE /.test(window.navigator.userAgent);
+      var logMethods = [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ];
+      function bindMethod(obj, methodName) {
+        var method = obj[methodName];
+        if (typeof method.bind === "function") {
+          return method.bind(obj);
+        } else {
+          try {
+            return Function.prototype.bind.call(method, obj);
+          } catch (e) {
+            return function() {
+              return Function.prototype.apply.apply(method, [obj, arguments]);
+            };
+          }
+        }
+      }
+      function traceForIE() {
+        if (console.log) {
+          if (console.log.apply) {
+            console.log.apply(console, arguments);
+          } else {
+            Function.prototype.apply.apply(console.log, [console, arguments]);
+          }
+        }
+        if (console.trace)
+          console.trace();
+      }
+      function realMethod(methodName) {
+        if (methodName === "debug") {
+          methodName = "log";
+        }
+        if (typeof console === undefinedType) {
+          return false;
+        } else if (methodName === "trace" && isIE) {
+          return traceForIE;
+        } else if (console[methodName] !== void 0) {
+          return bindMethod(console, methodName);
+        } else if (console.log !== void 0) {
+          return bindMethod(console, "log");
+        } else {
+          return noop;
+        }
+      }
+      function replaceLoggingMethods(level, loggerName) {
+        for (var i = 0; i < logMethods.length; i++) {
+          var methodName = logMethods[i];
+          this[methodName] = i < level ? noop : this.methodFactory(methodName, level, loggerName);
+        }
+        this.log = this.debug;
+      }
+      function enableLoggingWhenConsoleArrives(methodName, level, loggerName) {
+        return function() {
+          if (typeof console !== undefinedType) {
+            replaceLoggingMethods.call(this, level, loggerName);
+            this[methodName].apply(this, arguments);
+          }
+        };
+      }
+      function defaultMethodFactory(methodName, level, loggerName) {
+        return realMethod(methodName) || enableLoggingWhenConsoleArrives.apply(this, arguments);
+      }
+      function Logger2(name, defaultLevel, factory) {
+        var self = this;
+        var currentLevel;
+        defaultLevel = defaultLevel == null ? "WARN" : defaultLevel;
+        var storageKey = "loglevel";
+        if (typeof name === "string") {
+          storageKey += ":" + name;
+        } else if (typeof name === "symbol") {
+          storageKey = void 0;
+        }
+        function persistLevelIfPossible(levelNum) {
+          var levelName = (logMethods[levelNum] || "silent").toUpperCase();
+          if (typeof window === undefinedType || !storageKey)
+            return;
+          try {
+            window.localStorage[storageKey] = levelName;
+            return;
+          } catch (ignore) {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=" + levelName + ";";
+          } catch (ignore) {
+          }
+        }
+        function getPersistedLevel() {
+          var storedLevel;
+          if (typeof window === undefinedType || !storageKey)
+            return;
+          try {
+            storedLevel = window.localStorage[storageKey];
+          } catch (ignore) {
+          }
+          if (typeof storedLevel === undefinedType) {
+            try {
+              var cookie = window.document.cookie;
+              var location = cookie.indexOf(
+                encodeURIComponent(storageKey) + "="
+              );
+              if (location !== -1) {
+                storedLevel = /^([^;]+)/.exec(cookie.slice(location))[1];
+              }
+            } catch (ignore) {
+            }
+          }
+          if (self.levels[storedLevel] === void 0) {
+            storedLevel = void 0;
+          }
+          return storedLevel;
+        }
+        function clearPersistedLevel() {
+          if (typeof window === undefinedType || !storageKey)
+            return;
+          try {
+            window.localStorage.removeItem(storageKey);
+            return;
+          } catch (ignore) {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(storageKey) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch (ignore) {
+          }
+        }
+        self.name = name;
+        self.levels = {
+          "TRACE": 0,
+          "DEBUG": 1,
+          "INFO": 2,
+          "WARN": 3,
+          "ERROR": 4,
+          "SILENT": 5
+        };
+        self.methodFactory = factory || defaultMethodFactory;
+        self.getLevel = function() {
+          return currentLevel;
+        };
+        self.setLevel = function(level, persist) {
+          if (typeof level === "string" && self.levels[level.toUpperCase()] !== void 0) {
+            level = self.levels[level.toUpperCase()];
+          }
+          if (typeof level === "number" && level >= 0 && level <= self.levels.SILENT) {
+            currentLevel = level;
+            if (persist !== false) {
+              persistLevelIfPossible(level);
+            }
+            replaceLoggingMethods.call(self, level, name);
+            if (typeof console === undefinedType && level < self.levels.SILENT) {
+              return "No console available for logging";
+            }
+          } else {
+            throw "log.setLevel() called with invalid level: " + level;
+          }
+        };
+        self.setDefaultLevel = function(level) {
+          defaultLevel = level;
+          if (!getPersistedLevel()) {
+            self.setLevel(level, false);
+          }
+        };
+        self.resetLevel = function() {
+          self.setLevel(defaultLevel, false);
+          clearPersistedLevel();
+        };
+        self.enableAll = function(persist) {
+          self.setLevel(self.levels.TRACE, persist);
+        };
+        self.disableAll = function(persist) {
+          self.setLevel(self.levels.SILENT, persist);
+        };
+        var initialLevel = getPersistedLevel();
+        if (initialLevel == null) {
+          initialLevel = defaultLevel;
+        }
+        self.setLevel(initialLevel, false);
+      }
+      var defaultLogger = new Logger2();
+      var _loggersByName = {};
+      defaultLogger.getLogger = function getLogger(name) {
+        if (typeof name !== "symbol" && typeof name !== "string" || name === "") {
+          throw new TypeError("You must supply a name when creating a logger.");
+        }
+        var logger = _loggersByName[name];
+        if (!logger) {
+          logger = _loggersByName[name] = new Logger2(
+            name,
+            defaultLogger.getLevel(),
+            defaultLogger.methodFactory
+          );
+        }
+        return logger;
+      };
+      var _log = typeof window !== undefinedType ? window.log : void 0;
+      defaultLogger.noConflict = function() {
+        if (typeof window !== undefinedType && window.log === defaultLogger) {
+          window.log = _log;
+        }
+        return defaultLogger;
+      };
+      defaultLogger.getLoggers = function getLoggers() {
+        return _loggersByName;
+      };
+      defaultLogger["default"] = defaultLogger;
+      return defaultLogger;
+    });
+  }
+});
+
+// src/command/utils/linked-list.ts
+var _Node = class {
+  constructor(element) {
+    this.element = element;
+    this.next = _Node.Undefined;
+    this.prev = _Node.Undefined;
+  }
+};
+var Node = _Node;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Node.Undefined = new _Node(void 0);
+var LinkedList = class {
+  constructor() {
+    this._first = Node.Undefined;
+    this._last = Node.Undefined;
+    this._size = 0;
+  }
+  get size() {
+    return this._size;
+  }
+  isEmpty() {
+    return this._first === Node.Undefined;
+  }
+  clear() {
+    let node = this._first;
+    while (node !== Node.Undefined) {
+      const { next } = node;
+      node.prev = Node.Undefined;
+      node.next = Node.Undefined;
+      node = next;
+    }
+    this._first = Node.Undefined;
+    this._last = Node.Undefined;
+    this._size = 0;
+  }
+  unshift(element) {
+    return this._insert(element, false);
+  }
+  push(element) {
+    return this._insert(element, true);
+  }
+  _insert(element, atTheEnd) {
+    const newNode = new Node(element);
+    if (this._first === Node.Undefined) {
+      this._first = newNode;
+      this._last = newNode;
+    } else if (atTheEnd) {
+      const oldLast = this._last;
+      this._last = newNode;
+      newNode.prev = oldLast;
+      oldLast.next = newNode;
+    } else {
+      const oldFirst = this._first;
+      this._first = newNode;
+      newNode.next = oldFirst;
+      oldFirst.prev = newNode;
+    }
+    this._size += 1;
+    let didRemove = false;
+    return () => {
+      if (!didRemove) {
+        didRemove = true;
+        this._remove(newNode);
+      }
+    };
+  }
+  shift() {
+    if (this._first === Node.Undefined) {
+      return void 0;
+    }
+    const res = this._first.element;
+    this._remove(this._first);
+    return res;
+  }
+  pop() {
+    if (this._last === Node.Undefined) {
+      return void 0;
+    }
+    const res = this._last.element;
+    this._remove(this._last);
+    return res;
+  }
+  _remove(node) {
+    if (node.prev !== Node.Undefined && node.next !== Node.Undefined) {
+      const anchor = node.prev;
+      anchor.next = node.next;
+      node.next.prev = anchor;
+    } else if (node.prev === Node.Undefined && node.next === Node.Undefined) {
+      this._first = Node.Undefined;
+      this._last = Node.Undefined;
+    } else if (node.next === Node.Undefined) {
+      this._last = this._last.prev;
+      this._last.next = Node.Undefined;
+    } else if (node.prev === Node.Undefined) {
+      this._first = this._first.next;
+      this._first.prev = Node.Undefined;
+    }
+    this._size -= 1;
+  }
+  *[Symbol.iterator]() {
+    let node = this._first;
+    while (node !== Node.Undefined) {
+      yield node.element;
+      node = node.next;
+    }
+  }
+};
+
+// src/command/utils/util.ts
+function once(fn) {
+  const _this = this;
+  let didCall = false;
+  let result;
+  return function() {
+    if (didCall) {
+      return result;
+    }
+    didCall = true;
+    result = fn.apply(_this, arguments);
+    return result;
+  };
+}
+function toDisposable(fn) {
+  const self = {
+    dispose: once(() => {
+      fn();
+    })
+  };
+  return self;
+}
+function debounce(func, wait, immediate) {
+  let timer;
+  return function(...args) {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    if (immediate) {
+      const callNow = !timer;
+      timer = setTimeout(() => {
+        timer = null;
+      }, wait);
+      if (callNow) {
+        func.apply(this, args);
+      }
+    } else {
+      timer = setTimeout(() => {
+        func.apply(this, args);
+      }, wait);
+    }
+  };
+}
+function throttle(fn, wait) {
+  let timer = null;
+  return function(...args) {
+    if (!timer) {
+      timer = setTimeout(() => {
+        fn.apply(this, args);
+        timer = null;
+      }, wait);
+    }
+  };
+}
+
+// src/command/command-register.ts
+var CommandsRegistry = class {
+  constructor() {
+    /**
+     * 已经注册的所有指令
+     *
+     * @author chitanda
+     * @date 2022-07-21 15:07:47
+     * @private
+     */
+    this.commands = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 注册指令
+   *
+   * @author chitanda
+   * @date 2022-06-27 13:06:31
+   * @param {(string | ICommand)} idOrCommand
+   * @param {ICommandHandler} [handler]
+   * @return {*}  {IDisposable}
+   */
+  registerCommand(idOrCommand, handler, opts) {
+    if (!idOrCommand) {
+      throw new Error(`invalid command`);
+    }
+    if (typeof idOrCommand === "string") {
+      if (!handler) {
+        throw new Error(`invalid command`);
+      }
+      return this.registerCommand({ id: idOrCommand, handler, opts });
+    }
+    const { id } = idOrCommand;
+    let commands2 = this.commands.get(id);
+    if (!commands2) {
+      commands2 = new LinkedList();
+      this.commands.set(id, commands2);
+    }
+    const removeFn = commands2.unshift(idOrCommand);
+    const ret = toDisposable(() => {
+      removeFn();
+      const command = this.commands.get(id);
+      if (command == null ? void 0 : command.isEmpty()) {
+        this.commands.delete(id);
+      }
+    });
+    return ret;
+  }
+  /**
+   * 指令是否已经注册
+   *
+   * @author chitanda
+   * @date 2022-07-21 15:07:58
+   * @param {string} id
+   * @return {*}  {boolean}
+   */
+  hasCommand(id) {
+    return this.commands.has(id);
+  }
+  /**
+   * 查找指令
+   *
+   * @author chitanda
+   * @date 2022-07-21 16:07:12
+   * @param {string} id
+   * @return {*}  {(ICommand | undefined)}
+   */
+  getCommand(id) {
+    const list = this.commands.get(id);
+    if (!list || list.isEmpty()) {
+      return void 0;
+    }
+    return list[Symbol.iterator]().next().value;
+  }
+  /**
+   * 获取所有指令
+   *
+   * @author chitanda
+   * @date 2022-07-21 16:07:20
+   * @return {*}  {ICommandsMap}
+   */
+  getCommands() {
+    const result = /* @__PURE__ */ new Map();
+    const keys = this.commands.keys();
+    for (const key of keys) {
+      const command = this.getCommand(key);
+      if (command) {
+        result.set(key, command);
+      }
+    }
+    return result;
+  }
+  /**
+   * 获取指令配置参数
+   *
+   * @author chitanda
+   * @date 2022-07-21 16:07:27
+   * @param {string} id
+   * @return {*}  {(ICommandOption | undefined)}
+   */
+  getCommandOpt(id) {
+    const cmd = this.getCommand(id);
+    return cmd == null ? void 0 : cmd.opts;
+  }
+};
+
+// src/command/command.ts
+var CommandController = class {
+  constructor() {
+    this.commandRegister = new CommandsRegistry();
+  }
+  /**
+   * 注册指令
+   *
+   * @author chitanda
+   * @date 2022-06-28 19:06:45
+   * @param {string} id
+   * @param {ICommandHandler} handler
+   * @param {ICommandOption} [opts]
+   * @return {*}  {IDisposable}
+   */
+  register(id, handler, opts) {
+    return this.commandRegister.registerCommand(id, handler, opts);
+  }
+  /**
+   * 执行指令
+   *
+   * @author chitanda
+   * @date 2022-06-28 19:06:38
+   * @template T
+   * @param {string} id
+   * @param {...unknown[]} args
+   * @return {*}  {Promise<T>}
+   */
+  async execute(id, ...args) {
+    const command = this.commandRegister.getCommand(id);
+    if (command) {
+      return command.handler(...args);
+    }
+    throw new Error(`\u672A\u6CE8\u518C\u6307\u4EE4: ${id}\uFF0C\u8BF7\u5148\u6CE8\u518C\u6307\u4EE4`);
+  }
+  /**
+   * 判断指令是否存在，可直接抛出异常
+   *
+   * @author chitanda
+   * @date 2022-06-28 19:06:11
+   * @param {string} id
+   * @param {boolean} [err]
+   * @return {*}  {boolean}
+   */
+  hasCommand(id, err) {
+    const bol = !!this.commandRegister.hasCommand(id);
+    if (err === true && bol === true) {
+      throw new Error(`\u672A\u6CE8\u518C\u6307\u4EE4: ${id}\uFF0C\u8BF7\u5148\u6CE8\u518C\u6307\u4EE4`);
+    }
+    return bol;
+  }
+  /**
+   * 获取指令配置参数
+   *
+   * @author chitanda
+   * @date 2022-07-21 17:07:11
+   * @param {string} id
+   * @return {*}  {(ICommandOption | undefined)}
+   */
+  getCommandOpts(id) {
+    return this.commandRegister.getCommandOpt(id);
+  }
+};
+
+// src/command/index.ts
+var commands = new CommandController();
+
+// src/constant/core/core.ts
+var CoreConst = class {
+};
+/**
+ * 默认模型服务标识
+ */
+CoreConst.DEFAULT_MODEL_SERVICE_TAG = "default";
+/**
+ * 访问令牌标识
+ *
+ * @author chitanda
+ * @date 2022-07-20 15:07:28
+ * @static
+ */
+CoreConst.TOKEN = "access_token";
+/**
+ * 访问令牌标识过期时间
+ *
+ * @author lxm
+ * @date 2023-02-13 07:11:33
+ * @static
+ * @memberof CoreConst
+ */
+CoreConst.TOKEN_EXPIRES = "access_token_expires";
+
+// src/constant/util/util.ts
+var NOOP = () => {
+};
+
+// src/constant/http-status-message/http-status-message.ts
+var HttpStatusMessageConst = {
+  200: "\u670D\u52A1\u5668\u6210\u529F\u8FD4\u56DE\u8BF7\u6C42\u7684\u6570\u636E\u3002",
+  201: "\u65B0\u5EFA\u6216\u4FEE\u6539\u6570\u636E\u6210\u529F\u3002",
+  202: "\u4E00\u4E2A\u8BF7\u6C42\u5DF2\u7ECF\u8FDB\u5165\u540E\u53F0\u6392\u961F\uFF08\u5F02\u6B65\u4EFB\u52A1\uFF09\u3002",
+  204: "\u5220\u9664\u6570\u636E\u6210\u529F\u3002",
+  400: "\u53D1\u51FA\u7684\u8BF7\u6C42\u6709\u9519\u8BEF\uFF0C\u670D\u52A1\u5668\u6CA1\u6709\u8FDB\u884C\u65B0\u5EFA\u6216\u4FEE\u6539\u6570\u636E\u7684\u64CD\u4F5C\u3002",
+  401: "\u7528\u6237\u6CA1\u6709\u6743\u9650\uFF08\u4EE4\u724C\u3001\u7528\u6237\u540D\u3001\u5BC6\u7801\u9519\u8BEF\uFF09\u3002",
+  403: "\u7528\u6237\u5F97\u5230\u6388\u6743\uFF0C\u4F46\u662F\u8BBF\u95EE\u662F\u88AB\u7981\u6B62\u7684\u3002",
+  404: "\u53D1\u51FA\u7684\u8BF7\u6C42\u9488\u5BF9\u7684\u662F\u4E0D\u5B58\u5728\u7684\u8BB0\u5F55\uFF0C\u670D\u52A1\u5668\u6CA1\u6709\u8FDB\u884C\u64CD\u4F5C\u3002",
+  406: "\u8BF7\u6C42\u7684\u683C\u5F0F\u4E0D\u53EF\u5F97\u3002",
+  410: "\u8BF7\u6C42\u7684\u8D44\u6E90\u88AB\u6C38\u4E45\u5220\u9664\uFF0C\u4E14\u4E0D\u4F1A\u518D\u5F97\u5230\u7684\u3002",
+  422: "\u5F53\u521B\u5EFA\u4E00\u4E2A\u5BF9\u8C61\u65F6\uFF0C\u53D1\u751F\u4E00\u4E2A\u9A8C\u8BC1\u9519\u8BEF\u3002",
+  500: "\u670D\u52A1\u5668\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u5668\u3002",
+  502: "\u7F51\u5173\u9519\u8BEF\u3002",
+  503: "\u670D\u52A1\u4E0D\u53EF\u7528\uFF0C\u670D\u52A1\u5668\u6682\u65F6\u8FC7\u8F7D\u6216\u7EF4\u62A4\u3002",
+  504: "\u7F51\u5173\u8D85\u65F6\u3002"
+};
+
+// src/constant/login-mode/login-mode.ts
+var LoginMode = /* @__PURE__ */ ((LoginMode2) => {
+  LoginMode2["DEFAULT"] = "DEFAULT";
+  LoginMode2["CUSTOM"] = "CUSTOM";
+  LoginMode2["CAS"] = "CAS";
+  return LoginMode2;
+})(LoginMode || {});
+
+// src/constant/menu-permission-mode/menu-permission-mode.ts
+var MenuPermissionMode = /* @__PURE__ */ ((MenuPermissionMode2) => {
+  MenuPermissionMode2["MIXIN"] = "MIXIN";
+  MenuPermissionMode2["RESOURCE"] = "RESOURCE";
+  MenuPermissionMode2["RT"] = "RT";
+  return MenuPermissionMode2;
+})(MenuPermissionMode || {});
+
+// src/context/index.ts
+import { clone } from "ramda";
+var IBizContext = class {
+  /**
+   * Creates an instance of IBizContext.
+   *
+   * @author chitanda
+   * @date 2022-07-14 10:07:15
+   * @param {IDatum} [context={}] 自身的上下文
+   * @param {IContext} [parent]
+   */
+  // eslint-disable-next-line default-param-last
+  constructor(context = {}, parent) {
+    Object.defineProperty(this, "_associationContext", {
+      enumerable: false,
+      value: []
+    });
+    if (parent) {
+      const self = this;
+      Object.defineProperty(this, "_parent", {
+        enumerable: false,
+        writable: true,
+        value: parent
+      });
+      Object.defineProperty(this, "_context", {
+        enumerable: false,
+        writable: true,
+        value: {}
+      });
+      const properties = {};
+      const keys = Object.keys(parent);
+      keys.forEach((key) => {
+        properties[key] = {
+          enumerable: true,
+          set(val) {
+            if (val == null) {
+              self._context[key] = null;
+            } else {
+              self._context[key] = val;
+            }
+          },
+          get() {
+            if (self._context[key] !== void 0) {
+              return self._context[key];
+            }
+            return parent[key];
+          }
+        };
+      });
+      Object.defineProperties(this, properties);
+    }
+    Object.assign(this, context);
+  }
+  /**
+   * 返回自身的上下文，独有的和与父有差异的。
+   *
+   * @author lxm
+   * @date 2022-12-08 17:12:26
+   * @returns {*}  {IDatum}
+   */
+  getOwnContext() {
+    const result = {};
+    Object.keys(this).forEach((key) => {
+      if (!this._parent || !Object.prototype.hasOwnProperty.call(this._parent, key) || Object.prototype.hasOwnProperty.call(this._context, key)) {
+        result[key] = this[key];
+      }
+    });
+    return result;
+  }
+  /**
+   * 销毁当前上下文对象
+   *
+   * @author chitanda
+   * @date 2023-03-13 15:03:04
+   */
+  destroy() {
+    this._parent = void 0;
+    this._context = {};
+    this._associationContext.forEach((item) => {
+      item.destroy();
+    });
+  }
+  /**
+   * 在非视图中，需要断开视图上下文联系时。只能使用 clone 创建新的局部上下文
+   *
+   * @author chitanda
+   * @date 2023-03-13 16:03:13
+   * @return {*}  {IBizContext}
+   */
+  clone() {
+    const newContext = new IBizContext(
+      clone(this.getOwnContext()),
+      this._parent
+    );
+    this._associationContext.push(newContext);
+    return newContext;
+  }
+  /**
+   * 上下文只有在视图初始化时，调用 create 方法
+   *
+   * @author chitanda
+   * @date 2023-03-13 16:03:32
+   * @static
+   * @param {IDatum} [context]
+   * @param {IContext} [parent]
+   * @return {*}  {IContext}
+   */
+  static create(context, parent) {
+    return new IBizContext(context, parent);
+  }
+};
+
+// src/environment/environment.ts
+var Environment = {
+  dev: false,
+  hub: true,
+  logLevel: "ERROR",
+  baseUrl: "/api",
+  appId: "",
+  pluginBaseUrl: "./plugins",
+  remoteModelUrl: "/remotemodel",
+  assetsUrl: "./assets",
+  dcSystem: "",
+  downloadFileUrl: "/ibizutil/download",
+  uploadFileUrl: "/ibizutil/upload",
+  casLoginUrl: "",
+  loginMode: "DEFAULT" /* DEFAULT */,
+  menuPermissionMode: "MIXIN" /* MIXIN */,
+  enablePermission: true,
+  routePlaceholder: "-",
+  enableWfAllHistory: false
+};
+
+// src/error/http-error/http-error.ts
+var HttpError = class {
+  constructor(err) {
+    this.name = "HttpError";
+    const res = err.response;
+    this.response = err.response;
+    if (res) {
+      if (res.data) {
+        this.message = res.data.message;
+      } else {
+        this.message = res.statusText;
+      }
+      if (!this.message) {
+        this.message = "\u7F51\u7EDC\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5!";
+      }
+      this.status = res.status;
+    } else {
+      this.message = err.message;
+      this.status = 500;
+    }
+  }
+};
+
+// src/error/model-error/model-error.ts
+var ModelError = class extends Error {
+  /**
+   * Creates an instance of ModelError.
+   *
+   * @author chitanda
+   * @date 2022-08-30 16:08:38
+   * @param {IModelObject} model 模板未支持的模型
+   * @param {string} [msg]
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(model, msg) {
+    super(`\u300C${model.id}\u300D\u6A21\u578B${msg ? `\uFF1A ${msg}` : ""}`);
+    this.model = model;
+    this.name = "\u672A\u652F\u6301\u7684\u6A21\u578B";
+  }
+};
+
+// src/error/runtime-error/runtime-error.ts
+var RuntimeError = class {
+  constructor(message) {
+    this.message = message;
+    this.name = "Runtime Error";
+  }
+};
+
+// src/error/runtime-model-error/runtime-model-error.ts
+var RuntimeModelError = class extends Error {
+  /**
+   * Creates an instance of DefectModelError.
+   *
+   * @author chitanda
+   * @date 2022-08-30 16:08:58
+   * @param {IModelObject} model 丢失配置的模型
+   * @param {string} [msg] 缺失配置描述
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(model, msg) {
+    super(`\u300C${model.id}\u300D\u6A21\u578B${msg ? `\uFF1A ${msg}` : ""}`);
+    this.model = model;
+    this.name = "\u6A21\u578B\u914D\u7F6E\u7F3A\u5931";
+  }
+};
+
+// src/utils/util/util.ts
+import { debounce as debounce2 } from "lodash-es";
+import { getCookie } from "qx-util";
+function getToken() {
+  return getCookie(CoreConst.TOKEN);
+}
+function isOverlap(arr1, arr2) {
+  const newArr = Array.from(/* @__PURE__ */ new Set([...arr1, ...arr2]));
+  return newArr.length !== arr1.length + arr2.length;
+}
+function debounceAndMerge(func, mergeFunc, wait) {
+  let oldParams;
+  const debounceFunc = debounce2((...params) => {
+    oldParams = void 0;
+    return func(...params);
+  }, wait);
+  return (...args) => {
+    let newParams = args;
+    if (oldParams) {
+      newParams = mergeFunc(oldParams, newParams);
+    }
+    oldParams = newParams;
+    return debounceFunc(...newParams);
+  };
+}
+function debounceAndAsyncMerge(func, mergeFunc, wait) {
+  let oldParams;
+  let promises = [];
+  const debounceFunc = debounce2(async (...params) => {
+    oldParams = void 0;
+    try {
+      const result = await func(...params);
+      promises.forEach((promise) => {
+        promise.resolve(result);
+      });
+      promises = [];
+      return result;
+    } catch (error) {
+      promises.forEach((promise) => {
+        promise.reject(error);
+      });
+      promises = [];
+    }
+  }, wait);
+  const fun = async (...args) => {
+    let newParams = args;
+    if (oldParams) {
+      newParams = mergeFunc(oldParams, newParams);
+    }
+    oldParams = newParams;
+    debounceFunc(...newParams);
+    return new Promise((resolve, reject) => {
+      promises.push({ resolve, reject });
+    });
+  };
+  return fun;
+}
+
+// src/utils/interceptor/interceptor.ts
+var Interceptor = class {
+  /**
+   * 请求之前处理
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:41
+   * @protected
+   * @param {InternalAxiosRequestConfig} config
+   * @returns {*}  {Promise<InternalAxiosRequestConfig>}
+   */
+  async onBeforeRequest(config) {
+    return config;
+  }
+  /**
+   * 请求失败之后处理
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:40
+   * @protected
+   * @param {*} error
+   */
+  onRequestError(error) {
+    return Promise.reject(error);
+  }
+  /**
+   * 响应成功之后处理
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:38
+   * @protected
+   * @param {AxiosResponse} config
+   * @returns {*}  {Promise<AxiosRequestConfig>}
+   */
+  async onResponseSuccess(config) {
+    return config;
+  }
+  /**
+   * 响应失败之后处理
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:37
+   * @protected
+   * @param {*} _error
+   */
+  onResponseError(error) {
+    return Promise.reject(error);
+  }
+  /**
+   * 使用拦截器
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:28
+   * @param {AxiosInstance} instance
+   */
+  use(instance) {
+    this.requestTag = instance.interceptors.request.use(
+      this.onBeforeRequest,
+      this.onRequestError
+    );
+    this.responseTag = instance.interceptors.response.use(
+      this.onResponseSuccess,
+      this.onResponseError
+    );
+  }
+  /**
+   * 移出拦截器
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:27
+   * @param {AxiosInstance} instance
+   */
+  eject(instance) {
+    if (this.requestTag) {
+      instance.interceptors.request.eject(this.requestTag);
+    }
+    if (this.responseTag) {
+      instance.interceptors.response.eject(this.responseTag);
+    }
+  }
+};
+
+// src/utils/interceptor/core-interceptor.ts
+var CoreInterceptor = class extends Interceptor {
+  async onBeforeRequest(config) {
+    await super.onBeforeRequest(config);
+    const { headers } = config;
+    headers.set("Authorization", `Bearer ${getToken()}`);
+    const { orgData } = ibiz;
+    if (orgData) {
+      if (orgData.systemid) {
+        headers.set("srfsystemid", orgData.systemid);
+      }
+      if (orgData.orgid) {
+        headers.set("srforgid", orgData.orgid);
+      }
+    }
+    return config;
+  }
+};
+
+// src/utils/logger/logger.ts
+var Logger = __toESM(require_loglevel(), 1);
+
+// src/utils/namespace/namespace.ts
+var defaultNamespace = "ibiz";
+var statePrefix = "is-";
+function _bem(namespace, block, blockSuffix, element, modifier) {
+  let cls = `${namespace}-${block}`;
+  if (blockSuffix) {
+    cls += `-${blockSuffix}`;
+  }
+  if (element) {
+    cls += `__${element}`;
+  }
+  if (modifier) {
+    cls += `--${modifier}`;
+  }
+  return cls;
+}
+var Namespace = class {
+  /**
+   * Creates an instance of Namespace.
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:12
+   * @param {string} block 当前命名空间的根模块,例如组件的名称
+   * @param {string} [namespace] 指定命名空间，未指定使用默认值 ibiz
+   */
+  constructor(block, namespace) {
+    this.block = block;
+    this.namespace = namespace || defaultNamespace;
+  }
+  /**
+   * namespace-block
+   * namespace-block-blockSuffix
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:08
+   * @param {string} [blockSuffix='']
+   * @return {*}  {string}
+   */
+  b(blockSuffix = "") {
+    return _bem(this.namespace, this.block, blockSuffix, "", "");
+  }
+  /**
+   * namespace-block__element
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:48
+   * @param {string} [element]
+   * @return {*}  {string}
+   */
+  e(element) {
+    return element ? _bem(this.namespace, this.block, "", element, "") : "";
+  }
+  /**
+   * namespace-block--modifier
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:37
+   * @param {string} [modifier]
+   * @return {*}  {string}
+   */
+  m(modifier) {
+    return modifier ? _bem(this.namespace, this.block, "", "", modifier) : "";
+  }
+  /**
+   * namespace-block-blockSuffix__element
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:52
+   * @param {string} [blockSuffix]
+   * @param {string} [element]
+   * @return {*}  {string}
+   */
+  be(blockSuffix, element) {
+    return blockSuffix && element ? _bem(this.namespace, this.block, blockSuffix, element, "") : "";
+  }
+  /**
+   * namespace-block__element--modifier
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:19
+   * @param {string} [element]
+   * @param {string} [modifier]
+   * @return {*}  {string}
+   */
+  em(element, modifier) {
+    return element && modifier ? _bem(this.namespace, this.block, "", element, modifier) : "";
+  }
+  /**
+   * namespace-block-blockSuffix--modifier
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:59
+   * @param {string} [blockSuffix]
+   * @param {string} [modifier]
+   * @return {*}  {string}
+   */
+  bm(blockSuffix, modifier) {
+    return blockSuffix && modifier ? _bem(this.namespace, this.block, blockSuffix, "", modifier) : "";
+  }
+  /**
+   * namespace-block-blockSuffix__element--modifier
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:37
+   * @param {string} [blockSuffix]
+   * @param {string} [element]
+   * @param {string} [modifier]
+   * @return {*}  {string}
+   */
+  bem(blockSuffix, element, modifier) {
+    return blockSuffix && element && modifier ? _bem(this.namespace, this.block, blockSuffix, element, modifier) : "";
+  }
+  /**
+   * 返回状态 class
+   *
+   * is('loading', false) => '';
+   * is('loading', true) => 'is-loading';
+   *
+   * @author chitanda
+   * @date 2022-09-06 12:09:57
+   * @param {string} name
+   * @param {boolean} [state]
+   * @return {*}  {string}
+   */
+  is(name, state) {
+    return name && state ? `${statePrefix}${name}` : "";
+  }
+  /**
+   * 生成使用到的 css 变量 style 对象
+   *
+   * @author chitanda
+   * @date 2022-09-06 15:09:41
+   * @param {Record<string, string>} object
+   * @return {*}  {Record<string, string>}
+   */
+  cssVar(object) {
+    const styles = {};
+    for (const key in object) {
+      if (object[key]) {
+        styles[this.cssVarName(key)] = object[key];
+      }
+    }
+    return styles;
+  }
+  /**
+   * 生成使用到的 css block 变量 style 对象
+   *
+   * @author chitanda
+   * @date 2022-09-06 15:09:03
+   * @param {Record<string, string>} object
+   * @return {*}  {Record<string, string>}
+   */
+  cssVarBlock(object) {
+    const styles = {};
+    for (const key in object) {
+      if (object[key]) {
+        styles[this.cssVarBlockName(key)] = object[key];
+      }
+    }
+    return styles;
+  }
+  /**
+   * 生成 css var 变量名称
+   *
+   * @author chitanda
+   * @date 2022-09-06 15:09:21
+   * @param {string} name
+   * @return {*}  {string}
+   */
+  cssVarName(name) {
+    return `--${this.namespace}-${name}`;
+  }
+  /**
+   * 生成块 css var 变量名称
+   *
+   * @author chitanda
+   * @date 2022-09-06 15:09:35
+   * @param {string} name
+   * @return {*}  {string}
+   */
+  cssVarBlockName(name) {
+    return `--${this.namespace}-${this.block}-${name}`;
+  }
+};
+
+// src/utils/net/http-response.ts
+import {
+  AxiosHeaders
+} from "axios";
+var HttpResponse = class {
+  /**
+   * Creates an instance of HttpResponse.
+   *
+   * @author chitanda
+   * @date 2022-08-18 15:08:11
+   * @param {unknown} [data] 返回的数据
+   * @param {number} [status] 状态码 (默认为 200)
+   * @param {string} [statusText] 状态描述 (默认为空字符)
+   */
+  constructor(data, status, statusText) {
+    /**
+     * 本地仿造响应
+     *
+     * @author chitanda
+     * @date 2022-08-18 15:08:06
+     */
+    this.local = true;
+    this.ok = false;
+    this.headers = {};
+    this.config = {
+      headers: new AxiosHeaders()
+    };
+    this.data = data;
+    this.status = status || 200;
+    this.statusText = statusText || "";
+    if (this.status >= 200 && this.status < 300) {
+      this.ok = true;
+    }
+  }
+};
+
+// src/utils/net/net.ts
+import axios from "axios";
+import { merge } from "lodash-es";
+import { stringify } from "qs";
+import { notNilEmpty } from "qx-util";
+var Net = class {
+  /**
+   * Creates an instance of Net.
+   * @author lxm
+   * @date 2022-10-27 16:10:05
+   * @param {CreateAxiosDefaults} [config] 创建实例用的默认配置
+   */
+  constructor(config) {
+    /**
+     * 是否为 http || https 开头
+     *
+     * @author chitanda
+     * @date 2022-11-07 14:11:28
+     * @protected
+     */
+    this.urlReg = /^http[s]?:\/\/[^\s]*/;
+    /**
+     * 注册的拦截器
+     *
+     * @author lxm
+     * @date 2022-10-27 17:10:18
+     * @type {Map<string, Interceptor>}
+     */
+    this.interceptors = /* @__PURE__ */ new Map();
+    this.instance = axios.create(config);
+    this.addInterceptor("Default", new CoreInterceptor());
+  }
+  /**
+   * 添加拦截器
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:42
+   * @param {string} name 唯一标识
+   * @param {Interceptor} interceptor 拦截器
+   */
+  addInterceptor(name, interceptor) {
+    interceptor.use(this.instance);
+    this.interceptors.set(name, interceptor);
+  }
+  /**
+   * 删除拦截器
+   *
+   * @author lxm
+   * @date 2022-10-27 17:10:27
+   * @param {string} name 唯一标识
+   */
+  removeInterceptor(name) {
+    const interceptor = this.interceptors.get(name);
+    if (interceptor) {
+      interceptor.eject(this.instance);
+      this.interceptors.delete(name);
+    }
+  }
+  /**
+   * 预置config,绑定动态的配置
+   *
+   * @author lxm
+   * @date 2022-10-27 16:10:48
+   * @readonly
+   * @protected
+   * @type {AxiosRequestConfig}
+   */
+  get presetConfig() {
+    return {
+      // 请求前缀路径
+      baseURL: this.instance.defaults.baseURL || `${ibiz.env.baseUrl}/${ibiz.env.appId}`,
+      headers: {
+        "Content-Type": "application/json;charset=UTF-8",
+        Accept: "application/json"
+      }
+    };
+  }
+  /**
+   * 从左到右递归合并配置参数（内置第一个合并的预置参数）
+   *
+   * @author lxm
+   * @date 2022-10-27 16:10:09
+   * @protected
+   * @param {...AxiosRequestConfig[]} configs
+   * @returns {*}
+   */
+  mergeConfig(...configs) {
+    const config = this.presetConfig;
+    if (configs.length === 0) {
+      return config;
+    }
+    const { url } = configs[0];
+    if (url && this.urlReg.test(url)) {
+      delete config.baseURL;
+    }
+    return merge(config, ...configs);
+  }
+  /**
+   * Post 请求
+   *
+   * @author chitanda
+   * @date 2022-10-19 11:10:30
+   * @param {string} url
+   * @param {IData} data
+   * @param {IParams} [params={}]
+   * @param {RawAxiosRequestHeaders} [headers={}]
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  async post(url, data, params = {}, headers = {}) {
+    url = this.handleAppPresetParam(url, params);
+    try {
+      const response = await this.request(url, {
+        method: "post",
+        data,
+        headers
+      });
+      return this.doResponseResult(response);
+    } catch (error) {
+      throw new HttpError(error);
+    }
+  }
+  /**
+   * Get 请求
+   *
+   * @author chitanda
+   * @date 2022-10-19 11:10:24
+   * @param {string} url
+   * @param {IParams} [params={}]
+   * @param {RawAxiosRequestHeaders} [headers={}]
+   * @param {IParams} [option={}]
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  async get(url, params = {}, headers = {}, option = {}) {
+    url = this.attachUrlParam(url, params);
+    try {
+      const response = await this.request(
+        url,
+        merge({ method: "get", headers }, option)
+      );
+      return this.doResponseResult(response);
+    } catch (error) {
+      throw new HttpError(error);
+    }
+  }
+  /**
+   * Delete 请求
+   *
+   * @author chitanda
+   * @date 2022-10-19 11:10:17
+   * @param {string} url
+   * @param {IParams} [params]
+   * @param {RawAxiosRequestHeaders} [headers={}]
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  async delete(url, params, headers = {}) {
+    url = this.handleAppPresetParam(url, params);
+    try {
+      const response = await this.request(url, { method: "delete", headers });
+      return this.doResponseResult(response);
+    } catch (error) {
+      throw new HttpError(error);
+    }
+  }
+  /**
+   * Put 请求
+   *
+   * @author chitanda
+   * @date 2022-10-19 11:10:11
+   * @param {string} url
+   * @param {IData} data
+   * @param {IParams} [params={}]
+   * @param {RawAxiosRequestHeaders} [headers={}]
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  async put(url, data, params = {}, headers = {}) {
+    url = this.handleAppPresetParam(url, params);
+    try {
+      const response = await this.request(url, {
+        method: "put",
+        data,
+        headers
+      });
+      return this.doResponseResult(response);
+    } catch (error) {
+      throw new HttpError(error);
+    }
+  }
+  /**
+   * 获取模型数据
+   *
+   * @author chitanda
+   * @date 2022-07-14 15:07:15
+   * @param {string} url
+   * @param {RawAxiosRequestHeaders} [headers={}]
+   * @return {*}  {Promise<IHttpResponse>}
+   */
+  async getModel(url, headers = {}) {
+    try {
+      const response = await this.instance.get(url, {
+        headers
+      });
+      return this.doResponseResult(response);
+    } catch (error) {
+      throw new HttpError(error);
+    }
+  }
+  /**
+   * 基础请求方法，会合并预置配置
+   *
+   * @author lxm
+   * @date 2022-10-27 14:10:06
+   * @param {string} url
+   * @param {AxiosRequestConfig} [config={}]
+   * @returns {*}  {Promise<IHttpResponse>}
+   */
+  async request(url, config = {}) {
+    try {
+      const response = await this.instance.request(
+        this.mergeConfig({ url }, config)
+      );
+      return this.doResponseResult(response);
+    } catch (error) {
+      throw new HttpError(error);
+    }
+  }
+  /**
+   * 创建标准 axios 请求
+   *
+   * @author chitanda
+   * @date 2023-01-30 15:01:27
+   * @param {AxiosRequestConfig<IData>} config
+   * @return {*}
+   */
+  axios(config) {
+    return axios(config);
+  }
+  /**
+   * 统一处理请求返回
+   *
+   * @author chitanda
+   * @date 2022-07-14 16:07:23
+   * @private
+   * @param {AxiosResponse} response
+   * @return {*}  {IHttpResponse}
+   */
+  doResponseResult(response) {
+    const res = response;
+    if (res.status >= 200 && res.status <= 299) {
+      res.ok = true;
+    }
+    return res;
+  }
+  /**
+   * 处理平台预定义参数
+   *
+   * @author chitanda
+   * @date 2022-07-14 15:07:12
+   * @private
+   * @param {string} url
+   * @param {IParams} [params]
+   * @return {*}  {string}
+   */
+  handleAppPresetParam(url, params) {
+    if (params) {
+      const keys = Object.keys(params);
+      const tempParam = {};
+      keys.forEach((item) => {
+        if (item.startsWith("srf") && notNilEmpty(params[item])) {
+          tempParam[item] = params[item];
+        }
+      });
+      return this.attachUrlParam(url, params);
+    }
+    return url;
+  }
+  /**
+   * url 附加请求参数
+   *
+   * @author chitanda
+   * @date 2022-07-14 15:07:34
+   * @private
+   * @param {string} url
+   * @param {IParams} params
+   * @return {*}  {string}
+   */
+  attachUrlParam(url, params) {
+    const strParams = stringify(params);
+    if (notNilEmpty(strParams)) {
+      if (url.endsWith("?")) {
+        url = `${url}${strParams}`;
+      } else if (url.indexOf("?") !== -1 && url.endsWith("&")) {
+        url = `${url}${strParams}`;
+      } else if (url.indexOf("?") !== -1 && !url.endsWith("&")) {
+        url = `${url}&${strParams}`;
+      } else {
+        url = `${url}?${strParams}`;
+      }
+    }
+    return url;
+  }
+};
+
+// src/utils/plural/plural.ts
+import pluralize from "pluralize";
+function plural(key) {
+  return pluralize(key);
+}
+function pluralLower(key) {
+  return plural(key).toLowerCase();
+}
+
+// src/utils/string-util/string-util.ts
+import { notNilEmpty as notNilEmpty2 } from "qx-util";
+var StringUtil = class {
+  /**
+   * 填充字符串中的数据
+   *
+   * @author chitanda
+   * @date 2021-04-23 20:04:17
+   * @static
+   * @param {string} str
+   * @param {*} [context]
+   * @param {*} [data]
+   * @return {*}  {string}
+   */
+  static fill(str, context, data) {
+    if (notNilEmpty2(str)) {
+      if (notNilEmpty2(context)) {
+        const strArr = str.match(this.contextReg);
+        strArr == null ? void 0 : strArr.forEach((_key) => {
+          const key = _key.slice(10, _key.length - 1);
+          str = str.replace(`\${context.${key}}`, context[key] || "");
+        });
+      }
+      if (notNilEmpty2(data)) {
+        const strArr = str.match(this.dataReg);
+        strArr == null ? void 0 : strArr.forEach((_key) => {
+          const key = _key.slice(7, _key.length - 1);
+          str = str.replace(`\${data.${key}}`, data[key] || "");
+        });
+      }
+    }
+    return str;
+  }
+};
+/**
+ * 上下文替换正则
+ *
+ * @author chitanda
+ * @date 2021-04-23 20:04:01
+ * @static
+ */
+StringUtil.contextReg = /\$\{context.[a-zA-Z_$][a-zA-Z0-9_$]{1,}\}/g;
+/**
+ * 数据替换正则
+ *
+ * @author chitanda
+ * @date 2021-04-23 20:04:09
+ * @static
+ */
+StringUtil.dataReg = /\$\{data.[a-zA-Z_$][a-zA-Z0-9_$]{1,}\}/g;
+
+// src/utils/url-helper/url-helper.ts
+var UrlHelper = class {
+  /**
+   * 路由路径前面的基础路径
+   * 如：http://172.16.103.120:30061/portalwebapp/#/index/appportalview?params=123
+   * 返回：http://172.16.103.120:30061/portalwebapp/#
+   *
+   * @author lxm
+   * @date 2022-10-11 20:10:29
+   * @returns {*}
+   */
+  static get routeBase() {
+    return `${this.appBase}/#`;
+  }
+  /**
+   * 应用的的基础路径
+   * 如：http://172.16.103.120:30061/portalwebapp/#/index/appportalview?params=123
+   * 返回：http://172.16.103.120:30061/portalwebapp
+   *
+   * @author lxm
+   * @date 2022-10-11 20:10:29
+   * @returns {*}
+   */
+  static get appBase() {
+    const { origin, pathname } = window.location;
+    return `${origin}${pathname}`.replace(/\/$/, "");
+  }
+  /**
+   * #开始到末尾，即路由地址
+   * 如：http://172.16.103.120:30061/portalwebapp/#/index/appportalview?params=123
+   * 返回：/index/appportalview?params=123
+   *
+   * @author lxm
+   * @date 2022-10-11 16:10:40
+   * @returns {*}
+   */
+  static get routePath() {
+    return window.location.hash.replace("#", "");
+  }
+  /**
+   * 当前地址的全路径，包含域名和参数
+   * 如：http://172.16.103.120:30061/portalwebapp/#/index/appportalview?params=123
+   *
+   * @author lxm
+   * @date 2022-10-11 21:10:39
+   * @readonly
+   * @static
+   */
+  static get fullPath() {
+    return window.location.href;
+  }
+};
+
+// src/utils/event/event.ts
+function eventPath(event) {
+  const path = event.composedPath && event.composedPath() || event.path;
+  if (path != null)
+    return path;
+  function getParents(node, memo = []) {
+    const parentNode = node.parentNode;
+    return parentNode ? getParents(parentNode, memo.concat([parentNode])) : memo;
+  }
+  return [event.target].concat(getParents(event.target));
+}
+function listenJSEvent(target, eventName, listener, options = {}) {
+  target.addEventListener(eventName, listener, options);
+  let cleanup = () => {
+    target.removeEventListener(eventName, listener, options);
+    cleanup = NOOP;
+  };
+  return () => {
+    cleanup();
+  };
+}
+function isEventInside(event, el) {
+  return el && (event.target === el || eventPath(event).includes(el));
+}
+
+// src/utils/click-outside/click-outside.ts
+var defaultWindow = typeof window !== "undefined" ? window : void 0;
+function onClickOutside(target, handler, options = {}) {
+  const { window: window2 = defaultWindow, ignore = [], capture = true } = options;
+  if (!target)
+    throw new RuntimeError("target\u5143\u7D20\u4E0D\u5B58\u5728");
+  if (!window2)
+    throw new RuntimeError("\u627E\u4E0D\u5230window");
+  let shouldListen = true;
+  const isOutside = (event) => {
+    return ![target, ...ignore].some((el) => {
+      return isEventInside(event, el);
+    });
+  };
+  let isPaused = false;
+  const pause = () => {
+    isPaused = true;
+  };
+  const proceed = () => {
+    isPaused = false;
+  };
+  let fallback;
+  const listener = (event) => {
+    if (isPaused)
+      return;
+    window2.clearTimeout(fallback);
+    if (!(shouldListen && isOutside(event)))
+      return;
+    handler(event);
+  };
+  const cleanups = [
+    listenJSEvent(window2, "click", listener, { passive: true, capture }),
+    listenJSEvent(
+      window2,
+      "pointerdown",
+      (e) => {
+        if (isPaused)
+          return;
+        shouldListen = isOutside(e);
+      },
+      { passive: true }
+    ),
+    listenJSEvent(
+      window2,
+      "pointerup",
+      (e) => {
+        if (isPaused)
+          return;
+        if (e.button === 0) {
+          const path = eventPath(e);
+          e.composedPath = () => path;
+          fallback = window2.setTimeout(() => listener(e), 50);
+        }
+      },
+      { passive: true }
+    )
+  ].filter(Boolean);
+  const stop = () => cleanups.forEach((fn) => fn());
+  return { stop, pause, proceed };
+}
+
+// src/utils/color/color.ts
+var r = Math.round;
+function toRGBA(color) {
+  const l = color.length;
+  const rgba = [];
+  if (color.slice(0, 3).toLowerCase() === "rgb") {
+    const d = color.match(/([\d|.%]{1,3})/g);
+    rgba[0] = parseInt(d[0], 10);
+    rgba[1] = parseInt(d[1], 10);
+    rgba[2] = parseInt(d[2], 10);
+    rgba[3] = d[3] ? d[3].indexOf("%") !== -1 ? parseInt(d[3], 10) / 100 : parseFloat(d[3]) : 1;
+  } else {
+    let d;
+    if (l < 6)
+      d = parseInt(
+        String(color[1]) + color[1] + color[2] + color[2] + color[3] + color[3] + (l > 4 ? String(color[4]) + color[4] : ""),
+        16
+      );
+    else
+      d = parseInt(color.slice(1), 16);
+    rgba[0] = d >> 16 & 255;
+    rgba[1] = d >> 8 & 255;
+    rgba[2] = d & 255;
+    rgba[3] = l === 9 || l === 5 ? r((d >> 24 & 255) / 255 * 1e4) / 1e4 : 1;
+  }
+  return rgba;
+}
+function colorBlend(color1, color2, p = 0.5, format = "hex") {
+  color1 = color1.trim();
+  color2 = color2.trim();
+  const c1 = toRGBA(color1);
+  const c2 = toRGBA(color2);
+  const result = [
+    r((1 - p) * c1[0] + p * c2[0]),
+    r((1 - p) * c1[1] + p * c2[1]),
+    r((1 - p) * c1[2] + p * c2[2]),
+    (1 - p) * c1[3] + p * c2[3]
+  ];
+  if (format === "hex") {
+    const hex = [
+      result[0].toString(16),
+      result[1].toString(16),
+      result[2].toString(16),
+      result[3] === 0 ? "00" : r(result[3] * 255).toString(16)
+    ];
+    return `#${hex[0]}${hex[1]}${hex[2]}${hex[3]}`;
+  }
+  return `rgb(${result[0]} ${result[1]} ${result[2]} / ${result[3]})`;
+}
+
+// src/utils/download-file/download-file.ts
+function calcMimeByFileName(fileName) {
+  const ext = fileName.split(".").pop();
+  let mime = "";
+  switch (ext) {
+    case ".wps":
+      mime = "application/kswps";
+      break;
+    case ".doc":
+      mime = "application/msword";
+      break;
+    case ".docx":
+      mime = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+      break;
+    case ".txt":
+      mime = "text/plain";
+      break;
+    case ".zip":
+      mime = "application/zip";
+      break;
+    case ".png":
+      mime = "image/png";
+      break;
+    case ".gif":
+      mime = "image/gif";
+      break;
+    case ".jpeg":
+      mime = "image/jpeg";
+      break;
+    case ".jpg":
+      mime = "image/jpeg";
+      break;
+    case ".rtf":
+      mime = "application/rtf";
+      break;
+    case ".avi":
+      mime = "video/x-msvideo";
+      break;
+    case ".gz":
+      mime = "application/x-gzip";
+      break;
+    case ".tar":
+      mime = "application/x-tar";
+      break;
+    case ".xlsx":
+      mime = "application/vnd.ms-excel";
+      break;
+    default:
+      mime = "";
+  }
+  return mime;
+}
+function isImage(fileName) {
+  const ext = fileName.split(".").pop();
+  if (!ext) {
+    return false;
+  }
+  const imageTypes = [".jpeg", "jpg", "gif", "png", "bmp", "svg"];
+  return imageTypes.includes(ext);
+}
+function downloadFileFromBlob(file, fileName) {
+  const filetype = calcMimeByFileName(fileName);
+  const blob = new Blob([file], { type: filetype });
+  const href = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = href;
+  a.download = fileName;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(href);
+}
+
+// src/utils/upload/select-file.ts
+import { merge as merge2 } from "lodash-es";
+function fileListToArr(fileList) {
+  const files = [];
+  for (let i = 0; i < fileList.length; i++) {
+    files.push(fileList[i]);
+  }
+  return files;
+}
+function selectFile(_opts) {
+  const opts = merge2(
+    {
+      multiple: true,
+      accept: ""
+    },
+    _opts
+  );
+  const input = document.createElement("input");
+  input.setAttribute("type", "file");
+  input.setAttribute("multiple", `${opts.multiple}`);
+  input.setAttribute("accept", opts.accept);
+  input.onchange = (e) => {
+    const inputEl = e.target;
+    const files = inputEl.files ? fileListToArr(inputEl.files) : [];
+    if (files.length === 0) {
+      return;
+    }
+    opts.onSelected(files);
+    inputEl.value = "";
+  };
+  document.body.appendChild(input);
+  input.click();
+  document.body.removeChild(input);
+}
+
+// src/utils/upload/upload-file.ts
+import { cloneDeep, isFunction, merge as merge3, round, uniqueId } from "lodash-es";
+function uploadFile(_opts) {
+  const opts = merge3(
+    {
+      multiple: true,
+      accept: "",
+      separate: true,
+      beforeUpload: (_fileData, _files) => true,
+      finish: (_resultFiles) => {
+      },
+      success: (_resultFiles, _res) => {
+      },
+      error: (_resultFiles, _error) => {
+      },
+      progress: (_files) => {
+      }
+    },
+    _opts
+  );
+  const onUploadProgress = (event, files) => {
+    files.forEach((file) => {
+      file.percentage = round(event.progress * 100);
+    });
+    opts.progress(cloneDeep(files));
+  };
+  const uploadRequest = async (files, _onProgress) => {
+    if (opts.request && isFunction(opts.request)) {
+      return opts.request(files);
+    }
+    const data = new FormData();
+    files.forEach((file) => {
+      data.append("file", file);
+    });
+    throw new Error(`\u591A\u5E94\u7528\u6A21\u5F0F\u7B49\u5F85\u91CD\u65B0\u5B9E\u73B0\u8BF7\u6C42`);
+  };
+  const executeSingleUpload = async (files) => {
+    const resultFiles = files.map((file) => {
+      return {
+        status: "uploading",
+        name: file.name,
+        uid: uniqueId(),
+        percentage: 0
+      };
+    });
+    const pass = opts.beforeUpload(files, resultFiles);
+    if (!pass) {
+      resultFiles.forEach((file) => {
+        file.status = "cancel";
+      });
+      ibiz.log.debug("\u53D6\u6D88\u4E0A\u4F20", resultFiles);
+      return resultFiles;
+    }
+    try {
+      const res = await uploadRequest(files, (event) => {
+        onUploadProgress(event, resultFiles);
+      });
+      resultFiles.forEach((file) => {
+        file.status = "finished";
+      });
+      opts.success(resultFiles, res);
+      resultFiles.forEach((file) => {
+        file.response = res;
+      });
+    } catch (error) {
+      resultFiles.forEach((file) => {
+        file.status = "fail";
+      });
+      opts.error(resultFiles, error);
+      resultFiles.forEach((file) => {
+        file.error = error;
+      });
+      ibiz.log.error(error);
+      ibiz.log.error(`${files.map((file) => file.name).join(",")}\u4E0A\u4F20\u5931\u8D25`);
+    }
+    return resultFiles;
+  };
+  const uploadFiles = async (files) => {
+    const uploadSequence = opts.separate ? files.map((file) => [file]) : [files];
+    const res = await Promise.allSettled(
+      uploadSequence.map(async (sequence) => {
+        return executeSingleUpload(sequence);
+      })
+    );
+    const resultFiles = [];
+    res.forEach((result) => {
+      if (result.status === "fulfilled") {
+        resultFiles.push(...result.value);
+      }
+    });
+    opts.finish(resultFiles);
+  };
+  const select = () => {
+    selectFile({
+      accept: opts.accept,
+      multiple: opts.multiple,
+      onSelected: (files) => {
+        uploadFiles(files);
+      }
+    });
+  };
+  select();
+}
+
+// src/utils/sync/await-timeout.ts
+async function awaitTimeout(wait, fun, params) {
+  await new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true);
+    }, wait);
+  });
+  if (fun) {
+    return fun(...params || []);
+  }
+}
+
+// src/utils/sync/count-latch.ts
+var CountLatch = class {
+  constructor() {
+    this.promise = null;
+    this.resolve = null;
+    /**
+     * 计数，当前等待的异步逻辑个数
+     *
+     * @author lxm
+     * @date 2022-11-24 19:11:59
+     * @type {number}
+     */
+    this.count = 0;
+  }
+  /**
+   * 开启promise
+   *
+   * @author lxm
+   * @date 2022-11-24 19:11:32
+   * @private
+   */
+  startPromise() {
+    this.promise = new Promise((resolve) => {
+      this.resolve = resolve;
+    });
+  }
+  /**
+   * 结束promise
+   *
+   * @author lxm
+   * @date 2022-11-24 19:11:44
+   * @private
+   */
+  endPromise() {
+    if (this.resolve) {
+      this.resolve();
+      this.resolve = null;
+      this.promise = null;
+    }
+  }
+  /**
+   * 上锁，计数加一
+   * 第一次计数，开启异步
+   *
+   * @author lxm
+   * @date 2022-11-24 19:11:27
+   */
+  lock() {
+    this.count += 1;
+    if (!this.promise) {
+      this.startPromise();
+    }
+  }
+  /**
+   * 解锁，计数减一
+   * 归零时结束异步
+   *
+   * @author lxm
+   * @date 2022-11-24 19:11:47
+   */
+  unlock() {
+    if (this.count < 1) {
+      throw new RuntimeError("lock\u548Cunlock\u6B21\u6570\u4E0D\u5339\u914D\uFF01");
+    }
+    this.count -= 1;
+    if (this.count === 0) {
+      this.endPromise();
+    }
+  }
+  /**
+   * 等待，计数归零异步结束
+   *
+   * @author lxm
+   * @date 2022-11-24 19:11:20
+   */
+  async await() {
+    if (this.promise) {
+      await this.promise;
+    }
+  }
+};
+
+// src/utils/style/remote-style.ts
+async function setRemoteStyle(url) {
+  try {
+    const res = await ibiz.net.get(url);
+    const styleDom = document.createElement("style");
+    styleDom.setAttribute("title", "app-style-css");
+    styleDom.innerText = res.data;
+    document.head.appendChild(styleDom);
+  } catch (error) {
+    Logger.debug("\u52A0\u8F7D\u8FDC\u7A0B\u6837\u5F0F\u8868\u5931\u8D25", url);
+  }
+}
+
+// src/ibizsys.ts
+var IBizSys = class {
+  constructor() {
+    /**
+     * 环境变量
+     *
+     * @author chitanda
+     * @date 2022-07-19 18:07:04
+     */
+    this.env = Environment;
+    /**
+     * 日志对象
+     *
+     * @author chitanda
+     * @date 2022-10-25 20:10:22
+     */
+    this.log = Logger;
+    /**
+     * 网络请求工具类
+     *
+     * @author chitanda
+     * @date 2022-07-19 17:07:56
+     * @type {Net}
+     */
+    this.net = new Net();
+    /**
+     * 指令集
+     *
+     * @author chitanda
+     * @date 2022-07-20 10:07:33
+     * @type {AuthService}
+     */
+    this.commands = new CommandController();
+  }
+};
+
+// src/factory-center.ts
+var FactoryCenter = class {
+};
+
+// src/install.ts
+function install() {
+  if (window.ibiz) {
+    throw new Error("ibiz \u5DF2\u7ECF\u5B58\u5728, \u65E0\u9700\u91CD\u590D\u5B89\u88C5");
+  }
+  window.ibiz = new IBizSys();
+  window.___fc = new FactoryCenter();
+}
+export {
+  CommandController,
+  CommandsRegistry,
+  CoreConst,
+  CoreInterceptor,
+  CountLatch,
+  Environment,
+  FactoryCenter,
+  HttpError,
+  HttpResponse,
+  HttpStatusMessageConst,
+  IBizContext,
+  IBizSys,
+  Interceptor,
+  LinkedList,
+  Logger,
+  LoginMode,
+  MenuPermissionMode,
+  ModelError,
+  NOOP,
+  Namespace,
+  Net,
+  RuntimeError,
+  RuntimeModelError,
+  StringUtil,
+  UrlHelper,
+  awaitTimeout,
+  calcMimeByFileName,
+  colorBlend,
+  commands,
+  debounce,
+  debounceAndAsyncMerge,
+  debounceAndMerge,
+  downloadFileFromBlob,
+  eventPath,
+  fileListToArr,
+  getToken,
+  install,
+  isEventInside,
+  isImage,
+  isOverlap,
+  listenJSEvent,
+  onClickOutside,
+  plural,
+  pluralLower,
+  selectFile,
+  setRemoteStyle,
+  throttle,
+  toDisposable,
+  uploadFile
+};