@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/esm-node/runtime/pluginShared.mjs

@@ -0,0 +1,41 @@
+import "node:module";
+import { getGlobalLayoutApp, getGlobalRoutes } from "@modern-js/runtime/context";
+import { merge } from "@modern-js/runtime-utils/merge";
+import { createTanstackRouteObjectsFromConfig } from "./utils.mjs";
+function getMergedRouterConfig(api, userConfig) {
+    const pluginConfig = api.getRuntimeConfig();
+    return merge(pluginConfig.router || {}, userConfig);
+}
+function getFinalRouteConfig(mergedConfig) {
+    return {
+        routes: getGlobalRoutes(),
+        globalApp: getGlobalLayoutApp(),
+        ...mergedConfig.routesConfig
+    };
+}
+function getTanstackRouteConfig(api, userConfig) {
+    const mergedConfig = getMergedRouterConfig(api, userConfig);
+    const finalRouteConfig = getFinalRouteConfig(mergedConfig);
+    return {
+        mergedConfig,
+        finalRouteConfig,
+        hasConfiguredRoutes: Boolean(finalRouteConfig.routes) || Boolean(mergedConfig.createRoutes)
+    };
+}
+function createTanstackRouteObjects({ hooks, routeConfig, ssrMode }) {
+    const { mergedConfig, finalRouteConfig } = routeConfig;
+    const routeObjects = mergedConfig.createRoutes ? mergedConfig.createRoutes() : createTanstackRouteObjectsFromConfig({
+        routesConfig: finalRouteConfig,
+        ssrMode
+    }) || [];
+    return hooks.modifyRoutes.call(routeObjects);
+}
+function joinBasename(baseUrl, basename) {
+    const base = baseUrl || '/';
+    const normalizedBase = base.startsWith('/') ? base : `/${base}`;
+    const trimmedBase = normalizedBase.length > 1 ? normalizedBase.replace(/\/+$/g, '') : normalizedBase;
+    const trimmedBasename = basename.replace(/^\/+|\/+$/g, '');
+    if (!trimmedBasename) return trimmedBase || '/';
+    return `${trimmedBase}/${trimmedBasename}`.replace(/\/{2,}/g, '/');
+}
+export { createTanstackRouteObjects, getFinalRouteConfig, getMergedRouterConfig, getTanstackRouteConfig, joinBasename };

package/dist/esm-node/runtime/prefetchLink.mjs

@@ -1,6 +1,6 @@
 import "node:module";
 import { jsx } from "react/jsx-runtime";
