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

package/dist/cjs/runtime/routeTree.js

@@ -28,331 +28,18 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    createRouteTreeFromRouteObjects: ()=>createRouteTreeFromRouteObjects,
-    getModernRouteIdsFromMatches: ()=>getModernRouteIdsFromMatches
+    createRouteTreeFromRouteObjects: ()=>index_js_namespaceObject.createRouteTreeFromRouteObjects,
+    getModernRouteIdsFromMatches: ()=>index_js_namespaceObject.getModernRouteIdsFromMatches,
+    pickRouteModuleComponent: ()=>index_js_namespaceObject.pickRouteModuleComponent
 });
-const context_namespaceObject = require("@modern-js/runtime/context");
-const react_router_namespaceObject = require("@tanstack/react-router");
-const external_react_namespaceObject = require("react");
-const external_loaderBridge_js_namespaceObject = require("./loaderBridge.js");
-const external_outlet_js_namespaceObject = require("./outlet.js");
-const payloadRouter_js_namespaceObject = require("./rsc/payloadRouter.js");
-function createTanstackRoute(options) {
-    return (0, react_router_namespaceObject.createRoute)(options);
-}
-function createTanstackRootRoute(options) {
-    return (0, react_router_namespaceObject.createRootRoute)(options);
-}
-function wrapRouteComponentWithModernContext(route, component, routeId) {
-    const routeMatchId = routeId || route.id;
-    if (component && routeMatchId) route.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(component, routeMatchId);
-}
-function toTanstackPath(pathname) {
-    return pathname.split('/').map((segment)=>{
-        if (!segment) return segment;
-        if ('*' === segment) return '$';
-        if (segment.startsWith(':')) {
-            const name = segment.slice(1);
-            if (name.endsWith('?')) return `{-$${name.slice(0, -1)}}`;
-            return `$${name}`;
-        }
-        return segment;
-    }).join('/');
-}
-function isModernDeferredData(value) {
-    if (!value || 'object' != typeof value) return false;
-    const deferred = value;
-    return true === deferred.__modern_deferred && Boolean(deferred.data) && 'object' == typeof deferred.data && !Array.isArray(deferred.data);
-}
-function normalizeModernLoaderResult(result) {
-    return isModernDeferredData(result) ? result.data : result;
-}
-function normalizeModernLoaderResponse(result) {
-    if ((0, external_loaderBridge_js_namespaceObject.isResponse)(result)) {
-        if ((0, external_loaderBridge_js_namespaceObject.isRedirectResponse)(result)) {
-            const location = result.headers.get('Location') || '/';
-            (0, external_loaderBridge_js_namespaceObject.throwTanstackRedirect)(location);
-        }
-        if (404 === result.status) throw (0, react_router_namespaceObject.notFound)();
-    }
-    return normalizeModernLoaderResult(result);
-}
-function pickRouteModuleComponent(routeModule, seen = new Set()) {
-    if ('function' == typeof routeModule || routeModule && 'object' == typeof routeModule && '$$typeof' in routeModule) return routeModule;
-    if (!routeModule || 'object' != typeof routeModule) return;
-    if (seen.has(routeModule)) return;
-    seen.add(routeModule);
-    const module = routeModule;
-    for (const candidate of [
-        module.default,
-        module.Component
-    ]){
-        const component = pickRouteModuleComponent(candidate, seen);
-        if (component) return component;
-    }
-}
-function createServerLazyImportComponent(lazyImport, fallbackComponent) {
-    if ("u" > typeof document) return fallbackComponent;
-    let resolvedComponent;
-    let pendingLoad;
-    const load = async ()=>{
-        if (resolvedComponent) return resolvedComponent;
-        const routeModule = await lazyImport();
-        const component = pickRouteModuleComponent(routeModule);
-        if (component) resolvedComponent = component;
-        return resolvedComponent;
-    };
-    const Component = (props)=>{
-        if (resolvedComponent) return (0, external_react_namespaceObject.createElement)(resolvedComponent, props);
-        pendingLoad ||= load();
-        throw pendingLoad;
-    };
-    Component.load = load;
-    Component.preload = load;
-    return Component;
-}
-function createModernRequest(input, signal) {
-    return new Request(input, {
-        signal
-    });
-}
-function getModernUrlFromLoaderContext(ctx) {
-    const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '/';
-    const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
-    const baseUrl = baseRequest?.url || ("u" > typeof window ? window.origin : 'http://localhost');
-    return new URL(href || '/', baseUrl);
-}
-function rememberRouteLocation(state, ctx) {
-    state.currentUrl = getModernUrlFromLoaderContext(ctx);
-    state.currentParams = ctx?.params || {};
-}
-function createModernShouldReload(shouldRevalidate, state) {
-    if ('function' != typeof shouldRevalidate) return;
-    const revalidate = shouldRevalidate;
-    return (ctx)=>{
-        const nextUrl = getModernUrlFromLoaderContext(ctx);
-        const nextParams = ctx?.params || {};
-        const result = revalidate({
-            currentUrl: state.currentUrl || nextUrl,
-            currentParams: state.currentParams || nextParams,
-            nextUrl,
-            nextParams,
-            defaultShouldRevalidate: void 0
-        });
-        state.currentUrl = nextUrl;
-        state.currentParams = nextParams;
-        return 'boolean' == typeof result ? result : void 0;
-    };
-}
-function isRouteObjectPathlessLayout(route) {
-    return !route.path && !route.index;
-}
-function isRouteObjectSplatRoute(route) {
-    return 'string' == typeof route.path && route.path.includes('*');
-}
-function mapParamsForRouteObjectLoader({ route, params }) {
-    if (isRouteObjectSplatRoute(route)) {
-        const { _splat, ...rest } = params;
-        if (void 0 !== _splat) return {
-            ...rest,
-            '*': _splat
-        };
-        return rest;
-    }
-    return params;
-}
-function wrapRouteObjectLoader(route, revalidationState, options = {}) {
-    const modernRoute = route;
-    const routeLoader = modernRoute.loader;
-    if ('function' != typeof routeLoader) return;
-    return async (ctx)=>{
-        try {
-            if (revalidationState) rememberRouteLocation(revalidationState, ctx);
-            if ('function' == typeof modernRoute.lazyImport) try {
-                await modernRoute.lazyImport();
-            } catch  {}
-            const signal = ctx?.abortController?.signal || ctx?.signal || new AbortController().signal;
-            const baseRequest = ctx?.context?.request instanceof Request ? ctx.context.request : void 0;
-            const href = 'string' == typeof ctx?.location ? ctx.location : ctx?.location?.publicHref || ctx?.location?.href || ctx?.location?.url?.href || '';
-            const request = void 0 !== baseRequest ? new Request(baseRequest, {
-                signal
-            }) : createModernRequest(href, signal);
-            const params = mapParamsForRouteObjectLoader({
-                route,
-                params: ctx.params || {}
-            });
-            const loadModernData = async ()=>{
-                const result = await routeLoader({
-                    request,
-                    params,
-                    context: ctx?.context?.requestContext
-                });
-                return normalizeModernLoaderResponse(result);
-            };
-            if (options.rscPayloadRouter && (0, payloadRouter_js_namespaceObject.isTanstackRscPayloadNavigationEnabled)()) return (0, payloadRouter_js_namespaceObject.loadTanstackRscRouteData)({
-                hasClientLoader: modernRoute.hasClientLoader || void 0 !== modernRoute.clientData,
-                loadClientData: loadModernData,
-                request,
-                routeId: ctx.route?.id
-            });
-            return loadModernData();
-        } catch (err) {
-            if ((0, external_loaderBridge_js_namespaceObject.isResponse)(err)) {
-                if ((0, external_loaderBridge_js_namespaceObject.isTanstackRedirect)(err)) throw err;
-                if ((0, external_loaderBridge_js_namespaceObject.isRedirectResponse)(err)) {
-                    const location = err.headers.get('Location') || '/';
-                    (0, external_loaderBridge_js_namespaceObject.throwTanstackRedirect)(location);
-                }
-                if (404 === err.status) throw (0, react_router_namespaceObject.notFound)();
-            }
-            throw err;
-        }
-    };
-}
-function toRouteComponent(routeObject) {
-    const route = routeObject;
-    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
-    const fallbackComponent = route.Component ? route.Component : route.element ? ()=>route.element : void 0;
-    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
-    if (route.Component) return route.Component;
-    const element = route.element;
-    if (element) return ()=>element;
-}
-function toErrorComponent(routeObject) {
-    const route = routeObject;
-    if (route.ErrorBoundary) return route.ErrorBoundary;
-    if (route.errorElement) return ()=>route.errorElement;
-}
-function toPendingComponent(routeObject) {
-    const route = routeObject;
-    return route.HydrateFallback || route.pendingComponent || void 0;
-}
-function mergeModernRouteHandle(route) {
-    const config = route.config;
-    const handle = {
-        ...route.handle,
-        ...config && 'object' == typeof config ? config.handle : {}
-    };
-    return Object.keys(handle).length > 0 ? handle : void 0;
-}
-function createRouteStaticData(opts) {
-    const staticData = {};
-    if (opts.modernRouteId) staticData.modernRouteId = opts.modernRouteId;
-    if (opts.modernRouteAction) staticData.modernRouteAction = opts.modernRouteAction;
-    if (opts.modernRouteHandle) staticData.modernRouteHandle = opts.modernRouteHandle;
-    if (opts.modernRouteHasAction) staticData.modernRouteHasAction = true;
-    if (opts.modernRouteHasClientLoader) staticData.modernRouteHasClientLoader = true;
-    if (opts.modernRouteHasLoader) staticData.modernRouteHasLoader = true;
-    if (opts.modernRouteIsClientComponent) staticData.modernRouteIsClientComponent = true;
-    if (opts.modernRouteLoader) staticData.modernRouteLoader = opts.modernRouteLoader;
-    if (opts.modernRouteShouldRevalidate) staticData.modernRouteShouldRevalidate = opts.modernRouteShouldRevalidate;
-    return Object.keys(staticData).length > 0 ? staticData : void 0;
-}
-function createRouteFromRouteObject(opts) {
-    const { options = {}, parent, routeObject } = opts;
-    const modernRouteObject = routeObject;
-    const revalidationState = {};
-    const shouldRevalidate = modernRouteObject.shouldRevalidate;
-    const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
-    const stableFallbackId = routeObject.id || modernRouteObject.file || routeObject.path || 'pathless';
-    const component = toRouteComponent(routeObject);
-    const base = {
-        getParentRoute: ()=>parent,
-        component,
-        pendingComponent: toPendingComponent(routeObject),
-        errorComponent: toErrorComponent(routeObject),
-        validateSearch: modernRouteObject.validateSearch,
-        loaderDeps: modernRouteObject.loaderDeps,
-        staticData: createRouteStaticData({
-            modernRouteId: routeObject.id,
-            modernRouteAction: modernRouteObject.action,
-            modernRouteHandle: mergeModernRouteHandle(modernRouteObject),
-            modernRouteHasAction: modernRouteObject.hasAction || Boolean(modernRouteObject.action),
-            modernRouteHasClientLoader: modernRouteObject.hasClientLoader || void 0 !== modernRouteObject.clientData,
-            modernRouteHasLoader: modernRouteObject.hasLoader || 'function' == typeof modernRouteObject.loader,
-            modernRouteIsClientComponent: modernRouteObject.isClientComponent,
-            modernRouteLoader: modernRouteObject.loader,
-            modernRouteShouldRevalidate: shouldRevalidate
-        }),
-        loader: wrapRouteObjectLoader(routeObject, revalidationState, options)
-    };
-    if (modernRouteObject.inValidSSRRoute) base.ssr = false;
-    if (shouldReload) base.shouldReload = shouldReload;
-    if (isRouteObjectPathlessLayout(routeObject)) base.id = stableFallbackId;
-    else base.path = routeObject.index ? '/' : toTanstackPath(routeObject.path || '');
-    const route = createTanstackRoute(base);
-    wrapRouteComponentWithModernContext(route, component, routeObject.id);
-    const children = routeObject.children;
-    if (children && children.length > 0) {
-        const childRoutes = children.map((child)=>createRouteFromRouteObject({
-                options,
-                parent: route,
-                routeObject: child
-            }));
-        route.addChildren(childRoutes);
-    }
-    return route;
-}
-function getRootLikeRouteObject(routes) {
-    return routes.find((route)=>'/' === route.path && !route.index);
-}
-function createRouteTreeFromRouteObjects(routes, options = {}) {
-    const rootLikeRoute = getRootLikeRouteObject(routes);
-    const rootRevalidationState = {};
-    const rootShouldRevalidate = rootLikeRoute?.shouldRevalidate;
-    const rootShouldReload = createModernShouldReload(rootShouldRevalidate, rootRevalidationState);
-    const rootComponent = rootLikeRoute ? toRouteComponent(rootLikeRoute) : void 0;
-    const rootRouteOptions = {
-        component: rootComponent,
-        pendingComponent: rootLikeRoute ? toPendingComponent(rootLikeRoute) : void 0,
-        errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : void 0,
-        validateSearch: rootLikeRoute?.validateSearch,
-        loaderDeps: rootLikeRoute?.loaderDeps,
-        notFoundComponent: context_namespaceObject.DefaultNotFound,
-        staticData: createRouteStaticData({
-            modernRouteId: rootLikeRoute?.id,
-            modernRouteAction: rootLikeRoute?.action,
-            modernRouteHandle: rootLikeRoute ? mergeModernRouteHandle(rootLikeRoute) : void 0,
-            modernRouteHasAction: rootLikeRoute?.hasAction || Boolean(rootLikeRoute?.action),
-            modernRouteHasClientLoader: rootLikeRoute?.hasClientLoader || void 0 !== rootLikeRoute?.clientData,
-            modernRouteHasLoader: rootLikeRoute?.hasLoader || 'function' == typeof rootLikeRoute?.loader,
-            modernRouteIsClientComponent: rootLikeRoute?.isClientComponent,
-            modernRouteLoader: rootLikeRoute?.loader,
-            modernRouteShouldRevalidate: rootShouldRevalidate
-        }),
-        loader: rootLikeRoute ? wrapRouteObjectLoader(rootLikeRoute, rootRevalidationState, options) : void 0
-    };
-    if (rootShouldReload) rootRouteOptions.shouldReload = rootShouldReload;
-    if (rootLikeRoute?.inValidSSRRoute) rootRouteOptions.ssr = false;
-    const rootRoute = createTanstackRootRoute(rootRouteOptions);
-    if (rootComponent) rootRoute.options.component = (0, external_outlet_js_namespaceObject.withModernRouteMatchContext)(rootComponent, react_router_namespaceObject.rootRouteId);
-    const topLevel = rootLikeRoute ? [
-        ...rootLikeRoute.children || [],
-        ...routes.filter((route)=>route !== rootLikeRoute)
-    ] : routes;
-    const childRoutes = topLevel.map((routeObject)=>createRouteFromRouteObject({
-            options,
-            parent: rootRoute,
-            routeObject
-        }));
-    rootRoute.addChildren(childRoutes);
-    return rootRoute;
-}
-function getModernRouteIdsFromMatches(router) {
-    const matches = router.state.matches || [];
-    const routesById = router.routesById;
-    const ids = matches.map((match)=>{
-        const normalizedMatch = match;
-        const routeId = 'string' == typeof normalizedMatch.routeId ? normalizedMatch.routeId : void 0;
-        return normalizedMatch.route?.options?.staticData?.modernRouteId ?? (routeId ? routesById?.[routeId]?.options?.staticData?.modernRouteId : void 0);
-    }).filter((id)=>'string' == typeof id);
-    return Array.from(new Set(ids));
-}
+const index_js_namespaceObject = require("./routeTree/index.js");
 exports.createRouteTreeFromRouteObjects = __webpack_exports__.createRouteTreeFromRouteObjects;
 exports.getModernRouteIdsFromMatches = __webpack_exports__.getModernRouteIdsFromMatches;
