@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/dist/esm/runtime/rsc/payloadFetch.mjs

@@ -0,0 +1,55 @@
+import { notFound, redirect } from "@tanstack/react-router";
+import { isAbsoluteUrl } from "../shared/isAbsoluteUrl.mjs";
+import { reviveTanstackRscFlightValues } from "./flightSerialization.mjs";
+const payloadFetchCache = new Map();
+let payloadDecoder;
+async function decodePayload(stream) {
+    if (payloadDecoder) return reviveTanstackRscFlightValues(await payloadDecoder(stream));
+    const runtime = await import("@modern-js/runtime/rsc/client");
+    return reviveTanstackRscFlightValues(await runtime.createFromReadableStream(stream));
+}
+function isServerPayload(value) {
+    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
+}
+function createPayloadFetchKey(request) {
+    return JSON.stringify([
+        request.url,
+        request.method,
+        [
+            ...request.headers.entries()
+        ].sort(([left], [right])=>left.localeCompare(right))
+    ]);
+}
+async function fetchTanstackRscPayload(request) {
+    const headers = new Headers(request.headers);
+    headers.set('x-rsc-tree', 'true');
+    const response = await fetch(request.url, {
+        credentials: 'same-origin',
+        headers,
+        method: 'GET',
+        signal: request.signal
+    });
+    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
+    if (redirectLocation) {
+        if (isAbsoluteUrl(redirectLocation)) throw redirect({
+            headers: response.headers,
+            href: redirectLocation,
+            statusCode: response.status
+        });
+        throw redirect({
+            headers: response.headers,
+            statusCode: response.status,
+            to: redirectLocation || '/'
+        });
+    }
+    if (404 === response.status && !response.body) throw notFound();
+    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
+    const payload = await decodePayload(response.body);
+    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
+    return payload;
+}
+function __setTanstackRscPayloadDecoderForTests(decoder) {
+    payloadDecoder = decoder;
+    payloadFetchCache.clear();
+}
+export { __setTanstackRscPayloadDecoderForTests, createPayloadFetchKey, fetchTanstackRscPayload, isAbsoluteUrl, payloadFetchCache };

package/dist/esm/runtime/rsc/payloadRouter.mjs

