@bams-app/router 0.0.1

package/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar"]
+}

package/README.md

@@ -0,0 +1,174 @@
+# @bams-app/router
+
+BAMS-Work 平台的路由包，提供完整的路由体系：静态路由表构建、全局权限守卫、菜单驱动的动态路由注册，以及 404 / 403 / 500 错误页与登录中间件。
+
+## 目录结构
+
+```
+src/
+├── index.js                    # 包入口（对外导出）
+├── createRouterInstance.js     # 独立创建 router 实例（开发调试用）
+├── createRoutes.js             # 构建静态路由表
+├── routerController.js         # 全局前置守卫（beforeEach）
+├── registerRoutes.js           # 动态路由注册与权限判断工具
+└── components/
+    ├── LoginMiddleware.vue     # 登录中间件页面（/auth/login）
+    ├── NoPermission/index.vue  # 403 无权限页（挂载于 work 布局内）
+    ├── NotFound/index.vue      # 404 页面不存在
+    ├── SystemError/index.vue   # 500 系统错误页
+    ├── Loading/index.vue       # 异步组件加载中
+    └── Error/index.vue         # 业务页面组件加载失败提示
+```
+
+## 快速开始（应用集成）
+
+真实应用通过 `@bams-app/base` 接入本包，由 base 完成路由注册与守卫挂载：
+
+```js
+// apps/bams-app/src/main.js
+import { createApp } from "vue";
+import App from "./App.vue";
+import router from "./router";
+import bamsBase from "@bams-app/base";
+import WorkLayout from "@configurable/startr-layout"; // 菜单布局组件
+
+// 注册业务页面组件到 window.ui（权限模型依赖该注册表区分 403/404）
+import * as uiComponents from "@components-entry";
+window.ui = Object.assign(window.ui || {}, uiComponents);
+
+const app = createApp(App);
+app.use(bamsBase, { router, WorkLayout });
+app.$mount("#bams-app");
+```
+
+`@bams-app/base` 内部会调用 `createRoutes(WorkLayout, router.getRoutes(), appConfig)` 生成路由表并逐个 `addRoute`，然后挂载 `router.beforeEach(routerController)`。
+
+`createRouterInstance` 仅用于独立开发/调试（守卫在内部默认注释，便于脱离完整应用跑通基础路由）。
+
+## 路由表结构
+
+由 `createRoutes(workLayout, routes, appConfig)` 构建，`appConfig.defaultHome` 可指定默认首页（缺省 `pageHome`）：
+
+| 路径 | name | 说明 |
+|---|---|---|
+| `/auth/login` | `authLogin` | 登录中间件页（匿名可访问） |
+| `/login`、`/register` | `login`、`register` | 占位页，应用可注入同名路由覆盖 |
+| `/:channel?/:projectId/work/` | `work` | 业务主布局路由，`children` 含 `403` 无权限页 |
+| `/:channel?/:projectId/render/` | `render` | 渲染页（复用 `PublicContentView`） |
+| `/:channel?/:projectId/anon/` | `anon` | 公开页（复用 `PublicContentView`，登录白名单） |
+| `/404` | `404` | 页面不存在 |
+| `/500` | `500` | 系统错误 |
+| — | — | 末尾展开应用自定义路由（如 `/`、`/portal`） |
+
+> 说明：work 根路径的 `redirect` 必须使用函数而非字符串拼接，否则 vue-router 会把 `:channel?` 中的 `?` 当作查询串分隔符解析，导致重定向目标错误跳 404。
+
+## 用户登录流程
+
+```mermaid
+flowchart TD
+    START([用户访问页面]) --> Q1{URL 携带<br/>token/sessionId?}
+
+    subgraph AUTH_MID[登录中间件 /auth/login]
+        Q1 -- 是 --> AUTH[消费 token 同步会话]
+        AUTH --> Q2{会话同步成功?}
+        Q2 -- 是 --> REDIRECT[清理登录参数后回跳<br/>getSafeRedirectPath]
+        Q2 -- 否 --> LOGIN
+    end
+
+    subgraph ACCOUNT_LOGIN[账号密码登录 /login]
+        Q1 -- 否 --> Q3{本地已登录?<br/>checkLogin}
+        Q3 -- 否 --> LOGIN[输入账号密码登录]
+        LOGIN -- 成功 --> FETCH[拉取用户菜单并缓存<br/>localStorage 持久化]
+        Q3 -- 是 --> ROUTE[进入路由守卫分流]
+        FETCH --> REDIRECT
+        REDIRECT --> ROUTE
+    end
+
+    subgraph GUARD[路由守卫分流]
+        ROUTE --> Q4{work 路由?}
+        Q4 -- 是 --> Q5{菜单缓存为空?}
+        Q5 -- 是 --> LOAD[拉取菜单<br/>getMenuList]
+        LOAD -- 失败 --> ERR[/500 系统错误页/]
+        LOAD -- 成功 --> REG[幂等注册菜单路由<br/>registerRoutesByMenu]
+        Q5 -- 否 --> REG
+        REG --> Q6{页面有权限?<br/>hasRoute 通过}
+        Q6 -- 是 --> DONE([渲染业务页面])
+        Q6 -- 否 --> FORBID[/403 无权限 或 404 不存在<br/>按 window.ui 区分/]
+        Q4 -- 否 --> Q7{路由已注册?}
+        Q7 -- 是 --> DONE
+        Q7 -- 否 --> REG2[动态注册 render/anon 路由]
+        REG2 --> DONE
+    end
+```
+
+## 全局守卫流程（routerController）
+
+守卫按顺序处理，命中即返回：
+
+1. **URL 携带 token**：`to.query.token` 存在且不在 `/auth/login` → 跳转 `/auth/login` 走登录中间件同步会话。
+2. **未登录**：非匿名路由（`login`/`register`/`allowAnonymous`/`/anon/` 前缀）一律跳转 `/login`，携带 `sysCode` 与 `callback_url` 以便登录后回跳。
+3. **work 路由**（`/.../work/...`）：
+   - 菜单缓存为空时先拉取菜单（失败 → 跳 `/500`，携带 `source: "获取菜单失败"`）；
+   - 缓存过期（`isMenuStale`）静默刷新，失败沿用旧缓存；
+   - 幂等批量注册全部菜单路由（`registerRoutesByMenu`）；
+   - 当前导航尚未匹配（`to.matched.length === 0`，即首次访问动态页）：页面在菜单中或为 `pageHome` 则重导航，否则按权限跳 403/404；
+   - 已匹配：`hasRoute` 通过则放行，否则跳 403/404。
+4. **render/anon 等其余路由**：`hasRoute` 通过则放行，否则按 `registerRoutes` 动态注册。
+
+## 核心 API
+
+包入口 `index.js` 全部导出：
+
+| 导出 | 说明 |
+|---|---|
+| `createRoutes(workLayout, routes, appConfig)` | 构建静态路由表 |
+| `routerController` | 全局前置守卫（需 `this` 绑定 router） |
+| `hasRoute(to)` | 判断目标路由是否已注册（`this` 绑定 router） |
+| `registerRoutes(to, from, next)` | 单个动态路由注册（render/anon），含重复注册死循环保护 |
+| `registerRoutesByMenu(router)` | 按菜单幂等批量注册 work 动态路由，并补注 `pageHome` |
+| `toNoPermissionOrNotFound(pageId, fromPath)` | 构造 403（页面存在但无权限）或 404（页面不存在）跳转目标 |
+| `DEFAULT_HOME` | 默认首页 `pageHome` |
+| `createRouterInstance(appConfig)` | 独立创建 router 实例（开发调试用） |
+
+## 权限模型
+
+权限由两个维度共同决定：
+
+| 条件 | 结果 |
+|---|---|
+| 页面组件存在（`window.ui[id]`）**且**在用户菜单中 | 正常访问 |
+| 页面组件存在但不在菜单中 | 403 无权限（`toNoPermissionOrNotFound` → `/work/403`） |
+| 页面组件不存在 | 404 页面不存在（`toNoPermissionOrNotFound` → `/404`） |
+| 在菜单中但组件未实现 | 注册成功，渲染 `Error` 加载失败提示 |
+
+- **菜单**：由后端按用户权限返回（`getResourceByUserTree`），无权限菜单不会下发，对应路由不会被注册，权限天然由菜单保证。
+- **window.ui**：前端各业务页面组件的注册表，守卫据此区分"无权限"与"不存在"。
+
+## 动态路由注册
+
+- 菜单路由：`registerRoutesByMenu` 遍历 `menuStore.menuPathMap`，对每个页面调用 `createRoute(id)` 注册为 work 子路由，幂等（已注册跳过）。
+- `createRoute(id)`：iframe 菜单（`openType === "1"`）使用 `EmptyIframeRoute` 空占位组件（内容由内容区的 `BamsIframe` 渲染），普通菜单使用 `CheckAuthWorkPage(id)`。
+- `CheckAuthWorkPage`：异步加载 `window.ui[routeName]`，配合 `Loading`（延迟 500ms 显示）与 `Error` 加载失败组件；通过 `defer()` 与 `window.__currWorkRoute__` 实现路由级权限确认（`resolve` 渲染业务页，`reject` 显示无权限）。
+
+## 错误页体系
+
+| 页面 | 触发场景 | 布局 | 展示信息 | 操作 |
+|---|---|---|---|---|
+| 403（`NoPermission`） | 页面组件存在但无权限 | **work 菜单布局内**（保留菜单便于继续导航） | 来源地址 | 返回上一步 |
+| 404（`NotFound`） | 页面组件不存在 / 路由匹配失败 | 顶层独立页 | 来源地址 | 返回上一步 + 回到系统首页/返回首页 |
+| 500（`SystemError`） | 获取菜单失败等系统错误 | 顶层独立页 | 错误来源、错误信息、访问地址 | 返回上一步 + 回到系统首页 |
+
+- 所有错误页通过 `from` query 参数展示来源地址，便于排查是哪个地址触发的错误。
+- 403 作为 work 布局的静态子路由，`hasRoute` 命中后守卫直接放行，不会再次进入权限判断造成循环。
+- 顶层 `/403` 已移除，直接访问 `/403` 会落到 404（403 只在 work 上下文内产生）。
+
+## 登录中间件（LoginMiddleware）
+
+`/auth/login` 页面负责消费 URL 携带的登录参数（`token`/`sessionId`/`accountId` 等），完成会话同步后通过 `getSafeRedirectPath(redirect)` 跳回原地址。该函数会剔除全部登录敏感参数，保证回跳 URL 不再携带 token，避免与守卫的 token 分支构成死循环。
+
+## 设计要点与常见问题
+
+- **为何 403 放在 work 布局内？** 403 只会在 work 路由的权限判断中触发，放入布局子路由可保留菜单/页签，用户被拒绝访问后仍能自由导航。
+- **重导航为何不会死循环？** 动态路由注册后 `hasRoute` 必为 true，`registerRoutes` 对重复注册有显式保护；403/404/500 均为静态路由，守卫对其直接放行。
+- **`hasRoute` 中的 `/` 特判**：根路径由应用自身路由（如 `redirect: "/portal"`）处理，该特判作为兜底。
+- **历史记录**：错误页跳转使用 `replace: true`，不污染浏览器历史；错误页"回到首页"使用 `window.location.replace`，避免产生多余历史记录。

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@bams-app/router",
+  "version": "0.0.1",
+  "private": false,
+  "type": "module",
+  "main": "src/index.js",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "preview": "vite preview"
+  },
+  "peerDependencies": {
+    "vue": "^3.2.0",
+    "vue-router": "^4.0.0"
+  },
+  "dependencies": {
+    "@bams-app/api-model": "*",
+    "@bams-app/app-layout": "*",
+    "@bams-app/store": "*",
+    "@bams-app/utils": "*",
+    "axios": "^1.13.2"
+  },
+  "devDependencies": {
+    "@vitejs/plugin-vue": "^6.0.1",
+    "vite": "^7.2.4",
+    "vue": "^3.5.24",
+    "vue-router": "4"
+  }
+}

