@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.0

package/dist/esm-node/runtime/dataMutation.mjs

@@ -0,0 +1,306 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { useRouter } from "@tanstack/react-router";
+import { useCallback, useRef, useState } from "react";
+class RouteActionResponseError extends Error {
+    constructor(response, data){
+        super(`Route action failed with status ${response.status}`);
+        this.name = 'RouteActionResponseError';
+        this.response = response;
+        this.data = data;
+    }
+}
+function formDataToUrlSearchParams(formData) {
+    const searchParams = new URLSearchParams();
+    formData.forEach((value, key)=>{
+        if ('string' == typeof value) searchParams.append(key, value);
+    });
+    return searchParams;
+}
+function formDataToTextPlain(formData) {
+    return Array.from(formData.entries()).map(([key, value])=>`${key}=${String(value)}`).join('\n');
+}
+function toFormData(target) {
+    if (target instanceof HTMLFormElement) return new FormData(target);
+    if (target instanceof FormData) return target;
+    if (target instanceof URLSearchParams) {
+        const formData = new FormData();
+        target.forEach((value, key)=>{
+            formData.append(key, value);
+        });
+        return formData;
+    }
+    const formData = new FormData();
+    Object.entries(target).forEach(([key, value])=>{
+        if (null == value) return;
+        formData.append(key, String(value));
+    });
+    return formData;
+}
+function getSubmitter(event) {
+    const nativeEvent = event.nativeEvent;
+    const submitter = nativeEvent?.submitter;
+    if (submitter instanceof HTMLButtonElement || submitter instanceof HTMLInputElement) return submitter;
+    return null;
+}
+function createFormDataFromSubmit({ form, submitter }) {
+    if (submitter) try {
+        return new FormData(form, submitter);
+    } catch  {}
+    return new FormData(form);
+}
+function resolveSubmitOptionsFromForm({ form, submitter, action, method, encType }) {
+    const resolvedAction = submitter?.getAttribute('formaction') || action || form.getAttribute('action') || '.';
+    const resolvedMethod = (submitter?.getAttribute('formmethod') || method || form.getAttribute('method') || 'get').toLowerCase();
+    const resolvedEncType = submitter?.getAttribute('formenctype') || encType || form.getAttribute('enctype') || 'application/x-www-form-urlencoded';
+    return {
+        action: resolvedAction,
+        method: resolvedMethod,
+        encType: resolvedEncType
+    };
+}
+function resolveRouteHandlers(router, actionTo) {
+    const builtLocation = router.buildLocation({
+        to: actionTo
+    });
+    const href = router.getParsedLocationHref(builtLocation);
+    const matchedRoutes = router.getMatchedRoutes(builtLocation.pathname);
+    const routeStaticData = matchedRoutes.foundRoute?.options?.staticData;
+    const action = routeStaticData?.modernRouteAction;
+    const loader = routeStaticData?.modernRouteLoader;
+    return {
+        action,
+        loader,
+        href,
+        params: matchedRoutes.routeParams || {}
+    };
+}
+function isRedirectResponse(value) {
+    if (!(value instanceof Response)) return false;
+    return [
+        301,
+        302,
+        303,
+        307,
+        308
+    ].includes(value.status);
+}
+async function parseResponseData(response) {
+    if (204 === response.status) return null;
+    const contentType = response.headers.get('Content-Type') || '';
+    if (contentType.includes('application/json')) return response.json();
+    return response.text();
+}
+async function parseResponseResultOrThrow(response) {
+    const parsed = await parseResponseData(response);
+    if (!response.ok) throw new RouteActionResponseError(response, parsed);
+    return parsed;
+}
+async function submitRouteAction({ router, target, options = {}, isFetcher = false, onInvalidateStart }) {
+    const method = (options.method || 'post').toLowerCase();
+    const encType = options.encType || 'application/x-www-form-urlencoded';
+    const actionTo = options.action || '.';
+    const formData = toFormData(target);
+    const resolved = resolveRouteHandlers(router, actionTo);
+    if ('get' === method) {
+        const search = formDataToUrlSearchParams(formData).toString();
+        const requestUrl = new URL(resolved.href, window.location.origin);
+        requestUrl.search = search;
+        if (isFetcher && resolved.loader) {
+            const result = await resolved.loader({
+                request: new Request(requestUrl, {
+                    method: 'GET'
+                }),
+                params: resolved.params
+            });
+            if (result instanceof Response) {
+                const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+                if (redirectTo || isRedirectResponse(result)) {
+                    await router.navigate({
+                        to: redirectTo || '/'
+                    });
+                    return parseResponseData(result);
+                }
+                return parseResponseResultOrThrow(result);
+            }
+            return result;
+        }
+        await router.navigate({
+            href: search ? `${resolved.href}?${search}` : resolved.href
+        });
+        return;
+    }
+    if (!resolved.action) throw new Error(`No route action found for "${actionTo}"`);
+    const headers = new Headers();
+    let body = null;
+    if (encType.includes('application/json')) {
+        headers.set('Content-Type', 'application/json');
+        body = JSON.stringify(Object.fromEntries(formDataToUrlSearchParams(formData).entries()));
+    } else if (encType.includes('text/plain')) {
+        headers.set('Content-Type', 'text/plain;charset=UTF-8');
+        body = formDataToTextPlain(formData);
+    } else if (encType.includes('application/x-www-form-urlencoded')) {
+        headers.set('Content-Type', 'application/x-www-form-urlencoded;charset=UTF-8');
+        body = formDataToUrlSearchParams(formData);
+    } else body = formData;
+    const request = new Request(new URL(resolved.href, window.location.origin), {
+        method: method.toUpperCase(),
+        headers,
+        body
+    });
+    const result = await resolved.action({
+        request,
+        params: resolved.params
+    });
+    if (result instanceof Response) {
+        const redirectTo = result.headers.get('X-Modernjs-Redirect') || result.headers.get('Location');
+        if (redirectTo || isRedirectResponse(result)) {
+            await router.navigate({
+                to: redirectTo || '/'
+            });
+            return parseResponseData(result);
+        }
+        const parsed = isFetcher ? await parseResponseResultOrThrow(result) : await parseResponseData(result);
+        onInvalidateStart?.();
+        await router.invalidate();
+        return parsed;
+    }
+    onInvalidateStart?.();
+    await router.invalidate();
+    return result;
+}
+function Form({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest }) {
+    const router = useRouter();
+    const handleSubmit = useCallback(async (event)=>{
+        onSubmit?.(event);
+        if (event.defaultPrevented || reloadDocument) return;
+        event.preventDefault();
+        const submitter = getSubmitter(event);
+        const formData = createFormDataFromSubmit({
+            form: event.currentTarget,
+            submitter
+        });
+        const normalizedOptions = resolveSubmitOptionsFromForm({
+            form: event.currentTarget,
+            submitter,
+            action,
+            method,
+            encType
+        });
+        await submitRouteAction({
+            router,
+            target: formData,
+            options: normalizedOptions
+        });
+    }, [
+        action,
+        encType,
+        method,
+        onSubmit,
+        reloadDocument,
+        router
+    ]);
+    return /*#__PURE__*/ jsx("form", {
+        ...rest,
+        action: action,
+        method: method,
+        encType: encType,
+        onSubmit: handleSubmit
+    });
+}
+function useFetcher() {
+    const router = useRouter();
+    const [state, setState] = useState('idle');
+    const [data, setData] = useState(void 0);
+    const [error, setError] = useState(void 0);
+    const requestStatesRef = useRef(new Map());
+    const requestIdRef = useRef(0);
+    const syncStateFromRequests = useCallback(()=>{
+        let hasSubmitting = false;
+        let hasLoading = false;
+        requestStatesRef.current.forEach((requestState)=>{
+            if ('submitting' === requestState) hasSubmitting = true;
+            else if ('loading' === requestState) hasLoading = true;
+        });
+        if (hasSubmitting) return void setState('submitting');
+        if (hasLoading) return void setState('loading');
+        setState('idle');
+    }, []);
+    const setRequestState = useCallback((requestId, requestState)=>{
+        requestStatesRef.current.set(requestId, requestState);
+        syncStateFromRequests();
+    }, [
+        syncStateFromRequests
+    ]);
+    const clearRequestState = useCallback((requestId)=>{
+        requestStatesRef.current.delete(requestId);
+        syncStateFromRequests();
+    }, [
+        syncStateFromRequests
+    ]);
+    const submit = useCallback(async (target, options)=>{
+        setError(void 0);
+        const requestId = ++requestIdRef.current;
+        const normalizedMethod = (options?.method || 'post').toLowerCase();
+        const isLoaderSubmit = 'get' === normalizedMethod;
+        setRequestState(requestId, isLoaderSubmit ? 'loading' : 'submitting');
+        try {
+            const result = await submitRouteAction({
+                router,
+                target,
+                options,
+                isFetcher: true,
+                onInvalidateStart: ()=>{
+                    if (!isLoaderSubmit) setRequestState(requestId, 'loading');
+                }
+            });
+            setData(result);
+        } catch (err) {
+            setError(err);
+            throw err;
+        } finally{
+            clearRequestState(requestId);
+        }
+    }, [
+        clearRequestState,
+        router,
+        setRequestState
+    ]);
+    const FetcherForm = useCallback(({ action, method = 'get', encType, reloadDocument, onSubmit, ...rest })=>{
+        const handleSubmit = async (event)=>{
+            onSubmit?.(event);
+            if (event.defaultPrevented || reloadDocument) return;
+            event.preventDefault();
+            const submitter = getSubmitter(event);
+            const formData = createFormDataFromSubmit({
+                form: event.currentTarget,
+                submitter
+            });
+            const normalizedOptions = resolveSubmitOptionsFromForm({
+                form: event.currentTarget,
+                submitter,
+                action,
+                method,
+                encType
+            });
+            await submit(formData, normalizedOptions);
+        };
+        return /*#__PURE__*/ jsx("form", {
+            ...rest,
+            action: action,
+            method: method,
+            encType: encType,
+            onSubmit: handleSubmit
+        });
+    }, [
+        submit
+    ]);
+    return {
+        state,
+        data,
+        error,
+        Form: FetcherForm,
+        submit
+    };
+}
+export { Form, RouteActionResponseError, useFetcher };

