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

package/dist/cjs/runtime/lifecycle.js

@@ -0,0 +1,125 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    applyRouterRuntimeState: ()=>applyRouterRuntimeState,
+    applyRouterServerPrepareResult: ()=>applyRouterServerPrepareResult,
+    createRouterRuntimeState: ()=>createRouterRuntimeState,
+    createRouterServerSnapshot: ()=>createRouterServerSnapshot
+});
+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;
+}
+exports.applyRouterRuntimeState = __webpack_exports__.applyRouterRuntimeState;
+exports.applyRouterServerPrepareResult = __webpack_exports__.applyRouterServerPrepareResult;
+exports.createRouterRuntimeState = __webpack_exports__.createRouterRuntimeState;
+exports.createRouterServerSnapshot = __webpack_exports__.createRouterServerSnapshot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "applyRouterRuntimeState",
+    "applyRouterServerPrepareResult",
+    "createRouterRuntimeState",
+    "createRouterServerSnapshot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/plugin.js

@@ -0,0 +1,250 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>runtime_plugin,
+    tanstackRouterPlugin: ()=>tanstackRouterPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const url_namespaceObject = require("@modern-js/runtime-utils/url");
+const react_router_namespaceObject = require("@tanstack/react-router");
+const client_namespaceObject = require("@tanstack/react-router/ssr/client");
+const external_react_namespaceObject = require("react");
+const external_basepathRewrite_js_namespaceObject = require("./basepathRewrite.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_routeTree_js_namespaceObject = require("./routeTree.js");
+const client_js_namespaceObject = require("./rsc/client.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+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: external_hooks_js_namespaceObject.modifyRoutes,
+            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
+            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
+            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
+            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
+            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
+        },
+        setup: (api)=>{
+            api.onBeforeRender((context)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const mergedConfig = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+                if ("u" > typeof window && window._SSR_DATA && mergedConfig.unstable_reloadOnURLMismatch) {
+                    const { ssrContext } = context;
+                    const currentPathname = (0, url_namespaceObject.normalizePathname)(window.location.pathname);
+                    const initialPathname = ssrContext?.request?.pathname && (0, url_namespaceObject.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: react_router_namespaceObject.useMatches,
+                    useLocation: react_router_namespaceObject.useLocation,
+                    useNavigate: react_router_namespaceObject.useNavigate,
+                    useRouter: react_router_namespaceObject.useRouter
+                };
+            });
+            api.wrapRoot((App)=>{
+                const mergedConfig = (0, merge_namespaceObject.merge)(api.getRuntimeConfig().router || {}, userConfig);
+                const { serverBase = [], supportHtml5History = true, basename = '', routesConfig, createRoutes } = mergedConfig;
+                const finalRouteConfig = {
+                    routes: (0, context_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, context_namespaceObject.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() : (0, external_utils_js_namespaceObject.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, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
+                    const baseUrl = selectBasePath(location.pathname).replace(/^\/*/, '/');
+                    const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, runtimeContext._internalRouterBaseName || basename || '') : baseUrl;
+                    const routeTree = (0, external_react_namespaceObject.useMemo)(()=>{
+                        if (cachedRouteTree) return cachedRouteTree;
+                        const routeObjects = getRouteObjects();
+                        if (!routeObjects.length) return null;
+                        cachedRouteTree = (0, external_routeTree_js_namespaceObject.createRouteTreeFromRouteObjects)(routeObjects, {
+                            rscPayloadRouter: (0, context_namespaceObject.getGlobalEnableRsc)()
+                        });
+                        return cachedRouteTree;
+                    }, []);
+                    if (!routeTree) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {}) : null;
+                    const router = (0, external_react_namespaceObject.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 ? (0, react_router_namespaceObject.createBrowserHistory)() : (0, react_router_namespaceObject.createHashHistory)();
+                        const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
+                        const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (0, client_js_namespaceObject.getTanstackRscSerializationAdapters)() : void 0;
+                        cachedRouter = (0, react_router_namespaceObject.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 = (0, external_lifecycle_js_namespaceObject.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__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
+                        fallback: null,
+                        children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(client_namespaceObject.RouterClient, {
+                            router: router
+                        })
+                    }) : /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
+                        router: router
+                    });
+                    if (hasSSRBootstrap) hooks.onAfterHydrateRouter.call({
+                        ...lifecycleContext,
+                        phase: 'hydrate',
+                        router,
+                        runtimeContext: runtimeState
+                    });
+                    return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                        children: RouterContent
+                    }) : RouterContent;
+                };
+                return RouterWrapper;
+            });
+        }
+    };
+    return plugin;
+};
+const runtime_plugin = tanstackRouterPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.tanstackRouterPlugin = __webpack_exports__.tanstackRouterPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "tanstackRouterPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/plugin.node.js

@@ -0,0 +1,304 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    default: ()=>plugin_node,
+    tanstackRouterPlugin: ()=>tanstackRouterPlugin
+});
+const jsx_runtime_namespaceObject = require("react/jsx-runtime");
+const context_namespaceObject = require("@modern-js/runtime/context");
+const merge_namespaceObject = require("@modern-js/runtime-utils/merge");
+const node_namespaceObject = require("@modern-js/runtime-utils/node");
+const time_namespaceObject = require("@modern-js/runtime-utils/time");
+const constants_namespaceObject = require("@modern-js/utils/universal/constants");
+const react_router_namespaceObject = require("@tanstack/react-router");
+const server_namespaceObject = require("@tanstack/react-router/ssr/server");
+const external_react_namespaceObject = require("react");
+const external_basepathRewrite_js_namespaceObject = require("./basepathRewrite.js");
+const external_hooks_js_namespaceObject = require("./hooks.js");
+const external_lifecycle_js_namespaceObject = require("./lifecycle.js");
+const external_routeTree_js_namespaceObject = require("./routeTree.js");
+const payloadRouter_js_namespaceObject = require("./rsc/payloadRouter.js");
+const external_utils_js_namespaceObject = require("./utils.js");
+const setTanstackRscServerPayload = (payload)=>{
+    const storageContext = node_namespaceObject.storage.useContext?.();
+    if (storageContext) storageContext.serverPayload = payload;
+};
+function isPreloadableRouteComponent(component) {
+    if (!component || 'function' != typeof component) return false;
+    const preloadable = component;
+    return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
+}
+async function preloadRouteComponent(component) {
+    if (!isPreloadableRouteComponent(component)) return;
+    if ('function' == typeof component.load) return void await component.load({});
+    await component.preload?.({});
+}
+async function preloadMatchedRouteComponents(tanstackRouter) {
+    const matches = Array.isArray(tanstackRouter.state.matches) ? tanstackRouter.state.matches : [];
+    const routesById = tanstackRouter.routesById || {};
+    await Promise.all(matches.map(async (match)=>{
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : void 0;
+        const route = routeId ? routesById[routeId] : match.route;
+        const options = route?.options;
+        if (!options) return;
+        await Promise.all([
+            preloadRouteComponent(options.component),
+            preloadRouteComponent(options.pendingComponent),
+            preloadRouteComponent(options.errorComponent),
+            preloadRouteComponent(options.notFoundComponent)
+        ]);
+    }));
+}
+async function waitForRouterSerialization(tanstackRouter) {
+    const serverSsr = tanstackRouter.serverSsr;
+    if (!serverSsr || 'function' != typeof serverSsr.onSerializationFinished || serverSsr.isSerializationFinished?.()) return;
+    await new Promise((resolve)=>{
+        serverSsr.onSerializationFinished?.(resolve);
+    });
+}
+function htmlEscapeAttr(value) {
+    return value.replace(/&/g, '&').replace(/"/g, '"');
+}
+function routerManagedTagToHtml(tag) {
+    if (!tag || 'object' != typeof tag) return '';
+    const managedTag = tag;
+    if (!managedTag || "script" !== managedTag.tag) return '';
+    const attrs = managedTag.attrs || {};
+    const attrsStr = Object.entries(attrs).filter(([, v])=>null != v && false !== v).map(([k, v])=>{
+        const name = 'className' === k ? 'class' : k;
+        if (true === v) return name;
+        return `${name}="${htmlEscapeAttr(String(v))}"`;
+    }).join(' ');
+    const open = attrsStr.length ? `<script ${attrsStr}>` : "<script>";
+    const children = 'string' == typeof managedTag.children ? managedTag.children : '';
+    return `${open}${children}</script>`;
+}
+function routerManagedTagsToHtml(tags) {
+    const normalizedTags = Array.isArray(tags) ? tags : [
+        tags
+    ];
+    return normalizedTags.map(routerManagedTagToHtml).filter(Boolean);
+}
+function createGetSsrHref(request) {
+    const url = new URL(request.url);
+    return `${url.pathname}${url.search}${url.hash}`;
+}
+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)
+        };
+    });
+}
+function collectRouterErrors(tanstackRouter) {
+    const state = tanstackRouter.state;
+    const matches = Array.isArray(state.matches) ? state.matches : [];
+    const errors = matches.reduce((acc, match)=>{
+        if (!match.error) return acc;
+        const routeId = 'string' == typeof match.routeId ? match.routeId : 'string' == typeof match.route?.id ? match.route.id : `match-${Object.keys(acc).length}`;
+        acc[routeId] = match.error;
+        return acc;
+    }, {});
+    return Object.keys(errors).length > 0 ? errors : void 0;
+}
+const tanstackRouterPlugin = (userConfig = {})=>{
+    const plugin = {
+        name: '@modern-js/plugin-router-tanstack',
+        registryHooks: {
+            modifyRoutes: external_hooks_js_namespaceObject.modifyRoutes,
+            onAfterCreateRouter: external_hooks_js_namespaceObject.onAfterCreateRouter,
+            onAfterHydrateRouter: external_hooks_js_namespaceObject.onAfterHydrateRouter,
+            onBeforeCreateRouter: external_hooks_js_namespaceObject.onBeforeCreateRouter,
+            onBeforeCreateRoutes: external_hooks_js_namespaceObject.onBeforeCreateRoutes,
+            onBeforeHydrateRouter: external_hooks_js_namespaceObject.onBeforeHydrateRouter
+        },
+        setup: (api)=>{
+            api.onBeforeRender(async (context, interrupt)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const mergedConfig = (0, merge_namespaceObject.merge)(pluginConfig.router || {}, userConfig);
+                const serializationAdapters = (0, context_namespaceObject.getGlobalEnableRsc)() ? (await import("./rsc/server.js")).getTanstackRscSerializationAdapters() : void 0;
+                const enableRsc = (0, context_namespaceObject.getGlobalEnableRsc)();
+                const { basename = '', routesConfig, createRoutes } = mergedConfig;
+                const finalRouteConfig = {
+                    routes: (0, context_namespaceObject.getGlobalRoutes)(),
+                    globalApp: (0, context_namespaceObject.getGlobalLayoutApp)(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return;
+                const hooks = api.getHooks();
+                await hooks.onBeforeCreateRoutes.call(context);
+                const routeObjects = createRoutes ? createRoutes() : (0, external_utils_js_namespaceObject.createRouteObjectsFromConfig)({
+                    routesConfig: finalRouteConfig,
+                    ssrMode: context.ssrContext?.mode
+                }) || [];
+                const normalizedRouteObjects = createRoutes ? routeObjects : stripSyntheticNotFoundRoute(routeObjects);
+                const modifiedRouteObjects = hooks.modifyRoutes.call(normalizedRouteObjects);
+                if (!modifiedRouteObjects.length) return;
+                const { request, nonce, baseUrl, loaderFailureMode = 'errorBoundary' } = context.ssrContext;
+                const _basename = '/' === baseUrl ? (0, external_utils_js_namespaceObject.urlJoin)(baseUrl, basename || '') : baseUrl;
+                const initialHref = createGetSsrHref(request.raw);
+                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const requestContext = (0, node_namespaceObject.createRequestContext)(context.ssrContext?.loaderContext);
+                const controller = new AbortController();
+                const ssrRequest = new Request(request.raw.url, {
+                    method: 'GET',
+                    headers: request.raw.headers,
+                    signal: controller.signal
+                });
+                const routerContext = {
+                    request: ssrRequest,
+                    requestContext
+                };
+                const routeTree = (0, external_routeTree_js_namespaceObject.createRouteTreeFromRouteObjects)(modifiedRouteObjects);
+                const history = (0, react_router_namespaceObject.createMemoryHistory)({
+                    initialEntries: [
+                        initialHref
+                    ]
+                });
+                const rewrite = (0, external_basepathRewrite_js_namespaceObject.createModernBasepathRewrite)(_basename);
+                const routerLifecycleContext = {
+                    framework: 'tanstack',
+                    phase: 'ssr-prepare',
+                    routes: modifiedRouteObjects,
+                    runtimeContext: context,
+                    basename: _basename
+                };
+                hooks.onBeforeCreateRouter.call(routerLifecycleContext);
+                const tanstackRouter = (0, react_router_namespaceObject.createRouter)({
+                    routeTree,
+                    history,
+                    basepath: '/',
+                    rewrite,
+                    origin: new URL(request.raw.url).origin,
+                    ssr: {
+                        nonce
+                    },
+                    context: routerContext,
+                    ...serializationAdapters ? {
+                        serializationAdapters
+                    } : {}
+                });
+                const serverRouter = tanstackRouter;
+                (0, server_namespaceObject.attachRouterServerSsrUtils)({
+                    router: serverRouter,
+                    manifest: void 0
+                });
+                const end = (0, time_namespaceObject.time)();
+                try {
+                    await tanstackRouter.load({
+                        sync: true
+                    });
+                } finally{
+                    const cost = end();
+                    context.ssrContext?.onTiming?.(constants_namespaceObject.LOADER_REPORTER_NAME, cost);
+                }
+                if (serverRouter.state.redirect) {
+                    const resolved = serverRouter.resolveRedirect ? serverRouter.resolveRedirect(serverRouter.state.redirect) : serverRouter.state.redirect;
+                    try {
+                        serverRouter.serverSsr?.cleanup?.();
+                    } catch  {}
+                    return interrupt(isRSCNavigation ? (0, payloadRouter_js_namespaceObject.handleTanstackRscRedirect)(resolved.headers, _basename, resolved.status) : resolved);
+                }
+                const routerErrors = collectRouterErrors(tanstackRouter);
+                if (routerErrors && 'clientRender' === loaderFailureMode) {
+                    context.ssrContext?.response.status(200);
+                    try {
+                        serverRouter.serverSsr?.cleanup?.();
+                    } catch  {}
+                    throw Object.values(routerErrors)[0];
+                }
+                await preloadMatchedRouteComponents(serverRouter);
+                context.ssrContext?.response.status(tanstackRouter.state.statusCode);
+                await serverRouter.serverSsr?.dehydrate?.();
+                await waitForRouterSerialization(serverRouter);
+                if (isRSCNavigation) setTanstackRscServerPayload((0, payloadRouter_js_namespaceObject.createTanstackRscServerPayload)(serverRouter, {
+                    omitClientLoaderData: true
+                }));
+                const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
+                const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
+                const matchedRouteIds = (0, external_routeTree_js_namespaceObject.getModernRouteIdsFromMatches)(serverRouter);
+                const routerServerSnapshot = (0, external_lifecycle_js_namespaceObject.createRouterServerSnapshot)({
+                    framework: 'tanstack',
+                    basename: _basename,
+                    statusCode: tanstackRouter.state.statusCode,
+                    errors: routerErrors,
+                    matchedRouteIds,
+                    hydrationScripts
+                });
+                const runtimeContext = (0, external_lifecycle_js_namespaceObject.applyRouterServerPrepareResult)(context, {
+                    snapshot: routerServerSnapshot,
+                    cleanup: ()=>serverRouter.serverSsr?.cleanup?.(),
+                    state: {
+                        framework: 'tanstack',
+                        basename: _basename,
+                        instance: serverRouter,
+                        hydrationScripts,
+                        matchedRouteIds,
+                        serverSnapshot: routerServerSnapshot
+                    }
+                });
+                hooks.onAfterCreateRouter.call({
+                    ...routerLifecycleContext,
+                    router: serverRouter,
+                    serverSnapshot: routerServerSnapshot,
+                    runtimeContext
+                });
+            });
+            api.wrapRoot((App)=>{
+                const getRouteApp = ()=>(props)=>{
+                        const context = (0, external_react_namespaceObject.useContext)(context_namespaceObject.InternalRuntimeContext);
+                        const router = context.routerInstance ?? context.routerRuntime?.instance;
+                        if (!router) return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            ...props
+                        }) : null;
+                        const routerWrapper = /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
+                            fallback: null,
+                            children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(react_router_namespaceObject.RouterProvider, {
+                                router: router
+                            })
+                        });
+                        return App ? /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(App, {
+                            children: routerWrapper
+                        }) : routerWrapper;
+                    };
+                return getRouteApp();
+            });
+        }
+    };
+    return plugin;
+};
+const plugin_node = tanstackRouterPlugin;
+exports["default"] = __webpack_exports__["default"];
+exports.tanstackRouterPlugin = __webpack_exports__.tanstackRouterPlugin;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default",
+    "tanstackRouterPlugin"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});