package/src/components/Error/index.vue

@@ -0,0 +1,21 @@
+<template>
+  <div class="error-container" :style="{ backgroundImage: `url(${bgImg})` }"></div>
+</template>
+
+<script setup>
+  import bgImg from "./image.png";
+</script>
+
+<style scoped>
+  .error-container {
+    width: 100%;
+    height: 100%;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    background-color: var(--bams-page-bg);
+    background-repeat: no-repeat;
+    background-position: center;
+    background-size: contain;
+  }
+</style>

package/src/components/Loading/index.vue

@@ -0,0 +1,48 @@
+<template>
+  <div class="loading-container">
+    <div class="loading-spinner"></div>
+    <div class="loading-text">加载中</div>
+  </div>
+</template>
+
+<script setup>
+  // Vue3组合式API
+</script>
+
+<style scoped>
+  .loading-container {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: color-mix(in srgb, var(--bams-surface-bg) 92%, transparent);
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    align-items: center;
+    z-index: 9999;
+  }
+
+  .loading-spinner {
+    width: 50px;
+    height: 50px;
+    border: 4px solid color-mix(in srgb, var(--bams-border-color) 30%, transparent);
+    border-top-color: var(--bams-primary);
+    border-radius: 50%;
+    animation: spin 1s linear infinite;
+  }
+
+  @keyframes spin {
+    to {
+      transform: rotate(360deg);
+    }
+  }
+
+  .loading-text {
+    margin-top: 20px;
+    color: var(--bams-text-color);
+    font-size: 16px;
+    font-weight: 500;
+  }
+</style>