package/dist/esm-node/runtime/hooks.mjs

@@ -0,0 +1,9 @@
+import "node:module";
+import { createSyncHook } from "@modern-js/plugin";
+const modifyRoutes = createSyncHook();
+const onBeforeCreateRoutes = createSyncHook();
+const onBeforeCreateRouter = createSyncHook();
+const onAfterCreateRouter = createSyncHook();
+const onBeforeHydrateRouter = createSyncHook();
+const onAfterHydrateRouter = createSyncHook();
+export { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter };

package/dist/esm-node/runtime/index.mjs

@@ -0,0 +1,7 @@
+import "node:module";
+export * from "@tanstack/react-router";
+export { useMatch } from "@tanstack/react-router";
+export { Form, RouteActionResponseError, useFetcher } from "./dataMutation.mjs";
+export { tanstackRouterPlugin as default, tanstackRouterPlugin } from "./plugin.mjs";
+export { Link, NavLink } from "./prefetchLink.mjs";
+export { CompositeComponent } from "./rsc/client.mjs";

package/dist/esm-node/runtime/lifecycle.mjs

@@ -0,0 +1,83 @@
+import "node:module";
+function toHydrationScripts(state) {
+    if (state.hydrationScripts?.length) return state.hydrationScripts;
+    return state.hydrationScript ? [
+        state.hydrationScript
+    ] : void 0;
+}
+function getMatchedRouteIdsFromMatches(matches) {
+    const routeIds = matches?.map((match)=>match.assetRouteId ?? match.routeId).filter((routeId)=>'string' == typeof routeId);
+    return routeIds?.length ? routeIds : void 0;
+}
+function createRouterServerSnapshot(state) {
+    const hydrationScripts = toHydrationScripts(state);
+    const matchedRouteIds = state.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
+    return {
+        ...state,
+        ...hydrationScripts?.length ? {
+            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
+            hydrationScripts
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds
+        } : {}
+    };
+}
+function createRouterRuntimeState(state) {
+    const hasSnapshotState = Boolean(state.serverSnapshot) || Boolean(state.hydrationScript) || Boolean(state.hydrationScripts?.length) || Boolean(state.matchedRouteIds?.length) || Boolean(state.matches?.length);
+    const serverSnapshot = state.serverSnapshot ? createRouterServerSnapshot({
+        ...state.serverSnapshot,
+        framework: state.serverSnapshot.framework ?? state.framework,
+        basename: state.serverSnapshot.basename ?? state.basename,
+        hydrationScript: state.serverSnapshot.hydrationScript ?? state.hydrationScript,
+        hydrationScripts: state.serverSnapshot.hydrationScripts ?? state.hydrationScripts,
+        matchedRouteIds: state.serverSnapshot.matchedRouteIds ?? state.matchedRouteIds,
+        matches: state.serverSnapshot.matches ?? state.matches
+    }) : hasSnapshotState ? createRouterServerSnapshot({
+        framework: state.framework,
+        basename: state.basename,
+        hydrationScript: state.hydrationScript,
+        hydrationScripts: state.hydrationScripts,
+        matchedRouteIds: state.matchedRouteIds,
+        matches: state.matches
+    }) : void 0;
+    const hydrationScripts = toHydrationScripts({
+        hydrationScript: state.hydrationScript ?? serverSnapshot?.hydrationScript,
+        hydrationScripts: state.hydrationScripts ?? serverSnapshot?.hydrationScripts
+    });
+    const matchedRouteIds = state.matchedRouteIds ?? serverSnapshot?.matchedRouteIds ?? getMatchedRouteIdsFromMatches(state.matches);
+    return {
+        ...state,
+        ...hydrationScripts?.length ? {
+            hydrationScript: state.hydrationScript ?? hydrationScripts[0],
+            hydrationScripts
+        } : {},
+        ...matchedRouteIds ? {
+            matchedRouteIds
+        } : {},
+        ...serverSnapshot ? {
+            serverSnapshot
+        } : {}
+    };
+}
+function applyRouterRuntimeState(runtimeContext, state) {
+    const normalized = createRouterRuntimeState(state);
+    const mutableRuntimeContext = runtimeContext;
+    mutableRuntimeContext.routerFramework = normalized.framework;
+    mutableRuntimeContext.routerInstance = normalized.instance;
+    mutableRuntimeContext.routerHydrationScript = normalized.hydrationScript;
+    mutableRuntimeContext.routerMatchedRouteIds = normalized.matchedRouteIds;
+    mutableRuntimeContext.routerRuntime = normalized;
+    if (normalized.serverSnapshot) mutableRuntimeContext.routerServerSnapshot = normalized.serverSnapshot;
+    return runtimeContext;
+}
+function applyRouterServerPrepareResult(runtimeContext, result) {
+    const state = createRouterRuntimeState({
+        ...result.state,
+        cleanup: result.cleanup ?? result.state.cleanup,
+        serverSnapshot: result.snapshot ?? result.state.serverSnapshot
+    });
+    applyRouterRuntimeState(runtimeContext, state);
+    return runtimeContext;
+}
+export { applyRouterRuntimeState, applyRouterServerPrepareResult, createRouterRuntimeState, createRouterServerSnapshot };

