@fulgurjs/federation 5.3.2 → 5.4.0

package/dist/bridge-router-react.d.ts

@@ -0,0 +1,96 @@
+import { ReactElement } from 'react';
+import { RouteObject } from 'react-router-dom';
+
+/** 统一逻辑位置：pathname 以 / 开头；search 空串或 ? 开头；hash 空串或 # 开头 */
+interface BridgeLocation {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+type BridgeNavigationResult = {
+    status: 'committed';
+    location: BridgeLocation;
+} | {
+    status: 'cancelled';
+    location: BridgeLocation;
+};
+/** 宿主导航端口（宿主适配器把 Router 包装成本接口；逻辑路径不含部署 base） */
+interface BridgeHostNavigation {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace'): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+/** 子应用路由通道（桥接宿主按挂载代次创建，随 mount 第三参数交给子应用） */
+interface BridgeChildRoute {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace'): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+
+/**
+ * React Router 路由适配（/bridge/router/react 按需入口；URL 同步任务书 §3.1/§3.3）。
+ *
+ * 实际支持模式（原型实证，任务书 §1 结论 2）：
+ * - 宿主：data router（createBrowserRouter / createHashRouter + RouterProvider）。
+ *   router.navigate 被 blocker 拦截时静默返回 void（dist 源码核实）——取消用
+ *   「与 useBlocker 同一取消策略预判」：canNavigate(target) 返回 false 即 cancelled，
+ *   URL/历史零副作用；菜单/POP 等其他来源仍由树内 useBlocker 真实拦截。
+ * - 子应用：createMemoryRouter（RR 6.11+）受控路由——Link/useNavigate 全兼容，
+ *   通道广播与本地导航双向桥接，取消时乐观回滚。
+ * - declarative 模式（BrowserRouter）无 blocker/提交语义，不支持 URL 同步（文档声明）。
+ */
+
+/** 宿主取消策略（与树内 useBlocker 共用同一谓词，单一事实源） */
+type ReactBridgeCancelPolicy = (next: BridgeLocation) => boolean;
+/** data router 的最小结构面（避免耦合 RR 内部类型版本） */
+interface ReactDataRouterLike {
+    state: {
+        location: {
+            pathname: string;
+            search: string;
+            hash: string;
+        };
+    };
+    subscribe(cb: () => void): () => void;
+    navigate(to: string | number, opts?: {
+        replace?: boolean;
+    }): void | Promise<void>;
+}
+/**
+ * 宿主侧：把 RR data router 包装为宿主导航端口。
+ *
+ * ```tsx
+ * const router = createBrowserRouter(routes, { basename })
+ * const navigation = createReactBridgeNavigation(router, {
+ *   basename, // = createBrowserRouter 的 basename（含它；RR location.pathname 不剥 basename）
+ *   canNavigate: (next) => !next.pathname.startsWith('/approval/secret'), // 与 useBlocker 同一谓词
+ * })
+ * ```
+ */
+declare function createReactBridgeNavigation(router: ReactDataRouterLike, options?: {
+    canNavigate?: ReactBridgeCancelPolicy;
+    basename?: string;
+}): BridgeHostNavigation;
+interface ReactBridgeRouterConnection {
+    /** RouterProvider 元素：子应用在自己的 root 内渲染 */
+    element: ReactElement;
+    /** 清理本接线（通道订阅与本地监听；通道本身由宿主生命周期销毁） */
+    dispose(): void;
+}
+/**
+ * 子应用侧：把子应用自己的 routes 接到通道，返回 RouterProvider 元素。
+ *
+ * ```tsx
+ * export default defineBridgeApp((props, ctx) => {
+ *   const conn = createReactBridgeRouter(ctx.routing, routes)
+ *   const root = createRoot(el)
+ *   root.render(conn.element)
+ *   return { mount: () => {}, unmount: () => { conn.dispose(); root.unmount() } }
+ * }, { routing: true })
+ * ```
+ */
+declare function createReactBridgeRouter(routing: BridgeChildRoute, routes: RouteObject[]): ReactBridgeRouterConnection;
+
+export { type ReactBridgeCancelPolicy, type ReactBridgeRouterConnection, type ReactDataRouterLike, createReactBridgeNavigation, createReactBridgeRouter };

package/dist/bridge-router-react.js

@@ -0,0 +1,70 @@
+// src/bridge-router-react.tsx
+import { createElement } from "react";
+import { RouterProvider, createMemoryRouter } from "react-router-dom";
+function createReactBridgeNavigation(router, options = {}) {
+  const routerBase = options.basename && options.basename !== "/" ? options.basename.replace(/\/$/, "") : "";
+  const toLogic = () => {
+    const l = router.state.location;
+    const pathname = routerBase && l.pathname.startsWith(routerBase) ? l.pathname.slice(routerBase.length) || "/" : l.pathname;
+    return { pathname, search: l.search, hash: l.hash };
+  };
+  return {
+    getLocation: toLogic,
+    subscribe(listener) {
+      return router.subscribe(() => listener(toLogic()));
+    },
+    async navigate(target, action) {
+      if (options.canNavigate && !options.canNavigate(target)) {
+        return { status: "cancelled", location: toLogic() };
+      }
+      await router.navigate((routerBase && routerBase !== "/" ? routerBase : "") + target.pathname + target.search + target.hash, { replace: action === "replace" });
+      return { status: "committed", location: toLogic() };
+    },
+    go(delta) {
+      void router.navigate(delta);
+    }
+  };
+}
+function createReactBridgeRouter(routing, routes) {
+  const init = routing.getLocation();
+  const router = createMemoryRouter(routes, {
+    initialEntries: [init.pathname + init.search + init.hash]
+  });
+  let syncing = false;
+  let disposed = false;
+  const unsub = routing.subscribe((loc) => {
+    if (disposed) return;
+    const next = loc.pathname + loc.search + loc.hash;
+    const cur = router.state.location;
+    if (next !== cur.pathname + cur.search + cur.hash) void router.navigate(next, { replace: true });
+  });
+  const unwatch = router.subscribe(() => {
+    if (disposed || syncing) return;
+    const cur = router.state.location;
+    const chan = routing.getLocation();
+    if (cur.pathname + cur.search + cur.hash === chan.pathname + chan.search + chan.hash) return;
+    syncing = true;
+    void routing.navigate({ pathname: cur.pathname, search: cur.search, hash: cur.hash }, "push").then((result) => {
+      syncing = false;
+      if (result.status === "cancelled" && !disposed) {
+        const c = result.location;
+        const next = c.pathname + c.search + c.hash;
+        const cur2 = router.state.location;
+        if (next !== cur2.pathname + cur2.search + cur2.hash) void router.navigate(next, { replace: true });
+      }
+    });
+  });
+  return {
+    element: createElement(RouterProvider, { router }),
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      unwatch();
+      unsub();
+    }
+  };
+}
+export {
+  createReactBridgeNavigation,
+  createReactBridgeRouter
+};

package/dist/bridge-router-vue.d.ts

@@ -0,0 +1,75 @@
+import { Router } from 'vue-router';
+
+/** 统一逻辑位置：pathname 以 / 开头；search 空串或 ? 开头；hash 空串或 # 开头 */
+interface BridgeLocation {
+    pathname: string;
+    search: string;
+    hash: string;
+}
+type BridgeNavigationResult = {
+    status: 'committed';
+    location: BridgeLocation;
+} | {
+    status: 'cancelled';
+    location: BridgeLocation;
+};
+/** 宿主导航端口（宿主适配器把 Router 包装成本接口；逻辑路径不含部署 base） */
+interface BridgeHostNavigation {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace'): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+/** 子应用路由通道（桥接宿主按挂载代次创建，随 mount 第三参数交给子应用） */
+interface BridgeChildRoute {
+    getLocation(): BridgeLocation;
+    subscribe(listener: (location: BridgeLocation) => void): () => void;
+    navigate(target: BridgeLocation, action: 'push' | 'replace'): Promise<BridgeNavigationResult>;
+    go(delta: number): void;
+}
+
+/**
+ * Vue Router 4 路由适配（/bridge/router/vue 按需入口；URL 同步任务书 §3.1/§3.3）。
+ *
+ * 宿主侧：createVueBridgeNavigation(router) 把 Vue Router 实例包装为宿主导航端口——
+ * push/replace 落定 NavigationFailure | undefined，failure 即真实取消（守卫拒绝），
+ * 不以「函数返回」冒充提交成功。
+ *
+ * 子应用侧：connectVueBridgeRouter(routing, router) 把子应用自己的 memory router
+ * 接到通道上——RouterLink/router.push 等真实入口经 afterEach 桥为通道请求（宿主仲裁，
+ * 取消时回滚最后确认位置）；通道广播 replace 应用到本地 router。
+ * 初始位置已由通道就绪；`ready` 落定前 afterEach 不发起请求（原型实证：install 的
+ * 初始导航竞态，见任务书 §1 原型结论 1）。
+ *
+ * 本入口按需导入 vue-router（peerDependenciesMeta.optional）；默认 /bridge、/runtime、
+ * /react 不加载本模块。
+ */
+
+/** Vue Router base（createWebHistory/createWebHashHistory 的 base 参数）；逻辑路径 = 实际路径去 base */
+interface VueBridgeNavigationOptions {
+    routerBase?: string;
+}
+/** 宿主侧：把 Vue Router 实例包装为宿主导航端口（宿主 Router 是唯一历史写入方） */
+declare function createVueBridgeNavigation(router: Router, options?: VueBridgeNavigationOptions): BridgeHostNavigation;
+interface VueBridgeRouterConnection {
+    /** 初始位置就绪（含初始 push 与首次广播应用）；ready 前后的清理都必须可用 */
+    ready: Promise<void>;
+    /** 清理本接线（通道订阅与本地监听；通道本身由宿主生命周期销毁） */
+    dispose(): void;
+}
+/**
+ * 子应用侧：把子应用自己的 memory router 接到通道。
+ *
+ * ```ts
+ * export default defineBridgeApp((props, ctx) => {
+ *   const router = createRouter({ history: createMemoryHistory(), routes })
+ *   const conn = connectVueBridgeRouter(ctx.routing, router)
+ *   const app = createApp(App, props)
+ *   app.use(router)
+ *   return app
+ * }, { routing: true })
+ * ```
+ */
+declare function connectVueBridgeRouter(routing: BridgeChildRoute, router: Router): VueBridgeRouterConnection;
+
+export { type VueBridgeNavigationOptions, type VueBridgeRouterConnection, connectVueBridgeRouter, createVueBridgeNavigation };

package/dist/bridge-router-vue.js

@@ -0,0 +1,73 @@
+// src/bridge-router-vue.ts
+function createVueBridgeNavigation(router, options = {}) {
+  const routerBase = options.routerBase && options.routerBase !== "/" ? options.routerBase.replace(/\/$/, "") : "";
+  const toLogic = () => {
+    const raw = new URL(router.currentRoute.value.fullPath || "/", "http://f.invalid");
+    const pathname = routerBase && raw.pathname.startsWith(routerBase) ? raw.pathname.slice(routerBase.length) || "/" : raw.pathname;
+    return { pathname, search: raw.search, hash: raw.hash };
+  };
+  return {
+    getLocation: toLogic,
+    subscribe(listener) {
+      return router.afterEach(() => listener(toLogic()));
+    },
+    async navigate(target, action) {
+      const to = target.pathname + target.search + target.hash;
+      try {
+        const failure = action === "replace" ? await router.replace(to) : await router.push(to);
+        if (failure) return { status: "cancelled", location: toLogic() };
+        return { status: "committed", location: toLogic() };
+      } catch {
+        return { status: "cancelled", location: toLogic() };
+      }
+    },
+    go(delta) {
+      router.go(delta);
+    }
+  };
+}
+function connectVueBridgeRouter(routing, router) {
+  let syncing = false;
+  let disposed = false;
+  let started = false;
+  const unsub = routing.subscribe((loc) => {
+    if (disposed) return;
+    const next = loc.pathname + loc.search + loc.hash;
+    if (router.currentRoute.value.fullPath !== next) void router.replace(next);
+  });
+  const stopWatch = router.afterEach((to) => {
+    if (disposed || syncing || !started) return;
+    const chan = routing.getLocation();
+    const toFull = to.fullPath;
+    if (toFull === chan.pathname + chan.search + chan.hash) return;
+    const raw = new URL(toFull, "http://f.invalid");
+    syncing = true;
+    void routing.navigate({ pathname: raw.pathname, search: raw.search, hash: raw.hash }, "push").then((result) => {
+      syncing = false;
+      if (result.status === "cancelled" && !disposed) {
+        const c = result.location;
+        const cur = c.pathname + c.search + c.hash;
+        if (router.currentRoute.value.fullPath !== cur) void router.replace(cur);
+      }
+    });
+  });
+  const init = routing.getLocation();
+  const ready = router.push(init.pathname + init.search + init.hash).then(() => {
+    started = true;
+  }).catch(() => {
+    started = true;
+  });
+  return {
+    ready,
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      stopWatch();
+      unsub();
+    }
+  };
+}
+export {
+  connectVueBridgeRouter,
+  createVueBridgeNavigation
+};

package/dist/bridge-vue.d.ts

@@ -1,6 +1,6 @@
 import * as vue from 'vue';
-import { V as VueBridgeAppOptions } from './bridge-host-vue-BAxDKqGH.js';
-export { A as AppContext, B as BridgeApp } from './bridge-core-6uLJiMVa.js';
+import { V as VueBridgeAppOptions } from './bridge-host-vue-BuCGlLdS.js';
+export { A as AppContext, a as BridgeApp } from './bridge-core-BOWvVUxO.js';
 
 /** Vue 宿主桥接工厂：返回 `{ appProps: P; sessionKey?: string | null }` 形态的包装组件 */
 declare const createVueBridgeApp: <P = Record<string, unknown>>(spec: string, options?: VueBridgeAppOptions) => vue.Component;

package/dist/bridge.d.ts

@@ -1,9 +1,10 @@
 import * as react from 'react';
-import { R as ReactBridgeAppOptions } from './bridge-host-react-C55RmGll.js';
-export { B as BridgeErrorFallback } from './bridge-host-react-C55RmGll.js';
+import { B as BridgeHostRouting } from './bridge-core-BOWvVUxO.js';
+export { A as AppContext, a as BridgeApp } from './bridge-core-BOWvVUxO.js';
+import { R as ReactBridgeAppOptions } from './bridge-host-react-CMVd-ym0.js';
+export { B as BridgeErrorFallback } from './bridge-host-react-CMVd-ym0.js';
 import * as vue from 'vue';
-import { V as VueBridgeAppOptions } from './bridge-host-vue-BAxDKqGH.js';
-export { A as AppContext, B as BridgeApp } from './bridge-core-6uLJiMVa.js';
+import { V as VueBridgeAppOptions } from './bridge-host-vue-BuCGlLdS.js';
 
 /** Vue 宿主桥接工厂：返回 `{ appProps: P; sessionKey?: string | null }` 形态的包装组件 */
 declare const createVueBridgeApp: <P = Record<string, unknown>>(spec: string, options?: VueBridgeAppOptions) => vue.Component;
@@ -11,6 +12,7 @@ declare const createVueBridgeApp: <P = Record<string, unknown>>(spec: string, op
 declare const createReactBridgeApp: <P = Record<string, unknown>>(spec: string, options?: ReactBridgeAppOptions) => react.ComponentType<{
     appProps?: P;
     sessionKey?: string | null;
+    routing?: BridgeHostRouting;
 }>;
 
 export { ReactBridgeAppOptions, VueBridgeAppOptions, createReactBridgeApp, createVueBridgeApp };