package/src/components/LoginMiddleware.vue

@@ -0,0 +1,152 @@
+<template>
+  <div class="login-middleware">
+    <div v-if="loading" class="loading-state">
+      <a-spin size="large" tip="正在登录中，请稍候..." />
+    </div>
+    <div v-else-if="errorMessage" class="error-state">
+      <a-result status="error" title="登录失败" :sub-title="errorMessage">
+        <template #extra>
+          <a-button type="primary" @click="handleGoLogin">去登录</a-button>
+        </template>
+      </a-result>
+    </div>
+  </div>
+</template>
+
+<script setup>
+  import { onMounted, ref } from "vue";
+  import { useRoute, useRouter } from "vue-router";
+  import { useUserStore } from "@bams-app/store";
+  import { sysApi } from "@bams-app/api-model";
+  import * as utils from "@bams-app/utils";
+  import axios from "axios";
+
+  const route = useRoute();
+  const router = useRouter();
+  const userStore = useUserStore();
+  const loading = ref(true);
+  const errorMessage = ref("");
+
+  const buildCallbackUrl = target => {
+    const safeRedirectPath = getSafeRedirectPath(target);
+    const redirectUrl = new URL(safeRedirectPath, window.location.origin);
+    const { BASE_URL = "/" } = utils.env.getEnv();
+    const normalizedBaseUrl = BASE_URL === "/" ? "/" : `/${String(BASE_URL).replace(/^\/+|\/+$/g, "")}/`;
+
+    if (normalizedBaseUrl !== "/" && !redirectUrl.pathname.startsWith(normalizedBaseUrl)) {
+      redirectUrl.pathname = `${normalizedBaseUrl.replace(/\/$/, "")}/${redirectUrl.pathname.replace(/^\/+/, "")}`;
+    }
+
+    return redirectUrl.toString();
+  };
+
+  const handleGoLogin = () => {
+    const { redirect } = route.query;
+    utils.auth.redirectToLoginPage({
+      callbackPath: buildCallbackUrl(redirect),
+    });
+  };
+
+  /**
+   * 获取安全的跳转路径，移除 URL 中的登录相关参数
+   */
+  const getSafeRedirectPath = target => {
+    let targetPath = target || "/";
+    try {
+      const url = new URL(targetPath, window.location.origin);
+      const paramsToDelete = ["sessionId", "token", "accountId", "appRoleId", "corpCode", "menuType", "sysCode", "sessionExpire"];
+      paramsToDelete.forEach(param => url.searchParams.delete(param));
+      // 如果是同域跳转，保留相对路径
+      return url.pathname + url.search + url.hash;
+    } catch (e) {
+      // 如果解析失败，简单处理，只保留路径部分
+      return targetPath.split("?")[0];
+    }
+  };
+
+  onMounted(async () => {
+    const { sessionId, token, menuType, accountId, redirect, sysCode } = route.query;
+
+    // 1. 如果已经登录（登录组件已在本页建立会话），直接回跳，
+    // 避免再次调用 getAccountData，同时避免二次请求失败时把已建立的会话清掉
+    // if (userStore.checkLogin() || auth.isLogin()) {
+    //   router.replace(getSafeRedirectPath(redirect));
+    //   return;
+    // }
+
+    if (!token) {
+      errorMessage.value = "登录参数缺失 (token)，请通过正确渠道访问系统。";
+      loading.value = false;
+      return;
+    }
+
+    try {
+      // 调用 getAccountData 接口获取用户信息
+      const res = await axios.get("/admin-api/dac/gate/getAccountData?token=" + token, {
+        headers: {
+          sysCode: sysCode,
+          sessionid: sessionId,
+        },
+      });
+
+      if (res.data.code != 200) {
+        throw new Error(res.data.msg || "获取用户信息失败");
+      }
+
+      const userData = res.data.data;
+      if (!userData || (typeof userData === "object" && !Array.isArray(userData) && Object.keys(userData).length === 0)) {
+        throw new Error("用户信息为空，token 已失效");
+      }
+
+      userStore.login({
+        userId: userData.userId,
+        userName: userData.userName,
+        phone: userData.phone,
+        orgName: userData.orgName,
+        orgCode: userData.orgCode,
+        token,
+        sessionId,
+        menuType,
+        accountId: userData.accountId || accountId,
+        role: "user",
+        permissionMap: {},
+        data: userData,
+      });
+
+      // message.success("登录成功");
+
+      // 登录成功后拉取一次按钮权限表（失败不影响跳转，独立 try/catch 包裹）
+      try {
+        const permData = await sysApi.getButtonsBySessionld({ sysCode: sysCode }, { sessionId: sessionId });
+        userStore.setPermissions(permData.buttons || {});
+      } catch (error) {
+        console.error("获取按钮权限失败:", error);
+      }
+
+      // 跳转回目标页面或首页，并移除 URL 中的 sessionId 等登录参数
+      router.replace(getSafeRedirectPath(redirect));
+    } catch (error) {
+      console.error("中间件登录失败:", error);
+      userStore.logout();
+      errorMessage.value = "登录校验失败，请检查会话是否有效。";
+    } finally {
+      loading.value = false;
+    }
+  });
+</script>
+
+<style scoped>
+  .login-middleware {
+    height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: var(--bams-page-bg);
+  }
+  .loading-state,
+  .error-state {
+    width: 100%;
+    max-width: 500px;
+    text-align: center;
+  }
+</style>

