@deppon/deppon-router 2.1.1

package/es/utils.js

@@ -0,0 +1,558 @@
+import './_virtual/_rollup-plugin-inject-process-env.js';
+import _typeof from '@babel/runtime/helpers/typeof';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+
+var _excluded = ["appendIsUap"],
+  _excluded2 = ["uumsFunction", "closeCurrentTab"];
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * 创建路由工具函数
+ * @param {Object} router - Vue Router 实例
+ * @param {Object} [defaultViewTab] - 默认的 viewTab 配置（可选）
+ * @returns {Object} 工具函数对象，包含以下方法：
+ *   - safePush: 安全的路由跳转（带错误处理）
+ *   - safeReplace: 安全的路由替换（带错误处理）
+ *   - pushByName: 根据路由名称跳转
+ *   - pushByPath: 根据路由路径跳转
+ *   - goBack: 返回上一页
+ *   - hasRoute: 检查路由是否存在
+ *   - getRouteConfig: 获取路由配置
+ *   - depponPush: 智能路由跳转（在 iframe 环境中自动使用 viewTab，否则使用 router.push）
+ *   - getQueryByRoute: 智能获取路由参数（在 iframe 环境中从父级获取，否则从当前路由 query 获取）
+ */
+/**
+ * iframe 环境中的路由跳转工具函数（已迁移自 @deppon/deppon-utils）
+ */
+
+/**
+ * 检查是否在 iframe 环境中且父级支持 viewTab
+ * @returns {boolean} 是否支持 viewTab
+ */
+function isViewTabSupported() {
+  return typeof window !== 'undefined' && window.top && window.top !== window.self && typeof window.top.viewTab === 'function';
+}
+
+/**
+ * 从父级 iframe 获取参数
+ * @returns {Record<string, any>} 参数对象
+ */
+function getParentParams() {
+  if (typeof window === 'undefined' || !window.top || window.top === window.self) {
+    return {};
+  }
+  try {
+    var top = window.top;
+    if (top.Ext && top.Ext.getCmp && typeof top.Ext.getCmp === 'function') {
+      var mainAreaPanel = top.Ext.getCmp('mainAreaPanel');
+      if (mainAreaPanel && mainAreaPanel.params) {
+        return mainAreaPanel.params || {};
+      }
+    }
+  } catch (error) {
+    // 跨域或其他错误，返回空对象
+  }
+  return {};
+}
+
+/**
+ * 在 URL 后追加参数
+ * @param {string} url - 原始 URL
+ * @param {string} param - 要追加的参数（格式：key=value）
+ * @returns {string} 追加参数后的 URL
+ */
+function appendUrlParam(url, param) {
+  // 解析参数名
+  var _param$split = param.split('='),
+    _param$split2 = _slicedToArray(_param$split, 1),
+    key = _param$split2[0];
+
+  // 检查 URL 中是否已经存在该参数
+  // 使用正则表达式检查 query string 中是否已经包含该参数名
+  var paramPattern = new RegExp("[?&]".concat(key, "(=|&|$)"));
+  if (paramPattern.test(url)) {
+    // 如果参数已存在，直接返回原 URL
+    return url;
+  }
+  if (typeof window === 'undefined' || !window.top || window.top === window.self) {
+    // 降级处理：手动追加参数
+    var _separator = url.includes('?') ? '&' : '?';
+    return "".concat(url).concat(_separator).concat(param);
+  }
+  try {
+    var top = window.top;
+    if (top.Ext && top.Ext.urlAppend && typeof top.Ext.urlAppend === 'function') {
+      return top.Ext.urlAppend(url, param);
+    }
+  } catch (error) {
+  }
+
+  // 降级处理：手动追加参数
+  var separator = url.includes('?') ? '&' : '?';
+  return "".concat(url).concat(separator).concat(param);
+}
+
+/**
+ * 关闭当前标签页（内部函数）
+ * @param {string} url - 标签页 URL
+ * @param {string} type - 标签页类型（默认：'IFRAME'）
+ */
+function closeCurrentTabInternal(url) {
+  var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'IFRAME';
+  if (typeof window === 'undefined' || !window.top || window.top === window.self) {
+    return;
+  }
+  try {
+    var top = window.top;
+    if (top.closeTab && typeof top.closeTab === 'function') {
+      top.closeTab(url, type);
+    }
+  } catch (error) {
+  }
+}
+
+/**
+ * 在 iframe 环境中打开新标签页（通过父级的 viewTab 方法）
+ * @param {string} title - 标签页标题
+ * @param {string} url - 要打开的 URL
+ * @param {string} [viewType='iframe'] - 视图类型，默认为 'iframe'
+ * @param {Record<string, any> | null} [params=null] - 参数对象
+ * @param {Object} [options={}] - 配置选项
+ * @param {boolean} [options.appendIsUap=false] - 是否在 URL 后追加 isUap=true 参数（默认 false，不再自动追加）
+ * @returns {boolean} 是否成功调用 viewTab，如果不在 iframe 环境中返回 false
+ */
+function viewTab(title, url) {
+  var viewType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'iframe';
+  var params = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+  var options = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+  if (!isViewTabSupported()) {
+    return false;
+  }
+  try {
+    var top = window.top;
+    var _options$appendIsUap = options.appendIsUap,
+      appendIsUap = _options$appendIsUap === void 0 ? false : _options$appendIsUap,
+      restOptions = _objectWithoutProperties(options, _excluded);
+
+    // 如果需要追加 isUap 参数（默认不再追加）
+    var finalUrl = url;
+    if (appendIsUap) {
+      finalUrl = appendUrlParam(url, 'isUap=true');
+    }
+
+    // 调用父级的 viewTab 方法
+    top.viewTab(title, finalUrl, viewType, params, restOptions);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * 获取 viewTab 工具函数对象
+ * @returns {Object|null} viewTab 工具函数对象，如果不在 iframe 环境中返回 null
+ */
+function getViewTabUtils() {
+  // 直接返回本地函数，不再依赖 @deppon/deppon-utils
+  return {
+    isViewTabSupported: isViewTabSupported,
+    getParentParams: getParentParams,
+    appendUrlParam: appendUrlParam,
+    closeCurrentTab: closeCurrentTabInternal,
+    viewTab: viewTab
+  };
+}
+
+/**
+ * 合并 viewTab 配置（默认配置 + 传入配置，传入配置优先）
+ * @param {Object} defaultConfig - 默认配置
+ * @param {Object} userConfig - 用户传入的配置
+ * @returns {Object} 合并后的配置
+ */
+function mergeViewTabConfig(defaultConfig, userConfig) {
+  if (!defaultConfig) {
+    return userConfig || null;
+  }
+  if (!userConfig) {
+    return defaultConfig;
+  }
+  // 深度合并，userConfig 优先
+  return _objectSpread(_objectSpread(_objectSpread({}, defaultConfig), userConfig), {}, {
+    // uumsFunction 需要特殊处理（如果用户提供了，完全覆盖默认的）
+    uumsFunction: userConfig.uumsFunction || defaultConfig.uumsFunction
+  });
+}
+function createRouterUtils(router) {
+  var defaultViewTab = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  // 保存原始的 push 方法
+  var originalPush = router.push.bind(router);
+
+  /**
+   * 将路由位置转换为完整 URL
+   * @param {Object|String} location - 路由位置
+   * @returns {string} 完整 URL
+   */
+  function locationToUrl(location) {
+    if (typeof location === 'string') {
+      var _router$options$histo;
+      // 字符串路径
+      if (location.startsWith('http')) {
+        return location;
+      }
+      // 处理 hash 模式
+      var base = ((_router$options$histo = router.options.history) === null || _router$options$histo === void 0 ? void 0 : _router$options$histo.base) || '';
+      var isHash = base.includes('#') || typeof window !== 'undefined' && window.location.hash;
+      if (isHash && !location.startsWith('#')) {
+        return "".concat(window.location.origin, "/#").concat(location.startsWith('/') ? location : "/".concat(location));
+      }
+      return "".concat(window.location.origin).concat(location.startsWith('/') ? location : "/".concat(location));
+    }
+
+    // 使用 router.resolve 来正确解析路由（包括 params 和 query）
+    var resolved = router.resolve(location);
+    var url = resolved.href;
+
+    // 如果 href 是相对路径，添加 origin
+    if (!url.startsWith('http')) {
+      url = "".concat(window.location.origin).concat(url.startsWith('/') ? '' : '/').concat(url);
+    }
+    return url;
+  }
+  return {
+    /**
+     * 包装后的 push 方法，自动应用默认的 _viewTab 配置
+     * @param {Object|String} location - 路由位置
+     * @param {Function} onComplete - 成功回调
+     * @param {Function} onAbort - 失败回调
+     */
+    push: function push(location, onComplete, onAbort) {
+      // 直接调用 depponPush，它会自动处理默认配置
+      return this.depponPush(location, onComplete, onAbort);
+    },
+    /**
+     * 安全的路由跳转（带错误处理）
+     * @param {Object|String} location - 路由位置
+     * @param {Function} onComplete - 成功回调
+     * @param {Function} onAbort - 失败回调
+     */
+    safePush: function safePush(location, onComplete, onAbort) {
+      return originalPush(location)["catch"](function (err) {
+        // 忽略导航重复的错误
+        if (err.name !== 'NavigationDuplicated') {
+          if (onAbort) {
+            onAbort(err);
+          }
+        }
+      }).then(function () {
+        if (onComplete) {
+          onComplete();
+        }
+      });
+    },
+    /**
+     * 安全的路由替换（带错误处理）
+     * @param {Object|String} location - 路由位置
+     * @param {Function} onComplete - 成功回调
+     * @param {Function} onAbort - 失败回调
+     */
+    safeReplace: function safeReplace(location, onComplete, onAbort) {
+      return router.replace(location)["catch"](function (err) {
+        if (err.name !== 'NavigationDuplicated') {
+          if (onAbort) {
+            onAbort(err);
+          }
+        }
+      }).then(function () {
+        if (onComplete) {
+          onComplete();
+        }
+      });
+    },
+    /**
+     * 根据路由名称跳转
+     * @param {String} name - 路由名称
+     * @param {Object} params - 路由参数
+     * @param {Object} query - 查询参数
+     */
+    pushByName: function pushByName(name) {
+      var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var query = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      return this.safePush({
+        name: name,
+        params: params,
+        query: query
+      });
+    },
+    /**
+     * 根据路由路径跳转
+     * @param {String} path - 路由路径
+     * @param {Object} query - 查询参数
+     */
+    pushByPath: function pushByPath(path) {
+      var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      return this.safePush({
+        path: path,
+        query: query
+      });
+    },
+    /**
+     * 返回上一页
+     * @param {Number} delta - 返回的步数，默认为 1
+     */
+    goBack: function goBack() {
+      var delta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      router.go(-delta);
+    },
+    /**
+     * 关闭当前标签页
+     * @param {string} [url] - 标签页 URL（默认使用当前页面的 location.href）
+     * @param {string} [type='IFRAME'] - 标签页类型（默认：'IFRAME'）
+     */
+    closeCurrentTab: function closeCurrentTab(url) {
+      var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'IFRAME';
+      var utils = getViewTabUtils();
+
+      // 判断是否应该使用 viewTab（与 depponPush 逻辑一致）
+      var shouldUseViewTab = utils && utils.isViewTabSupported && utils.isViewTabSupported();
+      if (shouldUseViewTab && utils) {
+        // 在 iframe 环境中使用 viewTab 关闭标签页
+        var tabUrl = url || (typeof window !== 'undefined' ? window.location.href : '');
+        return closeCurrentTabInternal(tabUrl, type);
+      } else {
+        // 降级处理：使用 router 常规的返回
+        router.go(-1);
+      }
+    },
+    /**
+     * 检查路由是否存在（包括动态添加的路由）
+     * @param {String} name - 路由名称
+     * @returns {Boolean}
+     */
+    hasRoute: function hasRoute(name) {
+      // 使用 getRoutes() 获取所有路由（包括动态添加的），而不仅仅是初始路由
+      return router.getRoutes().some(function (route) {
+        return route.name === name;
+      });
+    },
+    /**
+     * 获取路由配置（包括动态添加的路由）
+     * @param {String} name - 路由名称
+     * @returns {Object|null}
+     */
+    getRouteConfig: function getRouteConfig(name) {
+      // 使用 getRoutes() 获取所有路由（包括动态添加的），而不仅仅是初始路由
+      return router.getRoutes().find(function (route) {
+        return route.name === name;
+      }) || null;
+    },
+    /**
+     * 智能获取路由参数：在 iframe 环境中优先从父级获取，否则从当前路由 query 获取
+     * 与 depponPush 的参数获取逻辑保持一致
+     * @param {String} [key] - 参数键名，如果不提供则返回所有参数对象
+     * @returns {any} 参数值（如果提供了 key）或参数对象（如果未提供 key）
+     *
+     * @example
+     * // 获取所有参数
+     * const params = router.getQueryByRoute();
+     *
+     * // 获取指定参数
+     * const sourceType = router.getQueryByRoute('sourceType');
+     */
+    getQueryByRoute: function getQueryByRoute(key) {
+      var utils = getViewTabUtils();
+      var params = {};
+
+      // 如果在 iframe 环境中且支持 viewTab，优先从父级获取参数
+      if (utils && utils.isViewTabSupported && utils.isViewTabSupported()) {
+        // 优先从父级获取 params（与 depponPush 逻辑一致）
+        var parentParams = utils.getParentParams && utils.getParentParams() || {};
+        // 同时从当前路由 query 获取参数（合并两者，query 优先级更高）
+        var queryParams = router.currentRoute.value.query || {};
+        // 合并参数：父级 params 作为基础，query 参数覆盖同名参数
+        params = _objectSpread(_objectSpread({}, parentParams), queryParams);
+      } else {
+        // 否则从当前路由 query 获取
+        params = router.currentRoute.value.query || {};
+      }
+
+      // 如果提供了 key，返回对应的值；否则返回所有参数
+      return key ? params[key] || null : params;
+    },
+    /**
+     * 智能路由跳转：在 iframe 环境中自动使用 viewTab，否则使用 router.push
+     * 参数传递方式与 router.push 完全一致，在 iframe 环境中会自动适配 viewTab
+     * @param {Object|String} location - 路由位置（与 router.push 一致）
+     *   - 如果是字符串：路径字符串，如 '/home' 或 '/home?id=1'
+     *   - 如果是对象，可以包含以下属性：
+     *     - path: 路径
+     *     - name: 路由名称
+     *     - params: 路由参数（在 iframe 环境中会传递给 viewTab 的 params）
+     *     - query: 查询参数（会转换为 URL 的 query string）
+     *     - _viewTab: viewTab 选项对象（可选，仅在 iframe 环境中生效）
+     *       - title: 标签页标题（默认使用路由 meta.title 或 '新页面'）
+     *       - uumsFunction: UUMS 功能配置
+     *         - functionCode: 功能代码
+     *         - sourceSystem: 来源系统
+     *       - closeCurrentTab: 是否关闭当前标签页（默认 false）
+     * @param {Function} [onComplete] - 成功回调（与 router.push 一致）
+     * @param {Function} [onAbort] - 失败回调（与 router.push 一致）
+     * @returns {Promise} 跳转 Promise
+     *
+     * @example
+     * // 基本用法（与 router.push 完全一致，在 iframe 环境中自动使用 viewTab）
+     * router.depponPush('/home');
+     * router.depponPush({ path: '/home', query: { id: 1 } });
+     * router.depponPush({ name: 'Home', params: { id: 1 } });
+     *
+     * // 在 iframe 环境中自定义 viewTab 选项
+     * router.depponPush({
+     *   path: '/preferInfo',
+     *   query: { sourceType: 'insert' },
+     *   params: { custNumber: '701265308', preferId: '1312' },
+     *   _viewTab: {
+     *     title: 'CMC-产品折扣新增',
+     *     uumsFunction: {
+     *       functionCode: 'CMC_FUNCTION_00002',
+     *       sourceSystem: 'CMC',
+     *     },
+     *     closeCurrentTab: true,
+     *   },
+     * });
+     *
+     * // 替换原有代码示例：
+     * // 原代码：
+     * // if (top.viewTab) {
+     * //   let params = { sourceType: 'insert' };
+     * //   let url = location.origin + '/#/preferInfo?sourceType=insert';
+     * //   let tabUrl = top.Ext.urlAppend(url, 'isUap=true');
+     * //   top.closeTab(tabUrl, 'IFRAME');
+     * //   top.viewTab('CMC-产品折扣新增', url, 'iframe', params, { ... });
+     * // } else {
+     * //   this.$router.push({ path: '/preferInfo', query: { sourceType: 'insert' } });
+     * // }
+     * //
+     * // 新代码（自动适配）：
+     * router.depponPush({
+     *   path: '/preferInfo',
+     *   query: { sourceType: 'insert' },
+     *   params: { sourceType: 'insert' },
+     *   _viewTab: {
+     *     title: 'CMC-产品折扣新增',
+     *     uumsFunction: {
+     *       functionCode: 'CMC_FUNCTION_00002',
+     *       sourceSystem: 'CMC',
+     *     },
+     *     closeCurrentTab: true,
+     *   },
+     * });
+     */
+    depponPush: function depponPush(location, onComplete, onAbort) {
+      var utils = getViewTabUtils();
+
+      // 提取 viewTab 选项（如果存在），并合并默认配置
+      var viewTabOptions = null;
+      var cleanLocation = location;
+      // 记录用户是否明确提供了 title（在 _viewTab 中）
+      var userProvidedTitle = null;
+      if (location && _typeof(location) === 'object' && location._viewTab) {
+        // 检查用户是否明确提供了 title
+        userProvidedTitle = location._viewTab.title;
+        // 合并默认配置和用户配置（用户配置优先）
+        viewTabOptions = mergeViewTabConfig(defaultViewTab, location._viewTab);
+        // 创建清理后的 location 对象（移除 _viewTab）
+        cleanLocation = _objectSpread({}, location);
+        delete cleanLocation._viewTab;
+      } else if (defaultViewTab) {
+        // 如果用户没有提供 _viewTab，但有默认配置，使用默认配置
+        viewTabOptions = defaultViewTab;
+      }
+
+      // 如果支持 viewTab 且在 iframe 环境中，或者明确提供了 viewTabOptions（强制使用 viewTab）
+      var shouldUseViewTab = utils && utils.isViewTabSupported && utils.isViewTabSupported() || viewTabOptions !== null;
+      if (shouldUseViewTab && utils) {
+        try {
+          // 如果没有提供 viewTabOptions，使用默认值
+          var defaultOptions = viewTabOptions || {};
+          var uumsFunction = defaultOptions.uumsFunction,
+            _defaultOptions$close = defaultOptions.closeCurrentTab,
+            closeCurrentTab = _defaultOptions$close === void 0 ? false : _defaultOptions$close,
+            restOptions = _objectWithoutProperties(defaultOptions, _excluded2);
+
+          // 构建完整 URL（使用清理后的 location）
+          var url = locationToUrl(cleanLocation);
+
+          // 获取标题的优先级：用户明确提供的 title > 目标路由的 meta.title > defaultViewTab.title > '新页面'
+          var finalTitle = null;
+
+          // 1. 如果用户明确提供了 title，使用用户的 title
+          if (userProvidedTitle !== null && userProvidedTitle !== undefined) {
+            finalTitle = userProvidedTitle;
+          } else {
+            // 2. 尝试从目标路由的 meta.title 中获取
+            try {
+              // 解析目标路由，获取其 meta.title
+              var resolved = router.resolve(cleanLocation);
+              if (resolved.matched && resolved.matched.length > 0) {
+                var _targetRoute$meta;
+                // 获取最后一个匹配的路由（最具体的路由）
+                var targetRoute = resolved.matched[resolved.matched.length - 1];
+                finalTitle = (_targetRoute$meta = targetRoute.meta) === null || _targetRoute$meta === void 0 ? void 0 : _targetRoute$meta.title;
+              }
+            } catch (error) {
+            }
+
+            // 3. 如果目标路由没有 title，使用默认配置的 title
+            if (!finalTitle && defaultViewTab && defaultViewTab.title) {
+              finalTitle = defaultViewTab.title;
+            }
+
+            // 4. 最后使用默认值
+            if (!finalTitle) {
+              finalTitle = '新页面';
+            }
+          }
+
+          // 获取参数（优先使用 location.params，其次从父级获取）
+          var params = null;
+          if (cleanLocation && _typeof(cleanLocation) === 'object' && cleanLocation.params) {
+            params = cleanLocation.params;
+          } else if (utils.getParentParams) {
+            params = utils.getParentParams();
+          }
+
+          // 使用 viewTab 跳转（即使 isViewTabSupported 返回 false，如果提供了 viewTabOptions 也尝试调用）
+          if (utils.viewTab) {
+            // 如果需要关闭当前标签页，在调用 viewTab 之前先关闭
+            // 使用当前页面的实际 URL（location.href），这样可以正确匹配包含动态参数的 URL
+            if (closeCurrentTab) {
+              var currentUrl = typeof window !== 'undefined' ? window.location.href : '';
+              if (currentUrl && utils.closeCurrentTab) {
+                utils.closeCurrentTab(currentUrl, 'IFRAME');
+              }
+            }
+
+            // 不再自动追加 isUap 参数，默认 appendIsUap 为 false
+            var success = utils.viewTab(finalTitle, url, 'iframe', params, _objectSpread({
+              uumsFunction: uumsFunction,
+              appendIsUap: false
+            }, restOptions));
+            if (success) {
+              if (onComplete) {
+                onComplete();
+              }
+              return Promise.resolve();
+            }
+          }
+        } catch (error) {
+        }
+      }
+
+      // 降级处理：使用普通 push（使用清理后的 location）
+      return this.safePush(cleanLocation, onComplete, onAbort);
+    }
+  };
+}
+
+export { createRouterUtils };

package/es/vue.d.ts

@@ -0,0 +1,16 @@
+declare namespace _default {
+    export { install };
+}
+export default _default;
+/**
+ * Vue 插件安装函数
+ * @param {Object} app - Vue 应用实例
+ * @param {Object|Array} options - 配置选项或路由配置数组
+ * @param {Object} options.router - 已创建的 router 实例（如果提供，将直接使用）
+ * @param {Array} options.routes - 路由配置数组
+ * @param {Object} options.routerOptions - Vue Router 原始配置选项
+ * @param {Object} options.guards - 路由守卫配置
+ * @param {Object} options.log - 日志实例（可选，用于路由追踪）
+ * @param {Function} options.onRouteChange - 路由变化回调（可选）
+ */
+declare function install(app: Object, options?: Object | any[]): void;

package/es/vue.js

@@ -0,0 +1,42 @@
+import './_virtual/_rollup-plugin-inject-process-env.js';
+import { createDepponRouter } from './index.js';
+
+/**
+ * Vue 插件安装函数
+ * @param {Object} app - Vue 应用实例
+ * @param {Object|Array} options - 配置选项或路由配置数组
+ * @param {Object} options.router - 已创建的 router 实例（如果提供，将直接使用）
+ * @param {Array} options.routes - 路由配置数组
+ * @param {Object} options.routerOptions - Vue Router 原始配置选项
+ * @param {Object} options.guards - 路由守卫配置
+ * @param {Object} options.log - 日志实例（可选，用于路由追踪）
+ * @param {Function} options.onRouteChange - 路由变化回调（可选）
+ */
+function install(app) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var router;
+
+  // 如果传入的是 router 实例，直接使用
+  if (options && options.router) {
+    router = options.router;
+  } else {
+    // 否则创建新的路由实例
+    router = createDepponRouter(options);
+  }
+
+  // 安装 Vue Router
+  app.use(router);
+
+  // 注册全局属性（可选，用于 Options API）
+  app.config.globalProperties.$router = router;
+  // 注意：Vue Router 4 已在全局原型上定义只读的 $route，勿手动覆盖
+  // app.config.globalProperties.$route = router.currentRoute;
+
+  // 提供实例，供 Composition API 使用
+  app.provide('depponRouter', router);
+}
+var vue = {
+  install: install
+};
+
+export { vue as default };

package/package.json

@@ -0,0 +1,46 @@
+{
+    "name": "@deppon/deppon-router",
+    "version": "2.1.1",
+    "description": "德邦前端 Vue Router 4 封装包",
+    "license": "MIT",
+    "homepage": "",
+    "keywords": [
+        "router",
+        "vue-router",
+        "vue-router4",
+        "vue",
+        "vue3",
+        "vue-plugin"
+    ],
+    "author": {
+        "name": "",
+        "email": ""
+    },
+    "main": "es/index.js",
+    "module": "es/index.js",
+    "typings": "es/index.d.ts",
+    "sideEffects": false,
+    "scripts": {
+        "build": "ts-node build.ts",
+        "publish:auto": "npm publish"
+    },
+    "publishConfig": {
+        "registry": "https://devrepo.devcloud.cn-east-3.huaweicloud.com/artgalaxy/api/npm/cn-east-3_8a2e1f0ee52d4adb9a0a6998d78d0dda_npm_1/"
+    },
+    "files": [
+        "es"
+    ],
+    "repository": {
+        "type": "git",
+        "url": ""
+    },
+    "dependencies": {
+        "@babel/runtime": "^7.17.7",
+        "vue-router": "^4.0.0"
+    },
+    "peerDependencies": {
+        "vue": "^3.0.0",
+        "vue-router": "^4.0.0"
+    },
+    "gitHead": "1f329a64567c2e22df7860b0918ebe3427718945"
+}