+exports.pickRouteModuleComponent = __webpack_exports__.pickRouteModuleComponent;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "createRouteTreeFromRouteObjects",
-    "getModernRouteIdsFromMatches"
+    "getModernRouteIdsFromMatches",
+    "pickRouteModuleComponent"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/runtime/router.js

@@ -28,10 +28,23 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    routerPlugin: ()=>internal_namespaceObject.routerPlugin
+    routerPlugin: ()=>routerPlugin
 });
-require("./register.js");
 const internal_namespaceObject = require("@modern-js/runtime/router/internal");
+const external_register_js_namespaceObject = require("./register.js");
+function getRouterPlugin() {
+    const createRouterPlugin = Reflect.get(internal_namespaceObject, 'createRouterPlugin');
+    if ('function' == typeof createRouterPlugin) return createRouterPlugin([
+        {
+            name: 'tanstack',
+            factory: external_register_js_namespaceObject.tanstackRouterProviderFactory
+        }
+    ]);
+    const legacyRouterPlugin = Reflect.get(internal_namespaceObject, 'routerPlugin');
+    if ('function' == typeof legacyRouterPlugin) return external_register_js_namespaceObject.tanstackRouterProviderFactory;
+    throw new Error('[@modern-js/plugin-tanstack] The installed @modern-js/runtime/router/internal exports neither createRouterPlugin nor routerPlugin. Install a compatible @modern-js/runtime version.');
+}
+const routerPlugin = getRouterPlugin();
 exports.routerPlugin = __webpack_exports__.routerPlugin;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "routerPlugin"