package/src/components/NoPermission/index.vue

@@ -0,0 +1,42 @@
+<template>
+  <div class="no-permission-container">
+    <a-result status="403" title="403" :sub-title="subTitle">
+      <template #extra>
+        <a-button type="primary" @click="goBack">返回上一步</a-button>
+      </template>
+    </a-result>
+  </div>
+</template>
+
+<script setup>
+  import { computed } from "vue";
+  import { useRoute, useRouter } from "vue-router";
+
+  const route = useRoute();
+  const router = useRouter();
+
+  const fromPath = computed(() => (typeof route.query.from === "string" ? route.query.from : ""));
+  const currentPath = computed(() => fromPath.value || route.fullPath);
+  const subTitle = computed(() => `抱歉，您没有权限访问该页面。访问地址：${currentPath.value}`);
+
+  const goBack = () => {
+    if (window.history.length > 1) {
+      router.back();
+      return;
+    }
+    // 历史记录不足时兜底回到系统首页（403 必然处于 work 布局下）
+    const match = currentPath.value.match(/^(\/.*\/work\/).*$/);
+    const targetPath = match ? `${match[1]}pageHome` : "/";
+    window.location.replace(router.resolve(targetPath).href);
+  };
+</script>
+
+<style scoped>
+  .no-permission-container {
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--bams-page-bg);
+  }
+</style>

package/src/components/NotFound/index.vue

