@ibiz-template/vue3-util 0.0.4-beta.5 → 0.1.1

package/dist/index.esm.js

@@ -1,3 +1,986 @@
+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/path-browserify@1.0.1/node_modules/path-browserify/index.js
+var require_path_browserify = __commonJS({
+  "../../node_modules/.pnpm/path-browserify@1.0.1/node_modules/path-browserify/index.js"(exports, module) {
+    "use strict";
+    function assertPath(path) {
+      if (typeof path !== "string") {
+        throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
+      }
+    }
+    function normalizeStringPosix(path, allowAboveRoot) {
+      var res = "";
+      var lastSegmentLength = 0;
+      var lastSlash = -1;
+      var dots = 0;
+      var code;
+      for (var i = 0; i <= path.length; ++i) {
+        if (i < path.length)
+          code = path.charCodeAt(i);
+        else if (code === 47)
+          break;
+        else
+          code = 47;
+        if (code === 47) {
+          if (lastSlash === i - 1 || dots === 1) {
+          } else if (lastSlash !== i - 1 && dots === 2) {
+            if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+              if (res.length > 2) {
+                var lastSlashIndex = res.lastIndexOf("/");
+                if (lastSlashIndex !== res.length - 1) {
+                  if (lastSlashIndex === -1) {
+                    res = "";
+                    lastSegmentLength = 0;
+                  } else {
+                    res = res.slice(0, lastSlashIndex);
+                    lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                  }
+                  lastSlash = i;
+                  dots = 0;
+                  continue;
+                }
+              } else if (res.length === 2 || res.length === 1) {
+                res = "";
+                lastSegmentLength = 0;
+                lastSlash = i;
+                dots = 0;
+                continue;
+              }
+            }
+            if (allowAboveRoot) {
+              if (res.length > 0)
+                res += "/..";
+              else
+                res = "..";
+              lastSegmentLength = 2;
+            }
+          } else {
+            if (res.length > 0)
+              res += "/" + path.slice(lastSlash + 1, i);
+            else
+              res = path.slice(lastSlash + 1, i);
+            lastSegmentLength = i - lastSlash - 1;
+          }
+          lastSlash = i;
+          dots = 0;
+        } else if (code === 46 && dots !== -1) {
+          ++dots;
+        } else {
+          dots = -1;
+        }
+      }
+      return res;
+    }
+    function _format(sep, pathObject) {
+      var dir = pathObject.dir || pathObject.root;
+      var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+      if (!dir) {
+        return base;
+      }
+      if (dir === pathObject.root) {
+        return dir + base;
+      }
+      return dir + sep + base;
+    }
+    var posix = {
+      // path.resolve([from ...], to)
+      resolve: function resolve() {
+        var resolvedPath = "";
+        var resolvedAbsolute = false;
+        var cwd;
+        for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+          var path;
+          if (i >= 0)
+            path = arguments[i];
+          else {
+            if (cwd === void 0)
+              cwd = process.cwd();
+            path = cwd;
+          }
+          assertPath(path);
+          if (path.length === 0) {
+            continue;
+          }
+          resolvedPath = path + "/" + resolvedPath;
+          resolvedAbsolute = path.charCodeAt(0) === 47;
+        }
+        resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+        if (resolvedAbsolute) {
+          if (resolvedPath.length > 0)
+            return "/" + resolvedPath;
+          else
+            return "/";
+        } else if (resolvedPath.length > 0) {
+          return resolvedPath;
+        } else {
+          return ".";
+        }
+      },
+      normalize: function normalize(path) {
+        assertPath(path);
+        if (path.length === 0)
+          return ".";
+        var isAbsolute = path.charCodeAt(0) === 47;
+        var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+        path = normalizeStringPosix(path, !isAbsolute);
+        if (path.length === 0 && !isAbsolute)
+          path = ".";
+        if (path.length > 0 && trailingSeparator)
+          path += "/";
+        if (isAbsolute)
+          return "/" + path;
+        return path;
+      },
+      isAbsolute: function isAbsolute(path) {
+        assertPath(path);
+        return path.length > 0 && path.charCodeAt(0) === 47;
+      },
+      join: function join2() {
+        if (arguments.length === 0)
+          return ".";
+        var joined;
+        for (var i = 0; i < arguments.length; ++i) {
+          var arg = arguments[i];
+          assertPath(arg);
+          if (arg.length > 0) {
+            if (joined === void 0)
+              joined = arg;
+            else
+              joined += "/" + arg;
+          }
+        }
+        if (joined === void 0)
+          return ".";
+        return posix.normalize(joined);
+      },
+      relative: function relative(from, to) {
+        assertPath(from);
+        assertPath(to);
+        if (from === to)
+          return "";
+        from = posix.resolve(from);
+        to = posix.resolve(to);
+        if (from === to)
+          return "";
+        var fromStart = 1;
+        for (; fromStart < from.length; ++fromStart) {
+          if (from.charCodeAt(fromStart) !== 47)
+            break;
+        }
+        var fromEnd = from.length;
+        var fromLen = fromEnd - fromStart;
+        var toStart = 1;
+        for (; toStart < to.length; ++toStart) {
+          if (to.charCodeAt(toStart) !== 47)
+            break;
+        }
+        var toEnd = to.length;
+        var toLen = toEnd - toStart;
+        var length = fromLen < toLen ? fromLen : toLen;
+        var lastCommonSep = -1;
+        var i = 0;
+        for (; i <= length; ++i) {
+          if (i === length) {
+            if (toLen > length) {
+              if (to.charCodeAt(toStart + i) === 47) {
+                return to.slice(toStart + i + 1);
+              } else if (i === 0) {
+                return to.slice(toStart + i);
+              }
+            } else if (fromLen > length) {
+              if (from.charCodeAt(fromStart + i) === 47) {
+                lastCommonSep = i;
+              } else if (i === 0) {
+                lastCommonSep = 0;
+              }
+            }
+            break;
+          }
+          var fromCode = from.charCodeAt(fromStart + i);
+          var toCode = to.charCodeAt(toStart + i);
+          if (fromCode !== toCode)
+            break;
+          else if (fromCode === 47)
+            lastCommonSep = i;
+        }
+        var out = "";
+        for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+          if (i === fromEnd || from.charCodeAt(i) === 47) {
+            if (out.length === 0)
+              out += "..";
+            else
+              out += "/..";
+          }
+        }
+        if (out.length > 0)
+          return out + to.slice(toStart + lastCommonSep);
+        else {
+          toStart += lastCommonSep;
+          if (to.charCodeAt(toStart) === 47)
+            ++toStart;
+          return to.slice(toStart);
+        }
+      },
+      _makeLong: function _makeLong(path) {
+        return path;
+      },
+      dirname: function dirname(path) {
+        assertPath(path);
+        if (path.length === 0)
+          return ".";
+        var code = path.charCodeAt(0);
+        var hasRoot = code === 47;
+        var end = -1;
+        var matchedSlash = true;
+        for (var i = path.length - 1; i >= 1; --i) {
+          code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              end = i;
+              break;
+            }
+          } else {
+            matchedSlash = false;
+          }
+        }
+        if (end === -1)
+          return hasRoot ? "/" : ".";
+        if (hasRoot && end === 1)
+          return "//";
+        return path.slice(0, end);
+      },
+      basename: function basename(path, ext) {
+        if (ext !== void 0 && typeof ext !== "string")
+          throw new TypeError('"ext" argument must be a string');
+        assertPath(path);
+        var start = 0;
+        var end = -1;
+        var matchedSlash = true;
+        var i;
+        if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+          if (ext.length === path.length && ext === path)
+            return "";
+          var extIdx = ext.length - 1;
+          var firstNonSlashEnd = -1;
+          for (i = path.length - 1; i >= 0; --i) {
+            var code = path.charCodeAt(i);
+            if (code === 47) {
+              if (!matchedSlash) {
+                start = i + 1;
+                break;
+              }
+            } else {
+              if (firstNonSlashEnd === -1) {
+                matchedSlash = false;
+                firstNonSlashEnd = i + 1;
+              }
+              if (extIdx >= 0) {
+                if (code === ext.charCodeAt(extIdx)) {
+                  if (--extIdx === -1) {
+                    end = i;
+                  }
+                } else {
+                  extIdx = -1;
+                  end = firstNonSlashEnd;
+                }
+              }
+            }
+          }
+          if (start === end)
+            end = firstNonSlashEnd;
+          else if (end === -1)
+            end = path.length;
+          return path.slice(start, end);
+        } else {
+          for (i = path.length - 1; i >= 0; --i) {
+            if (path.charCodeAt(i) === 47) {
+              if (!matchedSlash) {
+                start = i + 1;
+                break;
+              }
+            } else if (end === -1) {
+              matchedSlash = false;
+              end = i + 1;
+            }
+          }
+          if (end === -1)
+            return "";
+          return path.slice(start, end);
+        }
+      },
+      extname: function extname(path) {
+        assertPath(path);
+        var startDot = -1;
+        var startPart = 0;
+        var end = -1;
+        var matchedSlash = true;
+        var preDotState = 0;
+        for (var i = path.length - 1; i >= 0; --i) {
+          var code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              startPart = i + 1;
+              break;
+            }
+            continue;
+          }
+          if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+          }
+          if (code === 46) {
+            if (startDot === -1)
+              startDot = i;
+            else if (preDotState !== 1)
+              preDotState = 1;
+          } else if (startDot !== -1) {
+            preDotState = -1;
+          }
+        }
+        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+          return "";
+        }
+        return path.slice(startDot, end);
+      },
+      format: function format(pathObject) {
+        if (pathObject === null || typeof pathObject !== "object") {
+          throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+        }
+        return _format("/", pathObject);
+      },
+      parse: function parse(path) {
+        assertPath(path);
+        var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+        if (path.length === 0)
+          return ret;
+        var code = path.charCodeAt(0);
+        var isAbsolute = code === 47;
+        var start;
+        if (isAbsolute) {
+          ret.root = "/";
+          start = 1;
+        } else {
+          start = 0;
+        }
+        var startDot = -1;
+        var startPart = 0;
+        var end = -1;
+        var matchedSlash = true;
+        var i = path.length - 1;
+        var preDotState = 0;
+        for (; i >= start; --i) {
+          code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              startPart = i + 1;
+              break;
+            }
+            continue;
+          }
+          if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+          }
+          if (code === 46) {
+            if (startDot === -1)
+              startDot = i;
+            else if (preDotState !== 1)
+              preDotState = 1;
+          } else if (startDot !== -1) {
+            preDotState = -1;
+          }
+        }
+        if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+        preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+        preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+          if (end !== -1) {
+            if (startPart === 0 && isAbsolute)
+              ret.base = ret.name = path.slice(1, end);
+            else
+              ret.base = ret.name = path.slice(startPart, end);
+          }
+        } else {
+          if (startPart === 0 && isAbsolute) {
+            ret.name = path.slice(1, startDot);
+            ret.base = path.slice(1, end);
+          } else {
+            ret.name = path.slice(startPart, startDot);
+            ret.base = path.slice(startPart, end);
+          }
+          ret.ext = path.slice(startDot, end);
+        }
+        if (startPart > 0)
+          ret.dir = path.slice(0, startPart - 1);
+        else if (isAbsolute)
+          ret.dir = "/";
+        return ret;
+      },
+      sep: "/",
+      delimiter: ":",
+      win32: null,
+      posix: null
+    };
+    posix.posix = posix;
+    module.exports = posix;
+  }
+});
+
+// src/plugin/plugin-factory/plugin-factory.ts
+var import_path_browserify = __toESM(require_path_browserify(), 1);
+import { RuntimeError, RuntimeModelError } from "@ibiz-template/core";
+import {
+  RemotePluginItem
+} from "@ibiz-template/runtime";
+var PluginFactory = class {
+  constructor() {
+    /**
+     * 是否为 http || https 开头
+     *
+     * @author chitanda
+     * @date 2022-11-07 14:11:28
+     * @protected
+     */
+    this.urlReg = /^http[s]?:\/\/[^\s]*/;
+    /**
+     * 是否已经加载过文件缓存
+     *
+     * @author chitanda
+     * @date 2022-10-31 14:10:17
+     * @protected
+     * @type {Map<string, boolean>}
+     */
+    this.cache = /* @__PURE__ */ new Map();
+    /**
+     * 本地开发测试包，只在本地开发生效
+     *
+     * @author chitanda
+     * @date 2022-11-02 21:11:41
+     * @protected
+     */
+    this.devPackages = /* @__PURE__ */ new Map();
+    /**
+     * 插件缓存
+     *
+     * @author chitanda
+     * @date 2022-10-31 14:10:28
+     * @protected
+     * @type {Map<string, RemotePluginItem>}
+     */
+    this.pluginCache = /* @__PURE__ */ new Map();
+    /**
+     * 所有的插件
+     *
+     * @author chitanda
+     * @date 2023-02-02 16:02:55
+     * @protected
+     * @type {Plugin[]}
+     */
+    this.pluginCodes = [];
+    /**
+     * 预定义插件集合
+     *
+     * @author chitanda
+     * @date 2023-03-09 17:03:46
+     * @protected
+     * @type {Map<string, IPluginItem>}
+     */
+    this.predefinedPlugins = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 注册视图默认插件
+   *
+   * @author chitanda
+   * @date 2023-02-06 21:02:10
+   * @param {IPluginItem} plugin
+   */
+  registerPredefinedPlugin(plugin) {
+    this.predefinedPlugins.set(plugin.name, plugin);
+  }
+  /**
+   * 给入应用实例，将已经加载的过插件注入。主要用于多实例的情况
+   *
+   * @author chitanda
+   * @date 2023-02-02 16:02:51
+   * @param {App} app
+   */
+  register(app) {
+    this.pluginCodes.forEach((plugin) => {
+      app.use(plugin);
+    });
+  }
+  /**
+   * 加载预置插件
+   *
+   * @author chitanda
+   * @date 2023-03-09 18:03:48
+   * @param {string} name
+   * @return {*}  {Promise<void>}
+   */
+  async loadPredefinedPlugin(name) {
+    if (this.predefinedPlugins.has(name)) {
+      const plugin = this.predefinedPlugins.get(name);
+      if (plugin) {
+        await this.loadPluginRef(plugin.name, plugin.path);
+      }
+    }
+  }
+  /**
+   * 插件刚加载完成回来，设置到目前所有的 vue 实例当中
+   *
+   * @author chitanda
+   * @date 2023-02-02 17:02:38
+   * @protected
+   * @param {Plugin} code
+   */
+  setPluginCode(code) {
+    this.pluginCodes.push(code);
+  }
+  /**
+   * 设置开发插件，用于本地调试
+   *
+   * @author chitanda
+   * @date 2022-11-02 21:11:56
+   * @param {string} name
+   * @param {() => Promise<unknown>} fn
+   */
+  setDevPlugin(name, fn) {
+    this.devPackages.set(name, fn);
+  }
+  /**
+   * 加载插件
+   *
+   * @author chitanda
+   * @date 2022-10-31 14:10:13
+   * @param {ISysPFPlugin} plugin
+   * @return {*}  {Promise<boolean>}
+   */
+  async loadPlugin(plugin) {
+    if (plugin.runtimeObject === true) {
+      const pluginRef = plugin;
+      if (pluginRef) {
+        try {
+          await this.loadPluginRef(
+            pluginRef.rtobjectName,
+            pluginRef.rtobjectRepo
+          );
+        } catch (error) {
+          throw new RuntimeModelError(pluginRef, "\u914D\u7F6E\u52A0\u8F7D\u5931\u8D25");
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * 加载应用插件
+   *
+   * @author chitanda
+   * @date 2022-10-31 16:10:57
+   * @param {IPSAppPFPluginRef} pluginRef
+   * @return {*}  {Promise<boolean>}
+   */
+  async loadPluginRef(rtObjectName, rtObjectRepo) {
+    if (this.pluginCache.has(rtObjectName)) {
+      return true;
+    }
+    let configData = null;
+    const fn = this.devPackages.get(rtObjectName);
+    if (fn) {
+      configData = await fn();
+    } else {
+      const pluginPath = rtObjectRepo;
+      const configUrl = this.urlReg.test(pluginPath) ? "".concat(pluginPath, "/package.json") : "".concat(ibiz.env.pluginBaseUrl, "/").concat((0, import_path_browserify.join)(pluginPath, "package.json"));
+      const res = await ibiz.net.axios({
+        method: "get",
+        headers: { "Access-Control-Allow-Origin": "*" },
+        url: configUrl
+      });
+      if (res.status !== 200) {
+        throw new Error("\u914D\u7F6E\u52A0\u8F7D\u5931\u8D25");
+      }
+      configData = res.data;
+    }
+    const remotePlugin = new RemotePluginItem(
+      rtObjectName,
+      rtObjectRepo,
+      configData
+    );
+    if (remotePlugin) {
+      try {
+        await this.loadScript(remotePlugin);
+        this.pluginCache.set(rtObjectName, remotePlugin);
+        return true;
+      } catch (error) {
+        ibiz.log.error(error);
+      }
+    }
+    return false;
+  }
+  /**
+   * 加载插件
+   *
+   * @author chitanda
+   * @date 2022-11-02 14:11:31
+   * @protected
+   * @param {RemotePluginItem} remotePlugin
+   * @return {*}  {Promise<void>}
+   */
+  async loadScript(remotePlugin) {
+    const pluginPath = remotePlugin.repo;
+    const { name, version, system, module } = remotePlugin.config;
+    let scriptUrl = "";
+    if (this.devPackages.has(name)) {
+      scriptUrl = (0, import_path_browserify.join)("".concat(name, "@").concat(version), module);
+    } else if (ibiz.env.dev) {
+      scriptUrl = this.urlReg.test(pluginPath) ? "".concat(pluginPath, "/").concat((0, import_path_browserify.join)(module)) : "".concat(ibiz.env.pluginBaseUrl, "/").concat(pluginPath, "/").concat((0, import_path_browserify.join)(module));
+    } else {
+      scriptUrl = "".concat(pluginPath).concat(pluginPath.endsWith("/") ? "" : "/").concat((0, import_path_browserify.join)(
+        system
+      ));
+    }
+    if (scriptUrl) {
+      if (this.cache.has(scriptUrl)) {
+        return;
+      }
+      let data = null;
+      const url = this.parseUrl(scriptUrl);
+      if (this.devPackages.has(name)) {
+        const fn = this.devPackages.get(name);
+        const pluginModule = await fn();
+        this.setPluginCode(pluginModule.default);
+        this.cache.set(scriptUrl, true);
+      } else if (ibiz.env.dev) {
+        data = await import(
+          scriptUrl
+          /* @vite-ignore */
+        );
+      } else {
+        System.addImportMap({
+          imports: {
+            [name]: url
+          }
+        });
+        data = await System.import(name);
+      }
+      if (data) {
+        if (data.default) {
+          this.setPluginCode(data.default);
+        } else {
+          throw new RuntimeError(
+            "\u8FDC\u7A0B\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25, \u8FDC\u7A0B\u63D2\u4EF6\u672A\u627E\u5230[default]\u9ED8\u8BA4\u5BFC\u51FA"
+          );
+        }
+        this.cache.set(scriptUrl, true);
+      } else {
+        throw new RuntimeError(
+          "\u8FDC\u7A0B\u63D2\u4EF6\u52A0\u8F7D\u5931\u8D25, \u672A\u627E\u5230\u6587\u4EF6\u6216\u6587\u4EF6\u5185\u5BB9\u683C\u5F0F\u4E0D\u6B63\u786E"
+        );
+      }
+    }
+  }
+  /**
+   * 编译请求文件地址
+   *
+   * @author chitanda
+   * @date 2022-10-31 14:10:19
+   * @protected
+   * @param {string} script
+   * @return {*}  {string}
+   */
+  parseUrl(script) {
+    if (this.urlReg.test(script)) {
+      return script;
+    }
+    let url = "";
+    if (this.urlReg.test(ibiz.env.pluginBaseUrl)) {
+      if (script.startsWith("/")) {
+        url = ibiz.env.pluginBaseUrl + script;
+      } else {
+        url = "".concat(ibiz.env.pluginBaseUrl, "/").concat(script);
+      }
+    } else {
+      url = "".concat((0, import_path_browserify.join)(ibiz.env.pluginBaseUrl, script));
+    }
+    const { origin, pathname } = window.location;
+    if (pathname.endsWith("/") && url.startsWith("/")) {
+      url = url.substring(1);
+    }
+    url = "".concat(origin).concat(pathname).concat(url);
+    return url;
+  }
+};
+
+// src/use/click-outside/click-outside.ts
+import {
+  NOOP,
+  onClickOutside
+} from "@ibiz-template/core";
+import { isNil } from "ramda";
+import { onBeforeUnmount, watch } from "vue";
+function useClickOutside(elRef, handler, options = {}) {
+  let stop = NOOP;
+  let pause = NOOP;
+  let proceed = NOOP;
+  const destroy = () => {
+    stop();
+    stop = NOOP;
+    pause = NOOP;
+    proceed = NOOP;
+  };
+  watch(
+    elRef,
+    (newVal, oldVal) => {
+      if (newVal !== oldVal) {
+        if (isNil(newVal)) {
+          destroy();
+        } else {
+          const result = onClickOutside(
+            (newVal == null ? void 0 : newVal.$el) || newVal,
+            handler,
+            options
+          );
+          stop = result.stop;
+          pause = result.pause;
+          proceed = result.proceed;
+        }
+      }
+    },
+    { immediate: true }
+  );
+  onBeforeUnmount(() => {
+    if (stop !== NOOP) {
+      destroy();
+    }
+  });
+  return {
+    stop: () => stop(),
+    pause: () => pause(),
+    proceed: () => proceed()
+  };
+}
+
+// src/use/control/use-control-controller/use-control-controller.ts
+import { getCurrentInstance as getCurrentInstance2, onBeforeUnmount as onBeforeUnmount2, reactive, watch as watch3 } from "vue";
+
+// src/use/vue/vue.ts
+import { isFunc } from "qx-util";
+import {
+  createCommentVNode,
+  getCurrentInstance,
+  isReactive,
+  toRaw,
+  watch as watch2
+} from "vue";
+function useProps() {
+  const vue = getCurrentInstance().proxy;
+  return vue.$props;
+}
+function getOrigin(val) {
+  return isReactive(val) ? toRaw(val) : val;
+}
+function usePropsWatch(key, callback, options) {
+  const props = useProps();
+  if (Object.prototype.hasOwnProperty.call(props, key)) {
+    watch2(
+      () => props[key],
+      (newVal, oldVal) => {
+        callback(getOrigin(newVal), getOrigin(oldVal));
+      },
+      options
+    );
+    callback(getOrigin(props[key]), void 0);
+  }
+}
+function useForce() {
+  const vue = getCurrentInstance().proxy;
+  return (callback) => {
+    vue.$forceUpdate();
+    if (callback && isFunc(callback)) {
+      vue.$nextTick(() => {
+        callback();
+      });
+    }
+  };
+}
+function useForceTogether(vue, controller) {
+  const orignForce = controller.force;
+  const selfForce = useForce();
+  controller.force = (callback) => {
+    orignForce(callback);
+    selfForce();
+  };
+}
+function useController(controller) {
+  controller.force = useForce();
+}
+var EmptyVNode = createCommentVNode("EmptyVNode");
+function isEmptyVNode(nodes) {
+  if (!Array.isArray(nodes)) {
+    return nodes === EmptyVNode;
+  }
+  return nodes.length === 1 && nodes[0] === EmptyVNode;
+}
+
+// src/use/util/index.ts
+import { inject } from "vue";
+function useCtx() {
+  return inject("ctx");
+}
+function useMobCtx() {
+  return inject("ctx");
+}
+
+// src/use/control/use-control-controller/use-control-controller.ts
+function watchAndUpdateState(props, control) {
+  const excludeKeys = ["context", "params", "modelData"];
+  watch3(
+    () => {
+      const watchProps = {};
+      Object.keys(props).forEach((key) => {
+        if (!excludeKeys.includes(key)) {
+          watchProps[key] = props[key];
+        }
+      });
+      return watchProps;
+    },
+    (newVal, oldVal) => {
+      const changeProps = {};
+      Object.keys(newVal).forEach((key) => {
+        if (newVal[key] !== (oldVal || {})[key]) {
+          changeProps[key] = newVal[key];
+        }
+      });
+      ibiz.log.debug("\u90E8\u4EF6 [".concat(control.model.name, "] state \u53D8\u66F4"), changeProps);
+      Object.keys(changeProps).forEach((key) => {
+        if (changeProps[key] !== void 0) {
+          control.state[key] = changeProps[key];
+        }
+      });
+    },
+    { immediate: true }
+  );
+}
+function useControlController(fn) {
+  const ctx = useCtx();
+  const props = useProps();
+  ctx.evt.emit("onForecast", props.modelData.name);
+  const c = fn(props.modelData, props.context, props.params, ctx);
+  watchAndUpdateState(props, c);
+  c.state = reactive(c.state);
+  c.force = useForce();
+  const vue = getCurrentInstance2().proxy;
+  c.evt.onAll((eventName, event) => {
+    vue.$emit(eventName.slice(2), event);
+  });
+  vue.$emit("controllerAppear", c);
+  c.created();
+  onBeforeUnmount2(() => c.destroyed());
+  return c;
+}
+
+// src/use/event/event.ts
+import { listenJSEvent, NOOP as NOOP2 } from "@ibiz-template/core";
+import { isNil as isNil2 } from "ramda";
+import { onBeforeUnmount as onBeforeUnmount3, watch as watch4 } from "vue";
+function useEventListener(elRef, eventName, listener, options = {}) {
+  let cleanup = NOOP2;
+  watch4(
+    elRef,
+    (newVal, oldVal) => {
+      if (newVal !== oldVal) {
+        if (isNil2(newVal)) {
+          cleanup();
+          cleanup = NOOP2;
+        } else {
+          cleanup = listenJSEvent(
+            (newVal == null ? void 0 : newVal.$el) || newVal,
+            eventName,
+            listener,
+            options
+          );
+        }
+      }
+    },
+    { immediate: true }
+  );
+  onBeforeUnmount3(() => {
+    if (cleanup !== NOOP2) {
+      cleanup();
+    }
+  });
+  return () => {
+    cleanup();
+  };
+}
+
+// src/use/focus-blur/focus-blur.ts
+import { ref } from "vue";
+function useFocusAndBlur(focus, blur) {
+  const componentRef = ref();
+  const isFocus = ref(false);
+  let outsideFuns;
+  const doBlur = () => {
+    if (!isFocus.value) {
+      ibiz.log.debug("\u6CA1\u6709\u805A\u7126\uFF0C\u4E0D\u89E6\u53D1\u5931\u7126");
+    }
+    blur();
+    outsideFuns.stop();
+    isFocus.value = false;
+  };
+  const pause = () => {
+    if (outsideFuns) {
+      outsideFuns.pause();
+    }
+  };
+  const stop = () => {
+    if (outsideFuns) {
+      outsideFuns.stop();
+    }
+  };
+  useEventListener(
+    componentRef,
+    "click",
+    (_evt) => {
+      if (!isFocus.value) {
+        outsideFuns = useClickOutside(componentRef, () => {
+          doBlur();
+        });
+        isFocus.value = true;
+        focus();
+      }
+    },
+    { capture: true }
+    // 捕获防止内部ui拦截点击事件
+  );
+  return { componentRef, isFocus, doBlur, pause, stop };
+}
+
 // src/use/namespace/namespace.ts
 import { Namespace } from "@ibiz-template/core";
 function useNamespace(block) {
@@ -6,14 +989,15 @@ function useNamespace(block) {
 
 // src/use/route/route.ts
 import { useRoute as useRoute2 } from "vue-router";
-import { ref, watch as watch3 } from "vue";
+import { ref as ref2, watch as watch7 } from "vue";
 
 // src/util/route/route.ts
 import { notNilEmpty } from "qx-util";
-import { RuntimeError } from "@ibiz-template/core";
+import { RuntimeError as RuntimeError2 } from "@ibiz-template/core";
 import qs from "qs";
 import { useRoute } from "vue-router";
-import { watch } from "vue";
+import { watch as watch5 } from "vue";
+import { getMatchResPath } from "@ibiz-template/runtime";
 function getOwnRouteContext(context) {
   const ownContext = context.getOwnContext();
   const excludeKeys = ["srfsessionid", "srfappid"];
@@ -21,21 +1005,47 @@ function getOwnRouteContext(context) {
     if (excludeKeys.includes(key)) {
       delete ownContext[key];
     }
-  });
-  return ownContext;
+  });
+  return ownContext;
+}
+async function calcResRoutePath(routePath, context, appDataEntityId) {
+  if (!appDataEntityId) {
+    routePath.pathNodes[0].context = void 0;
+  } else {
+    const entity = await ibiz.hub.getAppDataEntity(appDataEntityId);
+    let match = getMatchResPath(context, entity);
+    if (!match) {
+      match = { path: "", keys: [entity.codeName.toLowerCase()] };
+    }
+    if (match) {
+      const currentContext = routePath.pathNodes[1].context;
+      const resContext = {};
+      match.keys.forEach((key) => {
+        if (currentContext && Object.prototype.hasOwnProperty.call(currentContext, key)) {
+          resContext[key] = currentContext[key];
+          delete currentContext[key];
+        }
+      });
+      routePath.pathNodes[0].context = resContext;
+    }
+  }
 }
-function generateRoutePath(appView, route, context, params) {
+async function generateRoutePath(appView, route, context, params) {
   const routePath = route2routePath(route);
   let depth = 2;
   if (context.toRouteDepth) {
     depth = context.toRouteDepth;
     delete context.toRouteDepth;
+  } else if (ibiz.env.isMob) {
+    routePath.pathNodes[0] = {
+      viewName: "home"
+    };
   }
   routePath.pathNodes.splice(depth - 1, routePath.pathNodes.length - depth + 1);
   if (context.currentSrfNav) {
     const currentNode = routePath.pathNodes[routePath.pathNodes.length - 1];
     currentNode.params = currentNode.params || {};
-    currentNode.params.srfnav = context.currentSrfNav;
+    currentNode.srfnav = context.currentSrfNav;
     delete context.currentSrfNav;
   }
   if (route.fullPath.startsWith("/appredirectview")) {
@@ -51,6 +1061,9 @@ function generateRoutePath(appView, route, context, params) {
     context: getOwnRouteContext(context),
     params
   });
+  if (depth === 2) {
+    await calcResRoutePath(routePath, context, appView.appDataEntityId);
+  }
   return { path: routePath2string(routePath) };
 }
 async function parseRouteViewData(route, depth) {
@@ -58,14 +1071,14 @@ async function parseRouteViewData(route, depth) {
   const routePath = route2routePath(route);
   let viewCodeName = routePath.pathNodes[depth - 1].viewName;
   if (!viewCodeName) {
-    throw new RuntimeError(`\u7B2C${depth}\u7EA7\u8DEF\u7531\u4E0D\u5B58\u5728\u89C6\u56FE\u6807\u8BC6`);
+    throw new RuntimeError2("\u7B2C".concat(depth, "\u7EA7\u8DEF\u7531\u4E0D\u5B58\u5728\u89C6\u56FE\u6807\u8BC6"));
   }
   if (viewCodeName === "index") {
     viewCodeName = ibiz.hub.defaultAppIndexViewName;
   }
   const viewModel = await ibiz.hub.getAppView(viewCodeName);
   if (!viewModel) {
-    throw new RuntimeError(`\u627E\u4E0D\u5230\u89C6\u56FE${viewCodeName}`);
+    throw new RuntimeError2("\u627E\u4E0D\u5230\u89C6\u56FE".concat(viewCodeName));
   }
   const context = {};
   if ((_a = ibiz.appData) == null ? void 0 : _a.context) {
@@ -92,8 +1105,8 @@ function route2routePath(route) {
   const depth = route.matched.length;
   const pathNodes = [];
   for (let index = 1; index <= depth; index++) {
-    const viewName = route.params[`view${index}`];
-    const paramsStr = route.params[`params${index}`];
+    const viewName = route.path.split("/")[index * 2];
+    const paramsStr = route.params["params".concat(index)];
     let params;
     let context;
     let srfnav;
@@ -134,16 +1147,16 @@ function route2routePath(route) {
 function routePath2string(routePath) {
   let pathStr = "";
   if (routePath.appContext) {
-    pathStr += `/${qs.stringify(routePath.appContext, {
+    pathStr += "/".concat(qs.stringify(routePath.appContext, {
       delimiter: ";",
       strictNullHandling: true
-    })}`;
+    }));
   } else {
-    pathStr += `/${ibiz.env.routePlaceholder}`;
+    pathStr += "/".concat(ibiz.env.routePlaceholder);
   }
   routePath.pathNodes.forEach((pathNode, index) => {
-    pathStr += `/${pathNode.viewName}/`;
-    let routeParams;
+    pathStr += "/".concat(pathNode.viewName, "/");
+    let routeParams = {};
     if (index === 0) {
       if (notNilEmpty(pathNode.context)) {
         routeParams = pathNode.context;
@@ -156,23 +1169,49 @@ function routePath2string(routePath) {
           routeParams.srfnavctx = encodeURIComponent(objStr);
         }
       }
+      if (pathNode.srfnav) {
+        routeParams.srfnav = pathNode.srfnav;
+      }
+    }
+    if (notNilEmpty(routeParams)) {
+      pathStr += qs.stringify(routeParams, {
+        delimiter: ";",
+        strictNullHandling: true
+      });
+    } else {
+      pathStr += ibiz.env.routePlaceholder;
     }
-    pathStr += qs.stringify(routeParams, { delimiter: ";", strictNullHandling: true }) || ibiz.env.routePlaceholder;
   });
   return pathStr;
 }
+function getNestedRoutePath(route, depth, noSrfNav = true) {
+  if (route.matched.length < depth) {
+    return "";
+  }
+  if (route.name) {
+    return route.path;
+  }
+  const routePath = route2routePath(route);
+  if (routePath.pathNodes.length < depth) {
+    return route.path;
+  }
+  if (routePath.pathNodes.length > depth) {
+    routePath.pathNodes = routePath.pathNodes.slice(0, depth);
+  }
+  if (noSrfNav) {
+    delete routePath.pathNodes[depth - 1].srfnav;
+  }
+  return routePath2string(routePath);
+}
 function onRouteChange(callback, depth) {
   const route = useRoute();
-  watch(
-    () => route.path,
+  if (!route) {
+    throw new RuntimeError2("\u65E0\u6CD5\u6B63\u786E\u83B7\u53D6route,\u53EF\u80FD\u662F\u4F9D\u8D56\u95EE\u9898");
+  }
+  watch5(
+    () => route == null ? void 0 : route.path,
     () => {
-      const routePath = route2routePath(route);
-      let currentKey = "";
-      if (routePath.pathNodes.length >= depth) {
-        routePath.pathNodes = routePath.pathNodes.slice(0, depth);
-        delete routePath.pathNodes[depth - 1].srfnav;
-        currentKey = routePath2string(routePath);
-      }
+      const currentKey = getNestedRoutePath(route, depth);
       callback({ currentKey, fullPath: route.fullPath });
     },
     { immediate: true }
@@ -180,7 +1219,7 @@ function onRouteChange(callback, depth) {
 }
 
 // src/util/route/route-listener.ts
-import { watch as watch2 } from "vue";
+import { watch as watch6 } from "vue";
 var RouteListener = class {
   constructor(route, wait) {
     /**
@@ -208,7 +1247,7 @@ var RouteListener = class {
     if (wait) {
       this.wait = wait;
     }
-    watch2(
+    watch6(
       () => route.path,
       (newVal, oldVal) => {
         if (newVal !== oldVal) {
@@ -258,6 +1297,24 @@ var withInstall = (main, install) => {
   return main;
 };
 
+// src/util/control/prepare-control.ts
+function prepareControl(c) {
+  const commonNs = useNamespace("control");
+  const { controlType, sysCss, codeName } = c.model;
+  const typeClass = controlType.toLowerCase();
+  const sysCssName = sysCss == null ? void 0 : sysCss.cssName;
+  const ns = useNamespace("control-".concat(typeClass));
+  const controlClass = [
+    commonNs.b(),
+    commonNs.b(typeClass),
+    commonNs.m(codeName)
+  ];
+  if (sysCssName) {
+    controlClass.push(sysCssName);
+  }
+  return { controlClass, ns };
+}
+
 // src/use/route/route.ts
 function useRouterQuery() {
   const route = useRoute2();
@@ -266,11 +1323,11 @@ function useRouterQuery() {
 }
 function useRouteKey(originKey, route, routeKey) {
   if (!routeKey) {
-    routeKey = ref("");
+    routeKey = ref2("");
   }
   routeKey.value = originKey.value;
   const routeListener = new RouteListener(route);
-  watch3(originKey, (newVal, oldVal) => {
+  watch7(originKey, (newVal, oldVal) => {
     if (newVal !== oldVal) {
       routeListener.nextChange(() => {
         routeKey.value = newVal;
@@ -280,189 +1337,65 @@ function useRouteKey(originKey, route, routeKey) {
   return routeKey;
 }
 
-// src/use/vue/vue.ts
-import { isFunc } from "qx-util";
+// src/use/view/use-view-controller/use-view-controller.ts
+import { clearAll } from "qx-util";
 import {
-  createCommentVNode,
-  getCurrentInstance,
-  isReactive,
-  toRaw,
-  watch as watch4
+  getCurrentInstance as getCurrentInstance3,
+  inject as inject2,
+  onBeforeUnmount as onBeforeUnmount4,
+  provide,
+  reactive as reactive2,
+  watch as watch8
 } from "vue";
-function useProps() {
-  const vue = getCurrentInstance().proxy;
-  return vue.$props;
-}
-function getOrigin(val) {
-  return isReactive(val) ? toRaw(val) : val;
-}
-function usePropsWatch(key, callback, options) {
-  const props = useProps();
-  if (Object.prototype.hasOwnProperty.call(props, key)) {
-    watch4(
-      () => props[key],
-      (newVal, oldVal) => {
-        callback(getOrigin(newVal), getOrigin(oldVal));
-      },
-      options
-    );
-    callback(getOrigin(props[key]), void 0);
-  }
-}
-function useForce() {
-  const vue = getCurrentInstance().proxy;
-  return (callback) => {
-    vue.$forceUpdate();
-    if (callback && isFunc(callback)) {
-      vue.$nextTick(() => {
-        callback();
-      });
+function watchAndUpateContextParams(props, view) {
+  watch8(
+    () => ({ context: props.context, params: props.params }),
+    (newVal) => {
+      view.context.reset({}, newVal.context);
+      clearAll(view.params);
+      Object.assign(view.params, newVal.params);
+      view.handleContextParams();
+      ibiz.log.debug("".concat(view.model.id, "\u7684\u4E0A\u4E0B\u6587\u6216\u89C6\u56FE\u53C2\u6570\u53D8\u66F4\uFF1A"), newVal);
     }
-  };
-}
-function useForceTogether(vue, controller) {
-  const orignForce = controller.force;
-  const selfForce = useForce();
-  controller.force = (callback) => {
-    orignForce(callback);
-    selfForce();
-  };
-}
-function useController(controller) {
-  controller.force = useForce();
-}
-var EmptyVNode = createCommentVNode("EmptyVNode");
-function isEmptyVNode(nodes) {
-  if (!Array.isArray(nodes)) {
-    return nodes === EmptyVNode;
-  }
-  return nodes.length === 1 && nodes[0] === EmptyVNode;
-}
-
-// src/use/click-outside/click-outside.ts
-import {
-  NOOP,
-  onClickOutside
-} from "@ibiz-template/core";
-import { isNil } from "ramda";
-import { onBeforeUnmount, watch as watch5 } from "vue";
-function useClickOutside(elRef, handler, options = {}) {
-  let stop = NOOP;
-  let pause = NOOP;
-  let proceed = NOOP;
-  const destroy = () => {
-    stop();
-    stop = NOOP;
-    pause = NOOP;
-    proceed = NOOP;
-  };
-  watch5(
-    elRef,
-    (newVal, oldVal) => {
-      if (newVal !== oldVal) {
-        if (isNil(newVal)) {
-          destroy();
-        } else {
-          const result = onClickOutside(
-            (newVal == null ? void 0 : newVal.$el) || newVal,
-            handler,
-            options
-          );
-          stop = result.stop;
-          pause = result.pause;
-          proceed = result.proceed;
-        }
-      }
-    },
-    { immediate: true }
   );
-  onBeforeUnmount(() => {
-    if (stop !== NOOP) {
-      destroy();
-    }
-  });
-  return {
-    stop: () => stop(),
-    pause: () => pause(),
-    proceed: () => proceed()
-  };
 }
-
-// src/use/event/event.ts
-import { listenJSEvent, NOOP as NOOP2 } from "@ibiz-template/core";
-import { isNil as isNil2 } from "ramda";
-import { onBeforeUnmount as onBeforeUnmount2, watch as watch6 } from "vue";
-function useEventListener(elRef, eventName, listener, options = {}) {
-  let cleanup = NOOP2;
-  watch6(
-    elRef,
+function watchAndUpdateState2(props, view) {
+  watch8(
+    () => {
+      return props.state ? { ...props.state } : {};
+    },
     (newVal, oldVal) => {
-      if (newVal !== oldVal) {
-        if (isNil2(newVal)) {
-          cleanup();
-          cleanup = NOOP2;
-        } else {
-          cleanup = listenJSEvent(
-            (newVal == null ? void 0 : newVal.$el) || newVal,
-            eventName,
-            listener,
-            options
-          );
+      const changeProps = {};
+      Object.keys(newVal).forEach((key) => {
+        if (newVal[key] !== (oldVal || {})[key]) {
+          changeProps[key] = newVal[key];
         }
-      }
+      });
+      ibiz.log.debug("\u89C6\u56FE [".concat(view.model.name, "] state \u53D8\u66F4"), changeProps);
+      Object.keys(changeProps).forEach((key) => {
+        view.state[key] = changeProps[key];
+      });
     },
     { immediate: true }
   );
-  onBeforeUnmount2(() => {
-    if (cleanup !== NOOP2) {
-      cleanup();
-    }
-  });
-  return () => {
-    cleanup();
-  };
 }
-
-// src/use/view/use-view-controller/use-view-controller.ts
-import {
-  getCurrentInstance as getCurrentInstance2,
-  inject,
-  onBeforeUnmount as onBeforeUnmount3,
-  provide,
-  reactive
-} from "vue";
 function useViewController(fn) {
   const props = useProps();
-  const ctx = inject("ctx", void 0);
-  ctx == null ? void 0 : ctx.evt.emit("forecast", props.modelData.name);
+  const ctx = inject2("ctx", void 0);
+  ctx == null ? void 0 : ctx.evt.emit("onForecast", props.modelData.name);
   const c = fn(props.modelData, props.context, props.params, ctx);
+  watchAndUpateContextParams(props, c);
+  watchAndUpdateState2(props, c);
   provide("ctx", c.ctx);
-  c.state = reactive(c.state);
+  c.state = reactive2(c.state);
+  c.slotProps = reactive2(c.slotProps);
   if (props.modal) {
     c.modal = props.modal;
   }
-  const vue = getCurrentInstance2().proxy;
-  c.force = useForce();
-  c.evt.onAll((eventName, event) => {
-    vue.$emit(eventName.slice(2), event);
-  });
-  c.created();
-  onBeforeUnmount3(() => c.destroyed());
-  return c;
-}
-
-// src/use/widgets/use-control-controller/use-control-controller.ts
-import { getCurrentInstance as getCurrentInstance3, inject as inject2, onBeforeUnmount as onBeforeUnmount4, reactive as reactive2 } from "vue";
-function useControlController(fn) {
-  const ctx = inject2("ctx");
-  const props = useProps();
-  ctx.evt.emit("forecast", props.modelData.name);
-  const c = fn(props.modelData, props.context, props.params, ctx);
-  c.state = reactive2(c.state);
   c.force = useForce();
   const vue = getCurrentInstance3().proxy;
   c.evt.onAll((eventName, event) => {
-    vue.$emit(eventName, event);
+    vue.$emit(eventName.slice(2), event);
   });
   c.created();
   onBeforeUnmount4(() => c.destroyed());
@@ -506,8 +1439,10 @@ function getEditorEmits() {
   return {
     /** 值变更事件 */
     change: (_value, _name) => true,
-    /** 是否正在操作事件 */
-    operate: (_isOperating) => true
+    /** 失焦事件 */
+    blur: () => true,
+    /** 聚焦事件 */
+    focus: () => true
   };
 }
 function getGridEditorEmits() {
@@ -545,34 +1480,272 @@ function getInputIpProps() {
 function getGridInputIpProps() {
   return { ...getInputIpProps(), ...getGridEditorCommonProps() };
 }
+
+// src/props/editor/span.ts
+function getSpanProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridSpanProps() {
+  return { ...getSpanProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/dropdown-list.ts
+function getDropdownProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridDropdownProps() {
+  return { ...getDropdownProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/check-box-list.ts
+function getCheckboxListProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridCheckboxListProps() {
+  return { ...getCheckboxListProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/check-box.ts
+function getCheckboxProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridCheckboxProps() {
+  return { ...getCheckboxProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/data-picker.ts
+function getDataPickerProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridDataPickerProps() {
+  return { ...getDataPickerProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/date-picker.ts
+function getDatePickerProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridDatePickerProps() {
+  return { ...getDatePickerProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/date-range.ts
+function getDateRangeProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridDateRangeProps() {
+  return { ...getDateRangeProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/list-box.ts
+function getListBoxProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridListBoxProps() {
+  return { ...getListBoxProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/number-range.ts
+function getNumberRangeProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridNumberRangeProps() {
+  return { ...getNumberRangeProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/radio-button-list.ts
+function getRadioProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridRadioProps() {
+  return { ...getRadioProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/rate.ts
+function getRateProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridRateProps() {
+  return { ...getRateProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/raw.ts
+function getRawProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridRawProps() {
+  return { ...getRawProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/slider.ts
+function getSliderProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridSliderProps() {
+  return { ...getSliderProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/stepper.ts
+function getStepperProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridStepperProps() {
+  return { ...getStepperProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/switch.ts
+function getSwitchProps() {
+  return { ...getEditorProps(), value: [String, Number] };
+}
+function getGridSwitchProps() {
+  return { ...getSwitchProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/upload.ts
+function getUploadProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridUploadProps() {
+  return { ...getUploadProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/autocomplete.ts
+function getAutoCompleteProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridAutoCompleteProps() {
+  return { ...getAutoCompleteProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/code.ts
+function getCodeProps() {
+  return {
+    ...getEditorProps(),
+    value: String,
+    language: {
+      type: String
+    },
+    theme: {
+      type: String
+    }
+  };
+}
+function getGridCodeProps() {
+  return { ...getCodeProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/html.ts
+function getHtmlProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridHtmlProps() {
+  return { ...getHtmlProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/markdown.ts
+function getMarkDownProps() {
+  return {
+    ...getEditorProps()
+  };
+}
+function getGridMarkDownProps() {
+  return { ...getMarkDownProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/array.ts
+function getArrayProps() {
+  return { ...getEditorProps(), value: [Array, Array] };
+}
+function getGridArrayProps() {
+  return { ...getArrayProps(), ...getGridEditorCommonProps() };
+}
+
+// src/props/editor/cascader.ts
+function getCascaderProps() {
+  return { ...getEditorProps(), value: String };
+}
+function getGridCascaderProps() {
+  return { ...getCascaderProps(), ...getGridEditorCommonProps() };
+}
 export {
   EmptyVNode,
+  PluginFactory,
   RequiredProp,
   RouteListener,
+  calcResRoutePath,
   generateRoutePath,
+  getArrayProps,
+  getAutoCompleteProps,
+  getCascaderProps,
+  getCheckboxListProps,
+  getCheckboxProps,
+  getCodeProps,
+  getDataPickerProps,
+  getDatePickerProps,
+  getDateRangeProps,
+  getDropdownProps,
   getEditorEmits,
   getEditorProps,
+  getGridArrayProps,
+  getGridAutoCompleteProps,
+  getGridCascaderProps,
+  getGridCheckboxListProps,
+  getGridCheckboxProps,
+  getGridCodeProps,
+  getGridDataPickerProps,
+  getGridDatePickerProps,
+  getGridDateRangeProps,
+  getGridDropdownProps,
   getGridEditorCommonProps,
   getGridEditorEmits,
+  getGridHtmlProps,
   getGridInputIpProps,
   getGridInputNumberProps,
   getGridInputProps,
+  getGridListBoxProps,
+  getGridMarkDownProps,
+  getGridNumberRangeProps,
+  getGridRadioProps,
+  getGridRateProps,
+  getGridRawProps,
+  getGridSliderProps,
+  getGridSpanProps,
+  getGridStepperProps,
+  getGridSwitchProps,
+  getGridUploadProps,
+  getHtmlProps,
   getInputIpProps,
   getInputNumberProps,
   getInputProps,
+  getListBoxProps,
+  getMarkDownProps,
+  getNestedRoutePath,
+  getNumberRangeProps,
   getOrigin,
   getOwnRouteContext,
+  getRadioProps,
+  getRateProps,
+  getRawProps,
+  getSliderProps,
+  getSpanProps,
+  getStepperProps,
+  getSwitchProps,
+  getUploadProps,
   isEmptyVNode,
   onRouteChange,
   parseRouteViewData,
+  prepareControl,
   route2routePath,
   routePath2string,
   useClickOutside,
   useControlController,
   useController,
+  useCtx,
   useEventListener,
+  useFocusAndBlur,
   useForce,
   useForceTogether,
+  useMobCtx,
   useNamespace,
   useProps,
   usePropsWatch,