package/dist/cjs/runtime/rsc/CompositeComponent.js

@@ -34,22 +34,27 @@ __webpack_require__.d(__webpack_exports__, {
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
 const external_SlotContext_js_namespaceObject = require("./SlotContext.js");
+const external_shared_js_namespaceObject = require("./shared.js");
 const external_symbols_js_namespaceObject = require("./symbols.js");
-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];
+const external_treeGetter_js_namespaceObject = require("./treeGetter.js");
+const rawServerValueGetters = new WeakMap();
+function getRawServerTreeGetter(src) {
+    if (!src || 'object' != typeof src && 'function' != typeof src) return;
+    const source = src;
+    const stream = source[external_symbols_js_namespaceObject.SERVER_COMPONENT_STREAM];
+    if ('function' != typeof stream?.createReplayStream) return;
+    let getTree = rawServerValueGetters.get(src);
+    if (!getTree) {
+        getTree = (0, external_treeGetter_js_namespaceObject.createTreeGetterFromFlightStream)(stream.createReplayStream());
+        rawServerValueGetters.set(src, getTree);
     }
-    return current;
+    return getTree;
 }
 function CompositeInner({ slotProps, src, strict }) {
-    const getTree = src[external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('CompositeComponent src must come from createCompositeComponent().');
-    const tree = selectTreePath(getTree(), src[external_symbols_js_namespaceObject.RSC_PROXY_PATH] || []);
+    const tree = (0, external_shared_js_namespaceObject.renderSelectedTree)(src, {
+        getTree: src[external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE] || getRawServerTreeGetter(src),
+        missingTreeError: 'CompositeComponent src must come from createCompositeComponent().'
+    });
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_SlotContext_js_namespaceObject.SlotProvider, {
         implementations: slotProps,
         strict: strict,
@@ -59,7 +64,7 @@ function CompositeInner({ slotProps, src, strict }) {
 function CompositeComponent(props) {
     const { children, src, strict, ...slotProps } = props;
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
-        fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyFallback, {}),
+        fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_shared_js_namespaceObject.EmptyFallback, {}),
         children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(CompositeInner, {
             slotProps: {
                 ...slotProps,

package/dist/cjs/runtime/rsc/ReplayableStream.js

@@ -132,13 +132,9 @@ _REPLAYABLE_STREAM_MARKER = REPLAYABLE_STREAM_MARKER;
 var _REPLAYABLE_STREAM_MARKER;
 __webpack_require__.d(__webpack_exports__, {
     ReplayableStream: ()=>ReplayableStream
-}, {
-    REPLAYABLE_STREAM_MARKER: REPLAYABLE_STREAM_MARKER
 });
-exports.REPLAYABLE_STREAM_MARKER = __webpack_exports__.REPLAYABLE_STREAM_MARKER;
 exports.ReplayableStream = __webpack_exports__.ReplayableStream;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "REPLAYABLE_STREAM_MARKER",
     "ReplayableStream"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/cjs/runtime/rsc/RscNodeRenderer.js

@@ -33,28 +33,17 @@ __webpack_require__.d(__webpack_exports__, {
 });
 const jsx_runtime_namespaceObject = require("react/jsx-runtime");
 const external_react_namespaceObject = require("react");
-const external_symbols_js_namespaceObject = require("./symbols.js");
-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;
-}
+const external_shared_js_namespaceObject = require("./shared.js");
 function RscNodeRenderInner({ data }) {
-    const getTree = data[external_symbols_js_namespaceObject.RSC_PROXY_GET_TREE];
-    if (!getTree) throw new Error('Renderable RSC is missing its decoded tree getter.');
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(jsx_runtime_namespaceObject.Fragment, {
-        children: selectTreePath(getTree(), data[external_symbols_js_namespaceObject.RSC_PROXY_PATH] || [])
+        children: (0, external_shared_js_namespaceObject.renderSelectedTree)(data, {
+            missingTreeError: 'Renderable RSC is missing its decoded tree getter.'
+        })
     });
 }
 function RscNodeRenderer({ data }) {
     return /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_react_namespaceObject.Suspense, {
-        fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(EmptyFallback, {}),
+        fallback: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(external_shared_js_namespaceObject.EmptyFallback, {}),
         children: /*#__PURE__*/ (0, jsx_runtime_namespaceObject.jsx)(RscNodeRenderInner, {
             data: data
         })

package/dist/cjs/runtime/rsc/client.js

@@ -30,46 +30,27 @@ var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
     CompositeComponent: ()=>external_CompositeComponent_js_namespaceObject.CompositeComponent,
+    createTanstackRscValueFromFlight: ()=>createTanstackRscValueFromFlight,
     getTanstackRscSerializationAdapters: ()=>getTanstackRscSerializationAdapters,
     rscSerializationAdapter: ()=>rscSerializationAdapter
 });
 const react_router_namespaceObject = require("@tanstack/react-router");
-const external_react_namespaceObject = require("react");
 const external_CompositeComponent_js_namespaceObject = require("./CompositeComponent.js");
 const external_createRscProxy_js_namespaceObject = require("./createRscProxy.js");
-let modernRscClientRuntimePromise;
-function loadModernRscClientRuntime() {
-    modernRscClientRuntimePromise ??= import("@modern-js/runtime/rsc/client").then((runtime)=>{
-        runtime.setServerCallback(runtime.callServer);
-        return runtime;
-    });
-    return modernRscClientRuntimePromise;
-}
-function createTreeGetter(stream) {
-    let ready = false;
-    let tree;
-    const treePromise = loadModernRscClientRuntime().then((runtime)=>runtime.createFromReadableStream(stream, {
-            callServer: runtime.callServer
-        })).then((value)=>{
-        tree = value;
-        ready = true;
-        return value;
-    });
-    return ()=>{
-        if (ready) return tree;
-        return (0, external_react_namespaceObject.use)(treePromise);
-    };
-}
+const external_treeGetter_js_namespaceObject = require("./treeGetter.js");
 function createFromFlightStream(serialized) {
     const streamWrapper = {
         createReplayStream: ()=>serialized.stream
     };
-    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)(createTreeGetter(serialized.stream), {
+    return (0, external_createRscProxy_js_namespaceObject.createRscProxy)((0, external_treeGetter_js_namespaceObject.createTreeGetterFromFlightStream)(serialized.stream), {
         renderable: 'renderable' === serialized.kind,
         slotUsagesStream: serialized.slotUsagesStream,
         stream: streamWrapper
     });
 }
+function createTanstackRscValueFromFlight(serialized) {
+    return createFromFlightStream(serialized);
+}
 const adapter = (0, react_router_namespaceObject.createSerializationAdapter)({
     key: '$MODERN_TANSTACK_RSC',
     test: (_value)=>false,
@@ -85,10 +66,12 @@ function getTanstackRscSerializationAdapters() {
 }
 const rscSerializationAdapter = getTanstackRscSerializationAdapters;
 exports.CompositeComponent = __webpack_exports__.CompositeComponent;
+exports.createTanstackRscValueFromFlight = __webpack_exports__.createTanstackRscValueFromFlight;
 exports.getTanstackRscSerializationAdapters = __webpack_exports__.getTanstackRscSerializationAdapters;
 exports.rscSerializationAdapter = __webpack_exports__.rscSerializationAdapter;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
     "CompositeComponent",
+    "createTanstackRscValueFromFlight",
     "getTanstackRscSerializationAdapters",
     "rscSerializationAdapter"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];

package/dist/cjs/runtime/rsc/flightSerialization.js

@@ -0,0 +1,132 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    isPlainObject: ()=>isPlainObject,
+    reviveTanstackRscFlightValues: ()=>reviveTanstackRscFlightValues,
+    serializeTanstackRscFlightValues: ()=>serializeTanstackRscFlightValues
+});
+const external_shared_js_namespaceObject = require("./shared.js");
+const external_symbols_js_namespaceObject = require("./symbols.js");
+function isPlainObject(value) {
+    if (!value || 'object' != typeof value) return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || null === prototype;
+}
+function serializeTanstackRscFlightValues(value, seen = new WeakMap()) {
+    if ((0, external_symbols_js_namespaceObject.isServerComponent)(value)) {
+        const streamWrapper = value[external_symbols_js_namespaceObject.SERVER_COMPONENT_STREAM];
+        if (!streamWrapper) throw new Error('Cannot serialize TanStack RSC without a Flight stream.');
+        const kind = (0, external_symbols_js_namespaceObject.isRenderableServerComponent)(value) ? 'renderable' : 'composite';
+        const slotUsagesStream = 'development' === process.env.NODE_ENV && 'composite' === kind ? value[external_symbols_js_namespaceObject.RSC_SLOT_USAGES_STREAM] : void 0;
+        return {
+            [external_shared_js_namespaceObject.TANSTACK_RSC_FLIGHT_VALUE]: true,
+            kind,
+            stream: streamWrapper.createReplayStream(),
+            ...slotUsagesStream ? {
+                slotUsagesStream
+            } : {}
+        };
+    }
+    if (!value || 'object' != typeof value) return value;
+    if (seen.has(value)) return seen.get(value);
+    if (value instanceof Map) {
+        const result = new Map();
+        seen.set(value, result);
+        for (const [key, item] of value)result.set(serializeTanstackRscFlightValues(key, seen), serializeTanstackRscFlightValues(item, seen));
+        return result;
+    }
+    if (value instanceof Set) {
+        const result = new Set();
+        seen.set(value, result);
+        for (const item of value)result.add(serializeTanstackRscFlightValues(item, seen));
+        return result;
+    }
+    if (Array.isArray(value)) {
+        const result = [];
+        seen.set(value, result);
+        for (const item of value)result.push(serializeTanstackRscFlightValues(item, seen));
+        return result;
+    }
+    if (!isPlainObject(value)) return value;
+    const result = {};
+    seen.set(value, result);
+    for (const [key, item] of Object.entries(value))result[key] = serializeTanstackRscFlightValues(item, seen);
+    return result;
+}
+async function reviveTanstackRscFlightValues(value, seen = new WeakMap()) {
+    let reviver;
+    const getReviver = async ()=>{
+        if (!reviver) {
+            const client = await import("./client.js");
+            reviver = client.createTanstackRscValueFromFlight;
+        }
+        return reviver;
+    };
+    const visit = async (current)=>{
+        if ((0, external_shared_js_namespaceObject.isSerializedTanstackRscFlightValue)(current)) return (await getReviver())(current);
+        if (!current || 'object' != typeof current) return current;
+        if (seen.has(current)) return seen.get(current);
+        if (current instanceof Map) {
+            const result = new Map();
+            seen.set(current, result);
+            for (const [key, item] of current)result.set(await visit(key), await visit(item));
+            return result;
+        }
+        if (current instanceof Set) {
+            const result = new Set();
+            seen.set(current, result);
+            for (const item of current)result.add(await visit(item));
+            return result;
+        }
+        if (Array.isArray(current)) {
+            const result = [];
+            seen.set(current, result);
+            for (const item of current)result.push(await visit(item));
+            return result;
+        }
+        if (!isPlainObject(current)) return current;
+        const result = {};
+        seen.set(current, result);
+        for (const [key, item] of Object.entries(current))result[key] = await visit(item);
+        return result;
+    };
+    return visit(value);
+}
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.reviveTanstackRscFlightValues = __webpack_exports__.reviveTanstackRscFlightValues;
+exports.serializeTanstackRscFlightValues = __webpack_exports__.serializeTanstackRscFlightValues;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isPlainObject",
+    "reviveTanstackRscFlightValues",
+    "serializeTanstackRscFlightValues"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});