@bleedingdev/modern-js-runtime 3.2.0-ultramodern.120 → 3.2.0-ultramodern.121

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

@@ -1,234 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { merge } from "@modern-js/runtime-utils/merge";
-import { createRequestContext } 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 { useContext } from "react";
-import { InternalRuntimeContext, getGlobalEnableRsc, getGlobalLayoutApp, getGlobalRoutes } from "../../../core/context/index.mjs";
-import { applyRouterServerPrepareResult, createRouterServerSnapshot } from "../lifecycle.mjs";
-import { createRouteObjectsFromConfig, urlJoin } from "../utils.mjs";
-import { createModernBasepathRewrite } from "./basepathRewrite.mjs";
-import { wrapTanstackSsrHydrationBoundary } from "./hydrationBoundary.mjs";
-import { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./routeTree.mjs";
-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)
-        ]);
-    }));
-}
-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 = {})=>({
-        name: '@modern-js/plugin-router-tanstack',
-        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 { 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 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(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?.();
-                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 = wrapTanstackSsrHydrationBoundary(/*#__PURE__*/ jsx(RouterProvider, {
-                            router: router
-                        }), true);
-                        return App ? /*#__PURE__*/ jsx(App, {
-                            children: routerWrapper
-                        }) : routerWrapper;
-                    };
-                return getRouteApp();
-            });
-        }
-    });
-export { tanstackRouterPlugin };

package/dist/esm/router/runtime/tanstack/prefetchLink.mjs

@@ -1,18 +0,0 @@
-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 'viewport';
-}
-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 };