@@ -0,0 +1,53 @@
+<template>
+  <div class="not-found-container">
+    <a-result status="404" title="404" :sub-title="subTitle">
+      <template #extra>
+        <a-button @click="goBack">返回上一步</a-button>
+        <a-button type="primary" @click="goHome">{{ backButtonText }}</a-button>
+      </template>
+    </a-result>
+  </div>
+</template>
+
+<script setup>
+  import { computed } from "vue";
+  import { useRoute, useRouter } from "vue-router";
+
+  const route = useRoute();
+  const router = useRouter();
+
+  const fromPath = computed(() => (typeof route.query.from === "string" ? route.query.from : ""));
+  const notFoundPath = computed(() => fromPath.value || route.fullPath);
+  const subTitle = computed(() => `抱歉，您访问的页面不存在。访问地址：${notFoundPath.value}`);
+  const isFromWork = computed(() => fromPath.value.includes("/work/"));
+  const backButtonText = computed(() => (isFromWork.value ? "回到系统首页" : "返回首页"));
+
+  const goHome = () => {
+    let targetPath = "/";
+    if (isFromWork.value) {
+      const match = fromPath.value.match(/^(\/.*\/work\/).*$/);
+      if (match) {
+        targetPath = `${match[1]}pageHome`;
+      }
+    }
+    window.location.replace(router.resolve(targetPath).href);
+  };
+
+  const goBack = () => {
+    if (window.history.length > 1) {
+      router.back();
+    } else {
+      goHome();
+    }
+  };
+</script>
+
+<style scoped>
+  .not-found-container {
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--bams-page-bg);
+  }
+</style>

package/src/components/SystemError/index.vue

@@ -0,0 +1,60 @@
+<template>
+  <div class="system-error-container">
+    <a-result status="error" title="系统错误" :sub-title="subTitle">
+      <template #extra>
+        <a-button @click="goBack">返回上一步</a-button>
+        <a-button type="primary" @click="goHome">{{ backButtonText }}</a-button>
+      </template>
+    </a-result>
+  </div>
+</template>
+
+<script setup>
+  import { computed } from "vue";
+  import { useRoute, useRouter } from "vue-router";
+
+  const route = useRoute();
+  const router = useRouter();
+
+  const errorSource = computed(() => (typeof route.query.source === "string" ? route.query.source : ""));
+  const errorMessage = computed(() => (typeof route.query.message === "string" ? route.query.message : ""));
+  const fromPath = computed(() => (typeof route.query.from === "string" ? route.query.from : ""));
+  const subTitle = computed(() => {
+    const parts = [];
+    if (errorSource.value) parts.push(`错误来源：${errorSource.value}`);
+    if (errorMessage.value) parts.push(`错误信息：${errorMessage.value}`);
+    if (fromPath.value) parts.push(`访问地址：${fromPath.value}`);
+    return parts.length ? parts.join("；") : "页面加载失败，请稍后重试。";
+  });
+  const isFromWork = computed(() => fromPath.value.includes("/work/"));
+  const backButtonText = computed(() => (isFromWork.value ? "回到系统首页" : "返回首页"));
+
+  const goHome = () => {
+    let targetPath = "/";
+    if (isFromWork.value) {
+      const match = fromPath.value.match(/^(\/.*\/work\/).*$/);
+      if (match) {
+        targetPath = `${match[1]}pageHome`;
+      }
+    }
+    window.location.replace(router.resolve(targetPath).href);
+  };
+
+  const goBack = () => {
+    if (window.history.length > 1) {
+      router.back();
+    } else {
+      goHome();
+    }
+  };
+</script>
+
+<style scoped>
+  .system-error-container {
+    height: 100%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--bams-page-bg);
+  }
+</style>

package/src/createRouterInstance.js

@@ -0,0 +1,24 @@
+import { createRouter, createWebHistory } from 'vue-router';
+import createRoutes from './createRoutes.js';
+import routerController from './routerController.js';
+
+const createRouterInstance = (appConfig = {}) => {
+    const router = createRouter({
+        history: createWebHistory(),
+        routes: createRoutes([], appConfig)
+    });
+
+    // 处理路由重复导航的问题
+    // const originalPush = router.push;
+    // router.push = function push(location, onComplete, onAbort) {
+    //     if (onComplete || onAbort) return originalPush.call(this, location, onComplete, onAbort);
+    //     return originalPush.call(this, location).catch(err => err);
+    // };
+
+    // 路由守卫
+    // router.beforeEach(routerController.bind(router));
+
+    return router;
+};
+
+export default createRouterInstance;

package/src/createRoutes.js