@@ -1,76 +1,8 @@
-import { isRouteErrorResponse } from "@modern-js/runtime-utils/router";
-import { notFound, redirect } from "@tanstack/react-router";
-const payloadFetchCache = new Map();
-let payloadDecoder;
-function getRouteId(match) {
-    const routeId = match.routeId ?? match.route?.id ?? match.id;
-    return 'string' == typeof routeId ? routeId : void 0;
-}
-function getRouteStaticData(match) {
-    return match.route?.options?.staticData || {};
-}
-function getRouteParentId(match) {
-    const parentId = match.route?.parentRoute?.id;
-    return 'string' == typeof parentId ? parentId : void 0;
-}
-function toRoutePath(match) {
-    const path = match.route?.options?.path;
-    return 'string' == typeof path ? path : void 0;
-}
-function toPayloadRoute(match) {
-    const routeId = getRouteId(match);
-    if (!routeId) return;
-    const staticData = getRouteStaticData(match);
-    const params = match.params && 'object' == typeof match.params ? match.params : {};
-    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
-    return {
-        handle: staticData.modernRouteHandle,
-        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
-        hasErrorBoundary: false,
-        hasLoader: Boolean(staticData.modernRouteHasLoader),
-        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
-        id: routeId,
-        index: Boolean(match.route?.options?.index) || void 0,
-        params,
-        parentId: getRouteParentId(match),
-        path: toRoutePath(match),
-        pathname,
-        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
-    };
-}
-function shouldRedactServerError(status = 500) {
-    return status >= 500 && 'development' !== process.env.NODE_ENV && 'test' !== process.env.NODE_ENV;
-}
-function serializePayloadError(error) {
-    if (isRouteErrorResponse(error)) {
-        if (shouldRedactServerError(error.status)) return {
-            status: error.status,
-            statusText: 'Internal Server Error',
-            data: 'Unexpected Server Error',
-            __type: 'RouteErrorResponse'
-        };
-        return {
-            ...error,
-            __type: 'RouteErrorResponse'
-        };
-    }
-    if (error instanceof Error) {
-        if (shouldRedactServerError()) return {
-            message: 'Unexpected Server Error',
-            stack: void 0,
-            __type: 'Error'
-        };
-        return {
-            message: error.message,
-            stack: error.stack,
-            __type: 'Error',
-            ...'Error' !== error.name ? {
-                __subType: error.name
-            } : {}
-        };
-    }
-    return error;
-}
+import { notFound } from "@tanstack/react-router";
+import { serializeTanstackRscFlightValues } from "./flightSerialization.mjs";
+import { isSerializedNotFound, serializePayloadError, toRouteErrors, toRouteLoaderData } from "./payloadErrors.mjs";
+import { __setTanstackRscPayloadDecoderForTests, createPayloadFetchKey, fetchTanstackRscPayload, payloadFetchCache } from "./payloadFetch.mjs";
+import { toPayloadRoute, toPlainLocation } from "./payloadRoutes.mjs";
 function createTanstackRscServerPayload(router, options = {}) {
     const matches = Array.isArray(router.state?.matches) ? router.state.matches : [];
     const routes = [];
@@ -80,7 +12,7 @@ function createTanstackRscServerPayload(router, options = {}) {
         const payloadRoute = toPayloadRoute(match);
         if (payloadRoute) {
             routes.push(payloadRoute);
-            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = match.loaderData;
+            if ('loaderData' in match && void 0 !== match.loaderData && !(options.omitClientLoaderData && payloadRoute.hasClientLoader)) loaderData[payloadRoute.id] = serializeTanstackRscFlightValues(match.loaderData);
             if (void 0 !== match.error) errors[payloadRoute.id] = serializePayloadError(match.error);
         }
     }
@@ -89,14 +21,17 @@ function createTanstackRscServerPayload(router, options = {}) {
         actionData: null,
         errors: Object.keys(errors).length > 0 ? errors : null,
         loaderData,
-        location: router.state?.location,
+        location: toPlainLocation(router.state?.location),
         routes
     };
 }
 function handleTanstackRscRedirect(headers, basename, status) {
     const newHeaders = new Headers(headers);
     let redirectUrl = headers.get('Location') || '/';
-    if ('/' !== basename) redirectUrl = redirectUrl.replace(basename, '') || '/';
+    if ('/' !== basename) {
+        if (redirectUrl === basename) redirectUrl = '/';
+        else if (redirectUrl.startsWith(`${basename}/`)) redirectUrl = redirectUrl.slice(basename.length);
+    }
     newHeaders.set('X-Modernjs-Redirect', redirectUrl);
     newHeaders.set('X-Modernjs-BaseUrl', basename);
     newHeaders.delete('Location');
@@ -108,69 +43,17 @@ function handleTanstackRscRedirect(headers, basename, status) {
 function isTanstackRscPayloadNavigationEnabled() {
     return "u" > typeof window;
 }
-async function decodePayload(stream) {
-    if (payloadDecoder) return payloadDecoder(stream);
-    const runtime = await import("@modern-js/runtime/rsc/client");
-    return runtime.createFromReadableStream(stream);
-}
-function isServerPayload(value) {
-    return Boolean(value) && 'object' == typeof value && 'render' === value.type && Array.isArray(value.routes);
-}
-function createPayloadFetchKey(request) {
-    return request.url;
-}
-function isAbsoluteUrl(value) {
-    try {
-        new URL(value);
-        return true;
-    } catch  {
-        return false;
-    }
-}
-async function fetchTanstackRscPayload(request) {
-    const headers = new Headers(request.headers);
-    headers.set('x-rsc-tree', 'true');
-    const response = await fetch(request.url, {
-        credentials: 'same-origin',
-        headers,
-        method: 'GET',
-        signal: request.signal
-    });
-    const redirectLocation = response.headers.get('X-Modernjs-Redirect');
-    if (redirectLocation) {
-        if (isAbsoluteUrl(redirectLocation)) throw redirect({
-            href: redirectLocation
-        });
-        throw redirect({
-            to: redirectLocation || '/'
-        });
-    }
-    if (404 === response.status && !response.body) throw notFound();
-    if (!response.body) throw new Error('TanStack RSC payload response body is null.');
-    const payload = await decodePayload(response.body);
-    if (!isServerPayload(payload)) throw new Error('Unexpected TanStack RSC payload type.');
-    return payload;
-}
 function loadTanstackRscPayload(request) {
     const key = createPayloadFetchKey(request);
     let payloadPromise = payloadFetchCache.get(key);
     if (!payloadPromise) {
         payloadPromise = fetchTanstackRscPayload(request).finally(()=>{
-            payloadFetchCache.delete(key);
+            payloadFetchCache["delete"](key);
         });
         payloadFetchCache.set(key, payloadPromise);
     }
     return payloadPromise;
 }
-function isSerializedNotFound(value) {
-    return Boolean(value) && 'object' == typeof value && true === value.isNotFound;
-}
-function toRouteErrors(payload) {
-    return payload.errors && 'object' == typeof payload.errors ? payload.errors : {};
-}
-function toRouteLoaderData(payload) {
-    return payload.loaderData && 'object' == typeof payload.loaderData ? payload.loaderData : {};
-}
 async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, request, routeId }) {
     if (hasClientLoader) return loadClientData();
     if (!routeId) return loadClientData();
@@ -189,8 +72,4 @@ async function loadTanstackRscRouteData({ hasClientLoader, loadClientData, reque
     const payloadRoute = payload.routes.find((route)=>route.id === routeId);
     if (payloadRoute && payloadRoute.hasClientLoader) return loadClientData();
 }
-function __setTanstackRscPayloadDecoderForTests(decoder) {
-    payloadDecoder = decoder;
-    payloadFetchCache.clear();
-}
 export { __setTanstackRscPayloadDecoderForTests, createTanstackRscServerPayload, handleTanstackRscRedirect, isTanstackRscPayloadNavigationEnabled, loadTanstackRscPayload, loadTanstackRscRouteData };

package/dist/esm/runtime/rsc/payloadRoutes.mjs

@@ -0,0 +1,50 @@
+function toPlainRecord(value) {
+    if (!value || 'object' != typeof value) return {};
+    return Object.fromEntries(Object.entries(value));
+}
+function toPlainLocation(location) {
+    if (!location || 'object' != typeof location) return location;
+    const plainLocation = toPlainRecord(location);
+    for (const key of [
+        'search',
+        'state'
+    ])if (plainLocation[key] && 'object' == typeof plainLocation[key] && !Array.isArray(plainLocation[key])) plainLocation[key] = toPlainRecord(plainLocation[key]);
+    return plainLocation;
+}
+function getRouteId(match) {
+    const routeId = match.routeId ?? match.route?.id ?? match.id;
+    return 'string' == typeof routeId ? routeId : void 0;
+}
+function getRouteStaticData(match) {
+    return match.route?.options?.staticData || {};
+}
+function getRouteParentId(match) {
+    const parentId = match.route?.parentRoute?.id;
+    return 'string' == typeof parentId ? parentId : void 0;
+}
+function toRoutePath(match) {
+    const path = match.route?.options?.path;
+    return 'string' == typeof path ? path : void 0;
+}
+function toPayloadRoute(match) {
+    const routeId = getRouteId(match);
+    if (!routeId) return;
+    const staticData = getRouteStaticData(match);
+    const params = match.params && 'object' == typeof match.params ? toPlainRecord(match.params) : {};
+    const pathname = 'string' == typeof match.pathname ? match.pathname : '';
+    return {
+        handle: staticData.modernRouteHandle,
+        hasAction: Boolean(staticData.modernRouteHasAction || staticData.modernRouteAction),
+        hasErrorBoundary: false,
+        hasLoader: Boolean(staticData.modernRouteHasLoader),
+        hasClientLoader: Boolean(staticData.modernRouteHasClientLoader),
+        id: routeId,
+        index: Boolean(match.route?.options?.index) || void 0,
+        params,
+        parentId: getRouteParentId(match),
+        path: toRoutePath(match),
+        pathname,
+        pathnameBase: 'string' == typeof match.pathnameBase ? match.pathnameBase : pathname
+    };
+}
+export { getRouteId, toPayloadRoute, toPlainLocation };

package/dist/esm/runtime/rsc/payloadStorage.mjs

@@ -0,0 +1,14 @@
+import { storage } from "@modern-js/runtime-utils/node";
+const setTanstackRscServerPayload = (payload)=>{
+    const storageContext = storage.useContext?.();
+    if (storageContext) storageContext.serverPayload = payload;
+};
+const setTanstackRscRouter = (router)=>{
+    const storageContext = storage.useContext?.();
+    if (storageContext) storageContext.tanstackRscRouter = router;
+};
+const getTanstackRscRouter = ()=>{
+    const storageContext = storage.useContext?.();
+    return storageContext?.tanstackRscRouter;
+};
+export { getTanstackRscRouter, setTanstackRscRouter, setTanstackRscServerPayload };

package/dist/esm/runtime/rsc/server.mjs

@@ -1,26 +1,11 @@
 import { Fragment, jsx } from "react/jsx-runtime";
-import { createFromReadableStream, renderRsc } from "@modern-js/runtime/rsc/server";
-import { createSerializationAdapter } from "@tanstack/react-router";
-import { RawStream } from "@tanstack/router-core";
-import { createElement, use } from "react";
+import { renderRsc } from "@modern-js/runtime/rsc/server";
+import { RawStream, createSerializationAdapter } from "@tanstack/router-core";
+import { createElement } from "react";
 import { ClientSlot } from "./ClientSlot.mjs";
-import { createRscProxy } from "./createRscProxy.mjs";
 import { ReplayableStream } from "./ReplayableStream.mjs";
 import { sanitizeSlotArgs } from "./slotUsageSanitizer.mjs";
-import { RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
-function createTreeGetter(stream) {
-    let ready = false;
-    let tree;
-    const treePromise = Promise.resolve(createFromReadableStream(stream.createReplayStream())).then((value)=>{
-        tree = value;
-        ready = true;
-        return value;
-    });
-    return ()=>{
-        if (ready) return tree;
-        return use(treePromise);
-    };
-}
+import { RENDERABLE_RSC, RSC_SLOT_USAGES_STREAM, SERVER_COMPONENT_STREAM, isRenderableServerComponent, isServerComponent } from "./symbols.mjs";
 function createSlotProxy(options) {
     const cache = new Map();
     return new Proxy({}, {
@@ -44,6 +29,17 @@ function createSlotProxy(options) {
         }
     });
 }
+function createServerRscValue(options) {
+    return {
+        [SERVER_COMPONENT_STREAM]: options.stream,
+        ...options.renderable ? {
+            [RENDERABLE_RSC]: true
+        } : {},
+        ...options.slotUsagesStream ? {
+            [RSC_SLOT_USAGES_STREAM]: options.slotUsagesStream
+        } : {}
+    };
+}
 function toReplayableFlightStream(node, handlers) {
     const flightStream = renderRsc({
         element: node
@@ -57,7 +53,7 @@ async function renderServerComponent(node) {
     const streamWrapper = {
         createReplayStream: ()=>stream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: true,
         stream: streamWrapper
     });
@@ -86,7 +82,7 @@ async function createCompositeComponent(component) {
     const streamWrapper = {
         createReplayStream: ()=>flightStream.createReplayStream()
     };
-    return createRscProxy(createTreeGetter(streamWrapper), {
+    return createServerRscValue({
         renderable: false,
         slotUsagesStream: slotUsagesEmitter?.stream,
         stream: streamWrapper

package/dist/esm/runtime/rsc/shared.mjs

@@ -0,0 +1,21 @@
+import { RSC_PROXY_GET_TREE, RSC_PROXY_PATH } from "./symbols.mjs";
+const TANSTACK_RSC_FLIGHT_VALUE = '__modernTanstackRsc';
+function isSerializedTanstackRscFlightValue(value) {
+    return Boolean(value) && 'object' == typeof value && true === value[TANSTACK_RSC_FLIGHT_VALUE] && ('renderable' === value.kind || 'composite' === value.kind) && value.stream instanceof ReadableStream;
+}
+function EmptyFallback() {
+    return null;
+}
+function selectTreePath(tree, path) {
+    let current = tree;
+    for (const key of path){
+        if (null === current || 'object' != typeof current) return null;
+        current = current[key];
+    }
+    return current;
+}
+function renderSelectedTree(src, { getTree = src[RSC_PROXY_GET_TREE], missingTreeError }) {
+    if (!getTree) throw new Error(missingTreeError);
+    return selectTreePath(getTree(), src[RSC_PROXY_PATH] || []);
+}
+export { EmptyFallback, TANSTACK_RSC_FLIGHT_VALUE, isSerializedTanstackRscFlightValue, renderSelectedTree };

package/dist/esm/runtime/rsc/slotUsageSanitizer.mjs

@@ -13,6 +13,7 @@ function sanitizeSlotArg(value, seen) {
     if (null == value) return value;
     if ('string' == typeof value || 'number' == typeof value || 'boolean' == typeof value || 'bigint' == typeof value) return value;
     if ('object' != typeof value && 'function' != typeof value) return String(value);
+    if ('function' == typeof value) return '[Function]';
     if (seen.has(value)) return '[Circular]';
     seen.add(value);
     if (Array.isArray(value)) return value.map((item)=>sanitizeSlotArg(item, seen));

package/dist/esm/runtime/rsc/treeGetter.mjs

@@ -0,0 +1,34 @@
+"use client";
+import { use } from "react";
+let modernRscClientRuntimePromise;
+function loadModernRscClientRuntime() {
+    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
+        runtime.setServerCallback(runtime.callServer);
+        return runtime;
+    });
+    return modernRscClientRuntimePromise;
+}
+async function createFromFlightStream(stream) {
+    if ("u" < typeof window) {
+        const runtime = await import("react-server-dom-rspack/client.edge");
+        return runtime.createFromReadableStream(stream);
+    }
+    const runtime = await loadModernRscClientRuntime();
+    return runtime.createFromReadableStream(stream, {
+        callServer: runtime.callServer
+    });
+}
+function createTreeGetterFromFlightStream(stream) {
+    let ready = false;
+    let tree;
+    const treePromise = createFromFlightStream(stream).then((value)=>{
+        tree = value;
+        ready = true;
+        return value;
+    });
+    return ()=>{
+        if (ready) return tree;
+        return use(treePromise);
+    };
+}
+export { createTreeGetterFromFlightStream };

package/dist/esm/runtime/shared/isAbsoluteUrl.mjs

@@ -0,0 +1,9 @@
+function isAbsoluteUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export { isAbsoluteUrl };

package/dist/esm/runtime/ssrManagedTags.mjs

@@ -0,0 +1,53 @@
+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 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;
+}
+async function attachServerSsrUtils(router) {
+    const { attachRouterServerSsrUtils } = await import("@tanstack/router-core/ssr/server");
+    attachRouterServerSsrUtils({
+        router,
+        manifest: void 0
+    });
+}
+export { attachServerSsrUtils, collectRouterErrors, createGetSsrHref, routerManagedTagsToHtml, waitForRouterSerialization };

package/dist/esm/runtime/ssrPreload.mjs

@@ -0,0 +1,51 @@
+function isPromiseLike(value) {
+    return Boolean(value && 'function' == typeof value.then);
+}
+function isPreloadableRouteComponent(component) {
+    if (!component || 'function' != typeof component) return false;
+    const preloadable = component;
+    return 'function' == typeof preloadable.load || 'function' == typeof preloadable.preload;
+}
+function isReactLazyRouteComponent(component) {
+    return null != component && 'object' == typeof component && 'function' == typeof component._init && '_payload' in component;
+}
+async function preloadReactLazyRouteComponent(component) {
+    try {
+        component._init?.(component._payload);
+    } catch (thrown) {
+        if (!isPromiseLike(thrown)) throw thrown;
+        await thrown;
+        component._init?.(component._payload);
+    }
+}
+async function preloadRouteComponent(component, preloadedComponents) {
+    if (isReactLazyRouteComponent(component)) {
+        if (preloadedComponents.has(component)) return;
+        preloadedComponents.add(component);
+        await preloadReactLazyRouteComponent(component);
+        return;
+    }
+    if (!isPreloadableRouteComponent(component)) return;
+    if (preloadedComponents.has(component)) return;
+    preloadedComponents.add(component);
+    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 || {};
+    const preloadedComponents = new Set();
+    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, preloadedComponents),
+            preloadRouteComponent(options.pendingComponent, preloadedComponents),
+            preloadRouteComponent(options.errorComponent, preloadedComponents),
+            preloadRouteComponent(options.notFoundComponent, preloadedComponents)
+        ]);
+    }));
+}
+export { preloadMatchedRouteComponents };

package/dist/esm/runtime/state.mjs

@@ -1,7 +1,7 @@
 import { getRouterRuntimeState } from "@modern-js/runtime/context";
 function getTanstackRouterState(context) {
     const state = getRouterRuntimeState(context);
-    if (void 0 === state || 'tanstack' !== state.framework) return;
+    if (void 0 === state || 'tanstack' !== state.framework || void 0 === state.instance) return;
     return state;
 }
 export { getTanstackRouterState };