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

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

@@ -0,0 +1,268 @@
+import { jsx } from "react/jsx-runtime";
+import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createRequestContext, storage } from "@modern-js/runtime-utils/node";
+import { time } from "@modern-js/runtime-utils/time";
+import { LOADER_REPORTER_NAME } from "@modern-js/utils/universal/constants";
+import { RouterProvider, createMemoryHistory, createRouter } from "@tanstack/react-router";
+import { attachRouterServerSsrUtils } from "@tanstack/react-router/ssr/server";
+import { Suspense, useContext } from "react";
+import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
+import { modifyRoutes, onAfterCreateRouter, onAfterHydrateRouter, onBeforeCreateRouter, onBeforeCreateRoutes, onBeforeHydrateRouter } from "./hooks.mjs";
+import { applyRouterServerPrepareResult, createRouterServerSnapshot } from "./lifecycle.mjs";
+import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
+import { createTanstackRscServerPayload, handleTanstackRscRedirect } from "./rsc/payloadRouter.mjs";
+import { createRouteObjectsFromConfig, urlJoin } from "./utils.mjs";
+const setTanstackRscServerPayload = (payload)=>{
+    const storageContext = 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: modifyRoutes,
+            onAfterCreateRouter: onAfterCreateRouter,
+            onAfterHydrateRouter: onAfterHydrateRouter,
+            onBeforeCreateRouter: onBeforeCreateRouter,
+            onBeforeCreateRoutes: onBeforeCreateRoutes,
+            onBeforeHydrateRouter: onBeforeHydrateRouter
+        },
+        setup: (api)=>{
+            api.onBeforeRender(async (context, interrupt)=>{
+                const pluginConfig = api.getRuntimeConfig();
+                const mergedConfig = merge(pluginConfig.router || {}, userConfig);
+                const serializationAdapters = getGlobalEnableRsc() ? (await import("./rsc/server.mjs")).getTanstackRscSerializationAdapters() : void 0;
+                const enableRsc = getGlobalEnableRsc();
+                const { basename = '', routesConfig, createRoutes } = mergedConfig;
+                const finalRouteConfig = {
+                    routes: getGlobalRoutes(),
+                    globalApp: getGlobalLayoutApp(),
+                    ...routesConfig
+                };
+                if (!finalRouteConfig.routes && !createRoutes) return;
+                const hooks = api.getHooks();
+                await hooks.onBeforeCreateRoutes.call(context);
+                const routeObjects = createRoutes ? createRoutes() : 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 ? urlJoin(baseUrl, basename || '') : baseUrl;
+                const initialHref = createGetSsrHref(request.raw);
+                const isRSCNavigation = enableRsc && 'true' === request.raw.headers.get('x-rsc-tree');
+                const requestContext = 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 = createRouteTreeFromRouteObjects(modifiedRouteObjects);
+                const history = createMemoryHistory({
+                    initialEntries: [
+                        initialHref
+                    ]
+                });
+                const rewrite = createModernBasepathRewrite(_basename);
+                const routerLifecycleContext = {
+                    framework: 'tanstack',
+                    phase: 'ssr-prepare',
+                    routes: modifiedRouteObjects,
+                    runtimeContext: context,
+                    basename: _basename
+                };
+                hooks.onBeforeCreateRouter.call(routerLifecycleContext);
+                const tanstackRouter = createRouter({
+                    routeTree,
+                    history,
+                    basepath: '/',
+                    rewrite,
+                    origin: new URL(request.raw.url).origin,
+                    ssr: {
+                        nonce
+                    },
+                    context: routerContext,
+                    ...serializationAdapters ? {
+                        serializationAdapters
+                    } : {}
+                });
+                const serverRouter = tanstackRouter;
+                attachRouterServerSsrUtils({
+                    router: serverRouter,
+                    manifest: void 0
+                });
+                const end = time();
+                try {
+                    await tanstackRouter.load({
+                        sync: true
+                    });
+                } finally{
+                    const cost = end();
+                    context.ssrContext?.onTiming?.(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 ? 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(createTanstackRscServerPayload(serverRouter, {
+                    omitClientLoaderData: true
+                }));
+                const ssrScriptTags = serverRouter.serverSsr?.takeBufferedScripts?.();
+                const hydrationScripts = routerManagedTagsToHtml(ssrScriptTags);
+                const matchedRouteIds = getModernRouteIdsFromMatches(serverRouter);
+                const routerServerSnapshot = createRouterServerSnapshot({
+                    framework: 'tanstack',
+                    basename: _basename,
+                    statusCode: tanstackRouter.state.statusCode,
+                    errors: routerErrors,
+                    matchedRouteIds,
+                    hydrationScripts
+                });
+                const runtimeContext = 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 = useContext(InternalRuntimeContext);
+                        const router = context.routerInstance ?? context.routerRuntime?.instance;
+                        if (!router) return App ? /*#__PURE__*/ jsx(App, {
+                            ...props
+                        }) : null;
+                        const routerWrapper = /*#__PURE__*/ jsx(Suspense, {
+                            fallback: null,
+                            children: /*#__PURE__*/ jsx(RouterProvider, {
+                                router: router
+                            })
+                        });
+                        return App ? /*#__PURE__*/ jsx(App, {
+                            children: routerWrapper
+                        }) : routerWrapper;
+                    };
+                return getRouteApp();
+            });
+        }
+    };
+    return plugin;
+};
+const plugin_node = tanstackRouterPlugin;
+export default plugin_node;
+export { tanstackRouterPlugin };

package/dist/esm/runtime/prefetchLink.mjs

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { Link } from "@tanstack/react-router";
+function resolvePreloadFromPrefetch(prefetch, preload) {
+    if (void 0 !== preload) return preload;
+    if ('none' === prefetch) return false;
+    if ('intent' === prefetch || 'render' === prefetch || 'viewport' === prefetch) return prefetch;
+    return preload;
+}
+const LinkComponentImpl = (props)=>{
+    const { prefetch, preload, ...rest } = props;
+    return /*#__PURE__*/ jsx(Link, {
+        ...rest,
+        preload: resolvePreloadFromPrefetch(prefetch, preload)
+    });
+};
+const prefetchLink_Link = LinkComponentImpl;
+const NavLink = LinkComponentImpl;
+export { NavLink, prefetchLink_Link as Link };