@@ -0,0 +1,96 @@
+import { AppLayoutPublicContentView as PublicContentView } from "@bams-app/app-layout";
+import LoginMiddleware from "./components/LoginMiddleware.vue";
+import NotFound from "./components/NotFound/index.vue";
+import NoPermission from "./components/NoPermission/index.vue";
+import SystemError from "./components/SystemError/index.vue";
+import { h } from "vue";
+import { DEFAULT_HOME } from "./registerRoutes.js";
+
+export default function createRoutes(workLayout = undefined, routes = [], appConfig = {}) {
+  const { defaultHome = DEFAULT_HOME } = appConfig;
+  return [
+    {
+      path: "/auth/login",
+      name: "authLogin",
+      component: LoginMiddleware,
+      meta: { allowAnonymous: true }
+    },
+    {
+      path: "/login",
+      name: "login",
+      // component: () => import(/* webpackChunkName: "login" */ "../login/index.vue")
+      component: h("div", "登录页")
+    },
+    {
+      path: "/register",
+      name: "register",
+      component: h("div", "注册页")
+    },
+    {
+      name: "work",
+      path: "/:channel?/:projectId/work/",
+      // 注意：不能用字符串重定向（如 `/:channel?/:projectId/work/${defaultHome}`），
+      // vue-router 会把路径中的 `?`（`:channel?` 的可选参数标记）当作查询串分隔符解析，
+      // 导致重定向目标被解析成 "/:channel"，匹配不到任何路由而跳 404。
+      // 因此必须使用函数重定向，基于当前路由参数拼接目标路径。
+      redirect: (to) => {
+        const { channel, projectId } = to.params;
+        const workHome = defaultHome || DEFAULT_HOME;
+        return `/${[channel, projectId, "work", workHome].filter(Boolean).join("/")}`;
+      },
+      beforeEnter(to, from, next) {
+        next();
+      },
+      props(route) {
+        return { appConfig, mode: "prod" };
+      },
+      component: workLayout,
+      // 403 无权限页仅在 work 路由下触发（routerController 权限判断），
+      // 作为 work 布局子路由渲染，保留菜单布局便于用户继续导航
+      children: [
+        {
+          path: "403",
+          name: "403",
+          component: NoPermission
+        }
+      ]
+    },
+    {
+      name: "render",
+      path: "/:channel?/:projectId/render/",
+      redirect: `/:channel?/:projectId/render/${defaultHome}`,
+      beforeEnter(to, from, next) {
+        next();
+      },
+      props(route) {
+        return { appConfig, mode: "prod" };
+      },
+      // 渲染页复用内容视图组件，与菜单驱动页面保持一致（路由视图 / iframe / 缓存行为一致）
+      component: PublicContentView
+    },
+    {
+      name: "anon",
+      path: "/:channel?/:projectId/anon/",
+      redirect: `/:channel?/:projectId/anon/${defaultHome}`,
+      beforeEnter(to, from, next) {
+        next();
+      },
+      props(route) {
+        return { appConfig, mode: "prod" };
+      },
+      // 公开页复用内容视图组件，与菜单驱动页面保持一致（路由视图 / iframe / 缓存行为一致）
+      component: PublicContentView
+    },
+    {
+      path: "/404",
+      name: "404",
+      component: NotFound
+    },
+    {
+      path: "/500",
+      name: "500",
+      component: SystemError
+    },
+    ...routes
+  ];
+}

package/src/index.js

@@ -0,0 +1,16 @@
+
+export { default as createRouterInstance } from './createRouterInstance.js';
+export { default as createRoutes } from './createRoutes.js';
+export { default as routerController } from './routerController.js';
+export { hasRoute, registerRoutes, registerRoutesByMenu, toNoPermissionOrNotFound, DEFAULT_HOME } from './registerRoutes.js';
+
+const install = function (Vue) {
+    if (install.installed) return;
+    install.installed = true;
+};
+
+if (process.env.NODE_ENV !== "development" && typeof window !== "undefined" && window.Vue) {
+    install(window.Vue);
+}
+
+export default { install };

package/src/registerRoutes.js