package/dist/esm-node/runtime/plugin.mjs

@@ -0,0 +1,215 @@
+import "node:module";
+import { jsx } from "react/jsx-runtime";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { normalizePathname } from "@modern-js/runtime-utils/url";
+import { RouterProvider, createBrowserHistory, createHashHistory, createRouter, useLocation, useMatches, useNavigate, useRouter } from "@tanstack/react-router";
+import { RouterClient } from "@tanstack/react-router/ssr/client";
+import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
+import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
+import { applyRouterRuntimeState } from "./lifecycle.mjs";
+import { createRouteTreeFromRouteObjects } from "./routeTree.mjs";
+import { getTanstackRscSerializationAdapters } from "./rsc/client.mjs";
+import { createRouteObjectsFromConfig, urlJoin } from "./utils.mjs";
+import * as __rspack_external_react from "react";
+const BLOCKING_SUBSCRIBE_SYMBOL = Symbol.for('@modern-js/plugin-tanstack:blocking-subscribe');
+const BLOCKING_STATE_SYMBOL = Symbol.for('@modern-js/plugin-tanstack:blocking-state');
+function normalizeBase(b) {
+    if (b.length > 1 && b.endsWith('/')) return b.slice(0, -1);
+    return b || '/';
+}
+function isSegmentPrefix(pathname, base) {
+    const b = normalizeBase(base);
+    const p = pathname || '/';
+    return p === b || p.startsWith(`${b}/`);
+}
+function wrapRouterSubscribeWithBlockState(router, getBlockNavState) {
+    if (!router || 'object' != typeof router) return;
+    const target = router;
+    target[BLOCKING_STATE_SYMBOL] = getBlockNavState;
+    if (target[BLOCKING_SUBSCRIBE_SYMBOL] || 'function' != typeof target.subscribe) return;
+    const originSubscribe = target.subscribe.bind(target);
+    target.subscribe = (eventType, listener)=>{
+        const wrappedListener = (...args)=>{
+            const blockRoute = target[BLOCKING_STATE_SYMBOL]?.() || false;
+            if (blockRoute) return;
+            return listener(...args);
+        };
+        return originSubscribe(eventType, wrappedListener);
+    };
+    target[BLOCKING_SUBSCRIBE_SYMBOL] = true;
+}
+function stripSyntheticNotFoundRoute(routes) {
+    return routes.filter((route)=>!('*' === route.path && !route.id && !route.loader)).map((route)=>{
+        if (!route.children?.length) return route;
+        return {
+            ...route,
+            children: stripSyntheticNotFoundRoute(route.children)
+        };
+    });
+}
+const tanstackRouterPlugin = (userConfig = {})=>{
+    const plugin = {
+        name: '@modern-js/plugin-router-tanstack',
+        registryHooks: {
+            modifyRoutes: modifyRoutes,
+            onAfterCreateRouter: onAfterCreateRouter,
+            onAfterHydrateRouter: onAfterHydrateRouter,
+            onBeforeCreateRouter: onBeforeCreateRouter,
+            onBeforeCreateRoutes: onBeforeCreateRoutes,
+            onBeforeHydrateRouter: onBeforeHydrateRouter
+        },
+        setup: (api)=>{
+            api.onBeforeRender((context)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const mergedConfig = merge(pluginConfig.router || {}, userConfig);
+                if ("u" > typeof window && window._SSR_DATA && mergedConfig.unstable_reloadOnURLMismatch) {
+                    const { ssrContext } = context;
+                    const currentPathname = normalizePathname(window.location.pathname);
+                    const initialPathname = ssrContext?.request?.pathname && normalizePathname(ssrContext.request.pathname);
+                    if (initialPathname && initialPathname !== currentPathname) {
+                        const errorMsg = `The initial URL ${initialPathname} and the URL ${currentPathname} to be hydrated do not match, reload.`;
+                        console.error(errorMsg);
+                        window.location.reload();
+                    }
+                }
+                context.router = {
+                    useMatches: useMatches,
+                    useLocation: useLocation,
+                    useNavigate: useNavigate,
+                    useRouter: useRouter
+                };
+            });
+            api.wrapRoot((App)=>{
+                const mergedConfig = merge(api.getRuntimeConfig().router || {}, userConfig);
+                const { serverBase = [], supportHtml5History = true, basename = '', routesConfig, createRoutes } = mergedConfig;
+                const finalRouteConfig = {
+                    routes: getGlobalRoutes(),
+                    globalApp: getGlobalLayoutApp(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return App;
+                const hooks = api.getHooks();
+                let cachedRouteObjects;
+                const getRouteObjects = ()=>{
+                    if (void 0 !== cachedRouteObjects) return cachedRouteObjects;
+                    const routeObjects = createRoutes ? createRoutes() : createRouteObjectsFromConfig({
+                        routesConfig: finalRouteConfig
+                    }) || [];
+                    const normalizedRouteObjects = createRoutes ? routeObjects : stripSyntheticNotFoundRoute(routeObjects);
+                    cachedRouteObjects = hooks.modifyRoutes.call(normalizedRouteObjects);
+                    return cachedRouteObjects;
+                };
+                const selectBasePath = (pathname)=>{
+                    const match = serverBase.find((baseUrl)=>isSegmentPrefix(pathname, baseUrl));
+                    return match || '/';
+                };
+                let cachedRouteTree = null;
+                let cachedRouter = null;
+                let cachedRouterBasepath = null;
+                const RouterWrapper = ()=>{
+                    const runtimeContext = (0, __rspack_external_react.useContext)(InternalRuntimeContext);
+                    const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
+                    const _basename = '/' === baseUrl ? urlJoin(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+                    const routeTree = (0, __rspack_external_react.useMemo)(()=>{
+                        if (cachedRouteTree) return cachedRouteTree;
+                        const routeObjects = getRouteObjects();
+                        if (!routeObjects.length) return null;
+                        cachedRouteTree = createRouteTreeFromRouteObjects(routeObjects, {
+                            rscPayloadRouter: getGlobalEnableRsc()
+                        });
+                        return cachedRouteTree;
+                    }, []);
+                    if (!routeTree) return App ? /*#__PURE__*/ jsx(App, {}) : null;
+                    const router = (0, __rspack_external_react.useMemo)(()=>{
+                        const lifecycleContext = {
+                            framework: 'tanstack',
+                            phase: 'client-create',
+                            routes: getRouteObjects(),
+                            runtimeContext,
+                            basename: _basename
+                        };
+                        hooks.onBeforeCreateRouter.call(lifecycleContext);
+                        if (cachedRouter && cachedRouterBasepath === _basename) {
+                            wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
+                            hooks.onAfterCreateRouter.call({
+                                ...lifecycleContext,
+                                router: cachedRouter,
+                                runtimeContext
+                            });
+                            return cachedRouter;
+                        }
+                        const history = supportHtml5History ? createBrowserHistory() : createHashHistory();
+                        const rewrite = createModernBasepathRewrite(_basename);
+                        const serializationAdapters = getGlobalEnableRsc() ? getTanstackRscSerializationAdapters() : void 0;
+                        cachedRouter = createRouter({
+                            routeTree,
+                            basepath: '/',
+                            rewrite,
+                            history,
+                            context: {},
+                            ...serializationAdapters ? {
+                                serializationAdapters
+                            } : {}
+                        });
+                        cachedRouterBasepath = _basename;
+                        wrapRouterSubscribeWithBlockState(cachedRouter, runtimeContext.unstable_getBlockNavState);
+                        hooks.onAfterCreateRouter.call({
+                            ...lifecycleContext,
+                            router: cachedRouter,
+                            runtimeContext
+                        });
+                        return cachedRouter;
+                    }, [
+                        _basename,
+                        routeTree,
+                        supportHtml5History,
+                        runtimeContext
+                    ]);
+                    const runtimeState = applyRouterRuntimeState(runtimeContext, {
+                        framework: 'tanstack',
+                        basename: _basename,
+                        instance: router
+                    });
+                    const lifecycleContext = {
+                        framework: 'tanstack',
+                        phase: 'client-create',
+                        routes: getRouteObjects(),
+                        runtimeContext: runtimeState,
+                        basename: _basename,
+                        router
+                    };
+                    const hasSSRBootstrap = "u" > typeof window && Boolean(window.$_TSR);
+                    if (hasSSRBootstrap) hooks.onBeforeHydrateRouter.call({
+                        ...lifecycleContext,
+                        phase: 'hydrate',
+                        router,
+                        runtimeContext: runtimeState
+                    });
+                    const RouterContent = hasSSRBootstrap ? /*#__PURE__*/ jsx(__rspack_external_react.Suspense, {
+                        fallback: null,
+                        children: /*#__PURE__*/ jsx(RouterClient, {
+                            router: router
+                        })
+                    }) : /*#__PURE__*/ jsx(RouterProvider, {
+                        router: router
+                    });
+                    if (hasSSRBootstrap) hooks.onAfterHydrateRouter.call({
+                        ...lifecycleContext,
+                        phase: 'hydrate',
+                        router,
+                        runtimeContext: runtimeState
+                    });
+                    return App ? /*#__PURE__*/ jsx(App, {
+                        children: RouterContent
+                    }) : RouterContent;
+                };
+                return RouterWrapper;
+            });
+        }
+    };
+    return plugin;
+};
+const runtime_plugin = tanstackRouterPlugin;
+export default runtime_plugin;
+export { tanstackRouterPlugin };