-import { Link } from "@tanstack/react-router";
+import { useLinkProps } from "@tanstack/react-router";
 function resolvePreloadFromPrefetch(prefetch, preload) {
     if (void 0 !== preload) return preload;
     if ('none' === prefetch) return false;
@@ -8,12 +8,25 @@ function resolvePreloadFromPrefetch(prefetch, preload) {
     return 'viewport';
 }
 const LinkComponentImpl = (props)=>{
-    const { prefetch, preload, ...rest } = props;
-    return /*#__PURE__*/ jsx(Link, {
+    const { prefetch, preload, 'aria-current': ariaCurrentProp, ref, children, ...rest } = props;
+    const hasAriaCurrentOverride = 'aria-current' in props;
+    const linkOptions = {
         ...rest,
         preload: resolvePreloadFromPrefetch(prefetch, preload)
+    };
+    const linkProps = useLinkProps(linkOptions, ref);
+    const { disabled: _disabled, type: _type, ...anchorProps } = linkProps;
+    if (hasAriaCurrentOverride) if (false === ariaCurrentProp || void 0 === ariaCurrentProp) delete anchorProps['aria-current'];
+    else anchorProps['aria-current'] = ariaCurrentProp;
+    const resolvedChildren = 'function' == typeof children ? children({
+        isActive: 'active' === anchorProps['data-status'],
+        isTransitioning: 'transitioning' === anchorProps['data-transitioning']
+    }) : children;
+    return /*#__PURE__*/ jsx("a", {
+        ...anchorProps,
+        children: resolvedChildren
     });
 };
-const prefetchLink_Link = LinkComponentImpl;
+const Link = LinkComponentImpl;
 const NavLink = LinkComponentImpl;
-export { NavLink, prefetchLink_Link as Link };
+export { Link, NavLink };

package/dist/esm-node/runtime/routeTree/components.mjs

@@ -0,0 +1,56 @@
+import "node:module";
+import { createElement } from "react";
+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 createElement(resolvedComponent, props);
+        pendingLoad ||= load();
+        throw pendingLoad;
+    };
+    Component.load = load;
+    Component.preload = load;
+    return Component;
+}
+function toRouteComponent(routeObject, options = {}) {
+    const route = routeObject;
+    const lazyImport = 'function' == typeof route.lazyImport ? route.lazyImport : void 0;
+    const routeComponent = route.Component || route.component;
+    const fallbackComponent = routeComponent ? routeComponent : route.element ? ()=>route.element : void 0;
+    if (lazyImport && fallbackComponent) return createServerLazyImportComponent(lazyImport, fallbackComponent);
+    if (routeComponent) return routeComponent;
+    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;
+}
+export { pickRouteModuleComponent, toErrorComponent, toPendingComponent, toRouteComponent };

package/dist/esm-node/runtime/routeTree/construction.mjs

@@ -0,0 +1,112 @@
+import "node:module";
+import { DefaultNotFound } from "@modern-js/runtime/context";
+import { rootRouteId } from "@tanstack/react-router";
+import { withModernRouteMatchContext } from "../outlet.mjs";
+import { toErrorComponent, toPendingComponent, toRouteComponent } from "./components.mjs";
+import { createModernShouldReload, wrapRouteObjectLoader } from "./loaders.mjs";
+import { isRouteObjectPathlessLayout, toTanstackPath } from "./paths.mjs";
+import { createRouteStaticData, mergeModernRouteHandle } from "./staticData.mjs";
+import { createTanstackRootRoute, createTanstackRoute, wrapRouteComponentWithModernContext } from "./tanstackRoutes.mjs";
+function createRouteFromRouteObject(opts) {
+    const { options = {}, parent, pathlessFallbackId = 'pathless', routeObject } = opts;
+    const modernRouteObject = routeObject;
+    const revalidationState = {};
+    const shouldRevalidate = modernRouteObject.shouldRevalidate;
+    const shouldReload = createModernShouldReload(shouldRevalidate, revalidationState);
+    const stableFallbackId = routeObject.id || modernRouteObject.file || pathlessFallbackId;
+    const component = toRouteComponent(routeObject, options);
+    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, index)=>createRouteFromRouteObject({
+                options,
+                parent: route,
+                pathlessFallbackId: `pathless-${index}`,
+                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: 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 = withModernRouteMatchContext(rootComponent, rootRouteId);
+    const topLevel = rootLikeRoute ? [
+        ...rootLikeRoute.children || [],
+        ...routes.filter((route)=>route !== rootLikeRoute)
+    ] : routes;
+    const childRoutes = topLevel.map((routeObject, index)=>createRouteFromRouteObject({
+            options,
+            parent: rootRoute,
+            pathlessFallbackId: `pathless-${index}`,
+            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));
+}
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches };

package/dist/esm-node/runtime/routeTree/index.mjs

@@ -0,0 +1,3 @@
+import "node:module";
+export { pickRouteModuleComponent } from "./components.mjs";
+export { createRouteTreeFromRouteObjects, getModernRouteIdsFromMatches } from "./construction.mjs";

package/dist/esm-node/runtime/routeTree/loaders.mjs

@@ -0,0 +1,118 @@
+import "node:module";
+import { notFound } from "@tanstack/react-router";
+import { isRedirectResponse, isResponse, isTanstackRedirect, throwTanstackRedirect } from "../loaderBridge.mjs";
+import { isTanstackRscPayloadNavigationEnabled, loadTanstackRscRouteData } from "../rsc/payloadRouter.mjs";
+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 (isResponse(result)) {
+        if (isRedirectResponse(result)) {
+            const location = result.headers.get('Location') || '/';
+            throwTanstackRedirect(location);
+        }
+        if (404 === result.status) throw notFound();
+    }
+    return normalizeModernLoaderResult(result);
+}
+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 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 && isTanstackRscPayloadNavigationEnabled()) return loadTanstackRscRouteData({
+                hasClientLoader: modernRoute.hasClientLoader || void 0 !== modernRoute.clientData,
+                loadClientData: loadModernData,
+                request,
+                routeId: ctx.route?.id
+            });
+            return loadModernData();
+        } catch (err) {
+            if (isResponse(err)) {
+                if (isTanstackRedirect(err)) throw err;
+                if (isRedirectResponse(err)) {
+                    const location = err.headers.get('Location') || '/';
+                    throwTanstackRedirect(location);
+                }
+                if (404 === err.status) throw notFound();
+            }
+            throw err;
+        }
+    };
+}
+export { createModernShouldReload, wrapRouteObjectLoader };

package/dist/esm-node/runtime/routeTree/paths.mjs

@@ -0,0 +1,17 @@
+import "node:module";
+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 isRouteObjectPathlessLayout(route) {
+    return !route.path && !route.index;
+}
+export { isRouteObjectPathlessLayout, toTanstackPath };

package/dist/esm-node/runtime/routeTree/staticData.mjs

@@ -0,0 +1,23 @@
+import "node:module";
+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;
+}
+export { createRouteStaticData, mergeModernRouteHandle };

package/dist/esm-node/runtime/routeTree/tanstackRoutes.mjs

@@ -0,0 +1,14 @@
+import "node:module";
+import { createRootRoute, createRoute } from "@tanstack/react-router";
+import { withModernRouteMatchContext } from "../outlet.mjs";
+function createTanstackRoute(options) {
+    return createRoute(options);
+}
+function createTanstackRootRoute(options) {
+    return createRootRoute(options);
+}
+function wrapRouteComponentWithModernContext(route, component, routeId) {
+    const routeMatchId = routeId || route.id;
+    if (component && routeMatchId) route.options.component = withModernRouteMatchContext(component, routeMatchId);
+}
+export { createTanstackRootRoute, createTanstackRoute, wrapRouteComponentWithModernContext };

package/dist/esm-node/runtime/routeTree/types.mjs

@@ -0,0 +1 @@
+import "node:module";