@@ -0,0 +1,195 @@
+import { defineComponent, ref, onMounted, onActivated, h, defineAsyncComponent, markRaw } from 'vue';
+import { useRoute } from 'vue-router';
+import * as utils from "@bams-app/utils";
+import Loading from "./components/Loading/index.vue";
+import Error from "./components/Error/index.vue";
+import { useMenuStore } from "@bams-app/store";
+
+const reg = /^\/(?:[^\/]+\/){1,2}(work|render|anon)\/([^\/]+)\/?$/;
+
+// 默认首页：不在权限菜单中（菜单由后端按用户权限返回），但必须始终注册并可访问，
+// createRoutes 中 work 根路径重定向即指向该页面
+export const DEFAULT_HOME = "pageHome";
+
+/**
+ * 构造无权限(403)或页面不存在(404)的跳转目标：
+ * 页面组件存在（window.ui 已注册）但不在用户菜单中 = 无权限(403)；组件不存在 = 页面不存在(404)
+ * 403 挂在 work 布局下（保留菜单布局），需从来源地址提取 work 前缀拼接跳转路径
+ * @param {string} pageId 页面 ID
+ * @param {string} fromPath 来源地址
+ * @returns {object} 路由跳转目标
+ */
+export function toNoPermissionOrNotFound(pageId, fromPath) {
+  if (window.ui && window.ui[pageId]) {
+    const match = fromPath.match(/^(\/.*\/work\/).*$/);
+    const base = match ? match[1] : "/";
+    return { path: `${base}403`, query: { from: fromPath }, replace: true };
+  }
+  return { path: "/404", query: { from: fromPath }, replace: true };
+}
+
+/**
+ * 判断当前访问路由是否存在
+ * @param {object} to
+ * @returns {boolean}
+ */
+export function hasRoute(to) {
+  if (!to.name) return false;
+  let router = this;
+  let find = router.getRoutes().find((item) => to.path === "/" || to.name === item.name);
+  return !!find;
+}
+
+/**
+ * 当前路由如果不存在，执行注册路由
+ * @param {object} to
+ * @param {object} from
+ * @param {function} next
+ */
+export function registerRoutes(to, from, next) {
+  let router = this;
+  const match = to.path.match(reg);
+
+  if (match) {
+    const type = match[1];
+    const id = match[2];
+    const route = createRoute(id);
+
+    // 防止重复注册导致的死循环
+    if (router.hasRoute(route.name)) {
+      console.error(`路由 [${route.name}] 已存在，但路径 [${to.path}] 仍未匹配成功。请检查父路由配置。`);
+      next({ path: "/404", query: { from: to.fullPath }, replace: true });
+      return;
+    }
+
+    router.addRoute(type, route);
+    next({ ...to, replace: false });
+  } else {
+    next({ path: "/404", query: { from: to.fullPath }, replace: true });
+  }
+}
+
+/**
+ * 菜单驱动批量注册 work 路由（幂等）
+ * work 路由表由权限过滤后的菜单生成：
+ * - 菜单是后端按用户权限返回的（getResourceByUserTree），无权限的菜单不会出现，对应路由不会被注册
+ * - 已注册的路由跳过，重复调用无副作用
+ * @param {object} router
+ */
+export function registerRoutesByMenu(router) {
+  const menuStore = useMenuStore();
+  const menuPathMap = menuStore.menuPathMap || {};
+  Object.keys(menuPathMap).forEach(id => {
+    if (router.hasRoute(id)) return;
+    router.addRoute("work", createRoute(id));
+  });
+  // 默认首页不在菜单清单中，需单独注册，否则 work 根路径重定向到 pageHome 会 404
+  if (!router.hasRoute(DEFAULT_HOME)) {
+    router.addRoute("work", createRoute(DEFAULT_HOME));
+  }
+}
+
+// iframe 菜单的路由仅作为跳转占位，内容由内容区（ContentRouteAndIframeView）的 BamsIframe 渲染：
+// 空组件避免 iframe 模式下被隐藏挂载时误加载业务组件或改写 window.__currWorkRoute__
+const EmptyIframeRoute = defineComponent({
+  name: "EmptyIframeRoute",
+  render: () => null
+});
+
+/**
+ * 创建一个路由表
+ * @param {string} id
+ * @returns route
+ */
+export function createRoute(id) {
+  const menuStore = useMenuStore();
+  const menuItem = menuStore.menuPathMap[id];
+  const isIframeMenu = String(menuItem?.openType) === "1";
+
+  return {
+    path: id,
+    name: id,
+    meta: { id: id, isWork: true, isCache: menuItem?.isCache },
+    props: (route) => ({ workId: id }),
+    // iframe 菜单的内容由内容区渲染，路由组件仅作占位
+    component: isIframeMenu ? EmptyIframeRoute : CheckAuthWorkPage(id)
+  };
+}
+
+/**
+ * route页面权限拦截组件
+ * window.__currWorkRoute__ 代表当前正在访问的work route
+ * window.__currWorkRoute__.resolve 有权限，显示业务页面
+ * window.__currWorkRoute__.reject 无权限，显示无权限提示
+ */
+const CheckAuthWorkPage = function (routeName) {
+  return defineComponent({
+    name: `CheckAuthWorkPage_${routeName}`,
+    inject: ['appConfig'],
+    setup(props) {
+      const status = ref('pending'); // pending(页面正在打开...) | resolve(有权限) | reject(无权限)
+      const route = useRoute();
+      const { promise, resolve, reject } = utils.base.defer();
+      const ErrorComponent = defineComponent({
+        name: `WorkRouteError_${routeName}`,
+        render() {
+          return h(Error, {
+            menuCode: routeName
+          });
+        }
+      });
+      const WorkComponent = markRaw(defineAsyncComponent({
+        // 核心：组件加载函数（必须，返回Promise）
+        loader: window.ui && window.ui[routeName] || (() => Promise.reject(`组件{${routeName}}不存在`)),
+        // 加载中显示的组件（可选）
+        loadingComponent: Loading,
+        // 加载失败显示的组件（可选）
+        errorComponent: ErrorComponent,
+        // 延迟多久显示加载中组件（ms，默认200），避免网络快时闪屏
+        delay: 500,
+        // 加载超时时间（ms，可选），超时会触发errorComponent
+        timeout: 20000,
+        // 加载失败时是否允许重试（可选，默认false）
+        retry: true,
+        // 重试的间隔时间（ms，可选，配合retry使用）
+        retryDelay: 1000
+      }));
+
+      promise
+        .then(() => {
+          status.value = "resolve";
+        })
+        .catch(() => {
+          status.value = "reject";
+        });
+
+      onMounted(() => {
+        window.__currWorkRoute__ = { resolve, reject };
+      });
+
+      onActivated(() => {
+        // window.__currWorkRoute__ = { resolve, reject };
+      });
+
+      // setTimeout(() => {
+      //   window.__currWorkRoute__.resolve();
+      // }, 1000);
+
+      resolve();
+
+      return {
+        status,
+        route,
+        WorkComponent
+      };
+    },
+    render() {
+      if (this.status === "pending") return h(Loading);
+      if (this.status === "reject") return h("div", {}, "无权限");
+      if (this.status === "resolve") {
+        return h(this.WorkComponent);
+      }
+    }
+  });
+
+}

package/src/routerController.js

@@ -0,0 +1,99 @@
+import { hasRoute, registerRoutes, registerRoutesByMenu, toNoPermissionOrNotFound, DEFAULT_HOME } from "./registerRoutes.js";
+import { useUserStore, useMenuStore } from "@bams-app/store";
+import { auth, url } from "@bams-app/utils";
+
+const allowList = ["login", "register"];
+const loginRoutePath = "/login";
+// 路径白名单：无需登录即可访问的路径
+const pathWhiteList = ["/anon/"];
+// work 路由前缀：/:channel?/:projectId/work/...
+const workRouteReg = /^\/(?:[^\/]+\/){1,2}work\//;
+
+export default async function routerController(to, from, next) {
+    const router = this;
+    const userStore = useUserStore();
+    const menuStore = useMenuStore();
+
+    // 1. 处理 URL 携带 sessionId/token 的登录中间件跳转
+    // 只有在未登录状态下，才跳转到授权页面进行登录同步
+    if (to.query.token && to.path !== "/auth/login") {
+        next({
+            path: "/auth/login",
+            query: {
+                ...to.query,
+                redirect: to.fullPath
+            }
+        });
+        return;
+    }
+
+    // 2. 未登录时，仅允许访问匿名路由，其余统一跳转登录页
+    const isAllowAnonymousRoute = allowList.includes(to.name) || to.meta?.allowAnonymous || to.path === loginRoutePath || pathWhiteList.some(path => to.path.includes(path));
+    if (!userStore.checkLogin() && !isAllowAnonymousRoute) {
+        next({
+            path: loginRoutePath,
+            query: {
+                sysCode: auth.getSysCode(),
+                callback_url: to.href
+            }
+        });
+        return;
+    }
+
+    // 3. work 路由：基于缓存菜单批量注册，不再逐条动态注册
+    // 登录成功后已拉取菜单并缓存（localStorage 持久化），这里直接用缓存数据注册，
+    // 权限由菜单天然保证；仅当缓存为空（如缓存被清理）时才兜底拉取一次，
+    // 缓存超过有效期（MENU_CACHE_TTL）时静默刷新，失败则沿用旧缓存
+    if (workRouteReg.test(to.path)) {
+        if (Object.keys(menuStore.menuPathMap).length === 0) {
+            try {
+                await menuStore.getMenuList();
+            } catch (error) {
+                console.error("获取菜单失败，无法注册 work 路由:", error);
+                next({
+                    path: "/500",
+                    query: { source: "获取菜单失败", from: to.fullPath, message: error?.message || String(error) },
+                    replace: true
+                });
+                return;
+            }
+        } else if (menuStore.isMenuStale) {
+            // 有缓存但已过期：刷新一次，失败不影响旧缓存继续使用
+            try {
+                await menuStore.getMenuList();
+            } catch (error) {
+                console.error("刷新菜单失败，使用缓存菜单:", error);
+            }
+        }
+        // 幂等批量注册全部菜单路由
+        registerRoutesByMenu(router);
+        // 路由刚注册，当前导航的 to 对象尚未重新解析（to.name/to.matched 均为空，hasRoute 必为 false），
+        // 需重导航一次让 vue-router 匹配新注册的路由；菜单中存在该页面才重导航，否则直接 404，
+        // 避免无权限页面在此处反复重导航造成死循环
+        if (to.matched.length === 0) {
+            const pageId = to.path.split("/").filter(Boolean).pop();
+            // 默认首页不在菜单中，但属于内置页面，同样放行重导航
+            if (menuStore.menuPathMap[pageId] || pageId === DEFAULT_HOME) {
+                next({ ...to, replace: true });
+            } else {
+                // TODO 临时放开：不在菜单中的 work 路由也允许访问，动态注册后重导航
+                // 原逻辑：next(toNoPermissionOrNotFound(pageId, to.fullPath));
+                registerRoutes.bind(router)(to, from, next);
+            }
+            return;
+        }
+        // 已匹配（二次导航或路由已注册）：菜单中存在该路由 = 有权限，否则按页面是否存在跳 403/404
+        if (hasRoute.bind(router)(to)) {
+            next();
+        } else {
+            const pageId = to.path.split("/").filter(Boolean).pop();
+            // TODO 临时放开：不在菜单中的 work 路由直接放行，不再跳 403/404
+            // 原逻辑：next(toNoPermissionOrNotFound(pageId, to.fullPath));
+            next();
+        }
+        return;
+    }
+
+    // 4. render/anon 等其余路由：保持原有动态注册逻辑
+    hasRoute.bind(router)(to) ? next() : registerRoutes.bind(router)(to, from, next);
+}

package/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [vue()],
+})