@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.11 → 3.2.0-ultramodern.111

package/dist/esm/cli/index.mjs

@@ -1,5 +1,6 @@
 import node_path from "node:path";
 import { NESTED_ROUTE_SPEC_FILE, filterRoutesForServer, fs } from "@modern-js/utils";
+import { createTanstackRsbuildRouteSplittingProfile, isTanstackStartRouteModuleSource, resolveTanstackRouteCodeSplittingEnabled } from "./routeSplitting.mjs";
 import { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled } from "./tanstackTypes.mjs";
 import { __webpack_require__ } from "../rslib-runtime.mjs";
 import * as __rspack_external__modern_js_runtime_cli_401ee077 from "@modern-js/runtime/cli";
@@ -78,6 +79,7 @@ async function writeTanstackRouterTypesForEntries(opts) {
 function tanstackRouterPlugin(options = {}) {
     const routesDir = options.routesDir || DEFAULT_ROUTES_DIR;
     const generatedDirName = options.generatedDirName || DEFAULT_GENERATED_DIR_NAME;
+    const routeSplittingProfile = createTanstackRsbuildRouteSplittingProfile(options);
     return {
         name: '@modern-js/plugin-tanstack',
         required: [
@@ -113,6 +115,7 @@ function tanstackRouterPlugin(options = {}) {
                     entry: entry || getRuntimeRouterCli().isRouteEntry(entryPath, routesDir)
                 }));
             api.config(()=>({
+                    ...routeSplittingProfile.defaultConfig,
                     source: {
                         include: [
                             /[\\/]node_modules[\\/]@tanstack[\\/]react-router[\\/]/,
@@ -195,4 +198,4 @@ function tanstackRouterPlugin(options = {}) {
 }
 const src_cli = tanstackRouterPlugin;
 export default src_cli;
-export { generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };
+export { createTanstackRsbuildRouteSplittingProfile, generateTanstackRouterTypesSourceForEntry, isTanstackRouterFrameworkEnabled, isTanstackStartRouteModuleSource, resolveTanstackRouteCodeSplittingEnabled, tanstackRouterPlugin, writeTanstackRegisterFile, writeTanstackRouterTypesForEntries };

package/dist/esm/cli/routeSplitting.mjs

@@ -0,0 +1,43 @@
+const TANSTACK_START_ROUTE_FACTORY_CALLS = [
+    'createFileRoute',
+    'createRootRoute',
+    'createRootRouteWithContext'
+];
+const TANSTACK_START_ROUTE_FACTORY_REGEX = /\b(createFileRoute|createRootRoute|createRootRouteWithContext)\s*(?:<|\()/;
+function isTanstackStartRouteModuleSource(source) {
+    return TANSTACK_START_ROUTE_FACTORY_REGEX.test(source);
+}
+function resolveTanstackRouteCodeSplittingEnabled(option) {
+    if ('boolean' == typeof option) return option;
+    return option?.enabled ?? true;
+}
+function createTanstackRsbuildRouteSplittingProfile(opts) {
+    return {
+        defaultConfig: {
+            output: {
+                splitRouteChunks: resolveTanstackRouteCodeSplittingEnabled(opts.routeCodeSplitting)
+            }
+        },
+        modernRouteChunks: {
+            enabled: resolveTanstackRouteCodeSplittingEnabled(opts.routeCodeSplitting),
+            owner: 'modern'
+        },
+        builderChunkSplit: {
+            owner: 'modern-rsbuild',
+            preserved: true
+        },
+        tanstackStartRspackSplitter: {
+            compatible: false,
+            reason: 'TanStack Start Rsbuild route splitting is tied to TanStack file-route factory modules; Modern generates TanStack route trees from Modern route metadata and owns route chunking through output.splitRouteChunks.',
+            clientDeleteNodes: [
+                'ssr',
+                'server',
+                'headers'
+            ],
+            routeFactoryCalls: [
+                ...TANSTACK_START_ROUTE_FACTORY_CALLS
+            ]
+        }
+    };
+}
+export { createTanstackRsbuildRouteSplittingProfile, isTanstackStartRouteModuleSource, resolveTanstackRouteCodeSplittingEnabled };

package/dist/esm/cli/tanstackTypes.mjs

@@ -55,6 +55,14 @@ function pickModernLoaderModule(route) {
         inline
     };
 }
+function pickRouteSearchContractModules(route) {
+    const validateSearchPath = route.validateSearch;
+    const loaderDepsPath = route.loaderDeps;
+    return {
+        validateSearchPath: 'string' == typeof validateSearchPath ? validateSearchPath : null,
+        loaderDepsPath: 'string' == typeof loaderDepsPath ? loaderDepsPath : null
+    };
+}
 function isPathlessLayout(route) {
     return 'nested' === route.type && 'boolean' != typeof route.index && void 0 === route.path;
 }
@@ -88,8 +96,21 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
     const imports = [];
     const statements = [];
     const loaderImportMap = new Map();
+    const searchContractImportMap = new Map();
+    const usedRouteVarNames = new Set();
     let loaderIndex = 0;
+    let validateSearchIndex = 0;
+    let loaderDepsIndex = 0;
     let routeIndex = 0;
+    const resolveRouteModuleNoExt = async (aliasedNoExtPath)=>{
+        const prefix = `${appContext.internalSrcAlias}/`;
+        let absNoExt;
+        if (aliasedNoExtPath.startsWith(prefix)) {
+            const rel = aliasedNoExtPath.slice(prefix.length);
+            absNoExt = path.join(appContext.srcDirectory, rel);
+        } else absNoExt = path.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : path.join(appContext.srcDirectory, aliasedNoExtPath);
+        return resolveFileNoExt(absNoExt);
+    };
     const getImportNamesForLoader = async (aliasedNoExtPath, inline, hasAction)=>{
         const key = `${inline ? 'inline' : 'default'}:${hasAction ? 'action' : 'loader'}:${aliasedNoExtPath}`;
         const existing = loaderImportMap.get(key);
@@ -97,13 +118,7 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             loaderName: existing,
             actionName: hasAction ? existing.replace(/^loader_/, 'action_') : null
         };
-        const prefix = `${appContext.internalSrcAlias}/`;
-        let absNoExt;
-        if (aliasedNoExtPath.startsWith(prefix)) {
-            const rel = aliasedNoExtPath.slice(prefix.length);
-            absNoExt = path.join(appContext.srcDirectory, rel);
-        } else absNoExt = path.isAbsolute(aliasedNoExtPath) ? aliasedNoExtPath : path.join(appContext.srcDirectory, aliasedNoExtPath);
-        const resolvedNoExt = await resolveFileNoExt(absNoExt);
+        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
         if (!resolvedNoExt) return null;
         const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
         const importName = `loader_${loaderIndex++}`;
@@ -121,10 +136,29 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             actionName
         };
     };
+    const getImportNameForSearchContract = async (aliasedNoExtPath, exportName)=>{
+        const key = `${exportName}:${aliasedNoExtPath}`;
+        const existing = searchContractImportMap.get(key);
+        if (existing) return existing;
+        const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
+        if (!resolvedNoExt) return null;
+        const relImport = normalizeRelativeImport(path.relative(outDir, resolvedNoExt));
+        const importName = 'validateSearch' === exportName ? `validateSearch_${validateSearchIndex++}` : `loaderDeps_${loaderDepsIndex++}`;
+        imports.push(`import { ${exportName} as ${importName} } from ${quote(relImport)};`);
+        searchContractImportMap.set(key, importName);
+        return importName;
+    };
+    const reserveRouteVarName = (preferred)=>{
+        let candidate = preferred;
+        let suffix = 1;
+        while(usedRouteVarNames.has(candidate))candidate = `${preferred}_${suffix++}`;
+        usedRouteVarNames.add(candidate);
+        return candidate;
+    };
     const createRouteVarName = (route)=>{
         const id = route.id;
         const base = id ? makeLegalIdentifier(id) : `r_${routeIndex++}`;
-        return `route_${base}`;
+        return reserveRouteVarName(`route_${base}`);
     };
     const buildRoute = async (opts)=>{
         const { parentVar, route } = opts;
@@ -134,6 +168,9 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
         const loaderImports = loaderInfo ? await getImportNamesForLoader(loaderInfo.loaderPath, loaderInfo.inline, Boolean(loaderInfo.inline && routeAction === loaderInfo.loaderPath)) : null;
         const loaderName = loaderImports?.loaderName || null;
         const actionName = loaderImports?.actionName || null;
+        const searchContractInfo = pickRouteSearchContractModules(route);
+        const validateSearchName = searchContractInfo.validateSearchPath ? await getImportNameForSearchContract(searchContractInfo.validateSearchPath, 'validateSearch') : null;
+        const loaderDepsName = searchContractInfo.loaderDepsPath ? await getImportNameForSearchContract(searchContractInfo.loaderDepsPath, 'loaderDeps') : null;
         const rawPath = route.path;
         const hasSplat = 'string' == typeof rawPath && rawPath.includes('*');
         const routeOpts = [
@@ -147,20 +184,24 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
             routeOpts.push(`path: ${quote(p)},`);
         }
         if (loaderName) routeOpts.push(`loader: modernLoaderToTanstack({ hasSplat: ${hasSplat} }, ${loaderName}),`);
+        if (validateSearchName) routeOpts.push(`validateSearch: ${validateSearchName},`);
+        if (loaderDepsName) routeOpts.push(`loaderDeps: ${loaderDepsName},`);
         const staticDataSnippet = createRouteStaticDataSnippet({
             modernRouteId: route.id,
             loaderName,
             actionName
         });
         if (staticDataSnippet) routeOpts.push(staticDataSnippet);
-        statements.push(`const ${varName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
         const children = route.children;
+        const hasChildren = Boolean(children && children.length > 0);
+        const routeCtorVarName = hasChildren ? reserveRouteVarName(`${varName}__base`) : varName;
+        statements.push(`const ${routeCtorVarName} = createRoute({\n  ${routeOpts.join('\n  ')}\n});`);
         if (children && children.length > 0) {
             const childVars = await Promise.all(children.map((child)=>buildRoute({
-                    parentVar: varName,
+                    parentVar: routeCtorVarName,
                     route: child
                 })));
-            statements.push(`${varName}.addChildren([${childVars.join(', ')}]);`);
+            statements.push(`const ${varName} = ${routeCtorVarName}.addChildren([${childVars.join(', ')}]);`);
         }
         return varName;
     };
@@ -169,17 +210,23 @@ async function generateTanstackRouterTypesSourceForEntry(opts) {
     const rootLoaderImports = rootLoaderInfo?.loaderPath ? await getImportNamesForLoader(rootLoaderInfo.loaderPath, rootLoaderInfo.inline, Boolean(rootLoaderInfo.inline && rootAction === rootLoaderInfo.loaderPath)) : null;
     const rootLoaderName = rootLoaderImports?.loaderName || null;
     const rootActionName = rootLoaderImports?.actionName || null;
+    const rootSearchContractInfo = rootModern ? pickRouteSearchContractModules(rootModern) : null;
+    const rootValidateSearchName = rootSearchContractInfo?.validateSearchPath ? await getImportNameForSearchContract(rootSearchContractInfo.validateSearchPath, 'validateSearch') : null;
+    const rootLoaderDepsName = rootSearchContractInfo?.loaderDepsPath ? await getImportNameForSearchContract(rootSearchContractInfo.loaderDepsPath, 'loaderDeps') : null;
     const topLevelVars = await Promise.all(topLevel.map((route)=>buildRoute({
             parentVar: 'rootRoute',
             route
         })));
     const rootOpts = [];
     if (rootLoaderName) rootOpts.push(`loader: modernLoaderToTanstack({ hasSplat: false }, ${rootLoaderName}),`);
+    if (rootValidateSearchName) rootOpts.push(`validateSearch: ${rootValidateSearchName},`);
+    if (rootLoaderDepsName) rootOpts.push(`loaderDeps: ${rootLoaderDepsName},`);
     const routerGenTs = `/* eslint-disable */
 // This file is auto-generated by Modern.js. Do not edit manually.
 
 import {
   createMemoryHistory,
+  modernTanstackRouterFastDefaults,
   createRootRouteWithContext,
   createRoute,
   createRouter,
@@ -207,7 +254,7 @@ function isRedirectResponse(res: Response) {
 }
 
 function throwTanstackRedirect(location: string) {
-  const target = location || '/';
+  const target = location.length > 0 ? location : '/';
   try {
     void new URL(target);
     throw redirect({ href: target });
@@ -233,21 +280,87 @@ function createRouteStaticData(opts: {
   modernRouteAction?: unknown;
   modernRouteLoader?: unknown;
 }) {
-  const staticData: Record<string, unknown> = {};
+  const staticData: {
+    modernRouteId?: string;
+    modernRouteAction?: unknown;
+    modernRouteLoader?: unknown;
+  } = {};
 
-  if (opts.modernRouteId) {
+  if (typeof opts.modernRouteId === 'string' && opts.modernRouteId.length > 0) {
     staticData.modernRouteId = opts.modernRouteId;
   }
 
-  if (opts.modernRouteLoader) {
+  if (typeof opts.modernRouteLoader !== 'undefined') {
     staticData.modernRouteLoader = opts.modernRouteLoader;
   }
 
-  if (opts.modernRouteAction) {
+  if (typeof opts.modernRouteAction !== 'undefined') {
     staticData.modernRouteAction = opts.modernRouteAction;
   }
 
-  return Object.keys(staticData).length > 0 ? staticData : undefined;
+  return staticData;
+}
+
+function getLoaderSignal(ctx: any): AbortSignal {
+  const abortSignal = ctx?.abortController?.signal;
+  if (abortSignal instanceof AbortSignal) {
+    return abortSignal;
+  }
+  if (ctx?.signal instanceof AbortSignal) {
+    return ctx.signal;
+  }
+  return new AbortController().signal;
+}
+
+function getLoaderHref(ctx: any): string {
+  if (typeof ctx?.location === 'string') {
+    return ctx.location;
+  }
+
+  const publicHref = ctx?.location?.publicHref;
+  if (typeof publicHref === 'string') {
+    return publicHref;
+  }
+
+  const href = ctx?.location?.href;
+  if (typeof href === 'string') {
+    return href;
+  }
+
+  const urlHref = ctx?.location?.url?.href;
+  return typeof urlHref === 'string' ? urlHref : '';
+}
+
+function getLoaderParams(ctx: any): Record<string, string> {
+  return typeof ctx?.params === 'object' && ctx.params !== null ? ctx.params : {};
+}
+
+function handleModernLoaderResult<LoaderResult>(result: LoaderResult): LoaderResult {
+  if (isResponse(result)) {
+    if (isRedirectResponse(result)) {
+      const location = result.headers.get('Location') ?? '/';
+      throwTanstackRedirect(location);
+    }
+    if (result.status === 404) {
+      throw notFound();
+    }
+  }
+
+  return result;
+}
+
+function handleModernLoaderError(err: unknown): never {
+  if (isResponse(err)) {
+    if (isRedirectResponse(err)) {
+      const location = err.headers.get('Location') ?? '/';
+      throwTanstackRedirect(location);
+    }
+    if (err.status === 404) {
+      throw notFound();
+    }
+  }
+
+  throw err;
 }
 
 function modernLoaderToTanstack<TLoader extends (args: any) => any>(
@@ -256,57 +369,31 @@ function modernLoaderToTanstack<TLoader extends (args: any) => any>(
 ) {
   type LoaderResult = Awaited<ReturnType<TLoader>>;
 
-  return async (ctx: any): Promise<LoaderResult> => {
+  return (ctx: any): Promise<LoaderResult> => {
     try {
-      const signal: AbortSignal =
-        ctx?.abortController?.signal ||
-        ctx?.signal ||
-        new AbortController().signal;
+      const signal = getLoaderSignal(ctx);
       const baseRequest: Request | undefined =
         ctx?.context?.request instanceof Request ? ctx.context.request : undefined;
 
-      const href =
-        typeof ctx?.location === 'string'
-          ? ctx.location
-          : ctx?.location?.publicHref ||
-            ctx?.location?.href ||
-            ctx?.location?.url?.href ||
-            '';
+      const href = getLoaderHref(ctx);
 
-      const request = baseRequest
+      const request = baseRequest !== undefined
         ? new Request(baseRequest, { signal })
         : new Request(href, { signal });
 
-      const params = mapParamsForModernLoader(ctx?.params || {}, opts.hasSplat);
+      const params = mapParamsForModernLoader(getLoaderParams(ctx), opts.hasSplat);
 
-      const result = await (modernLoader as any)({
-        request,
-        params,
-        context: ctx?.context?.requestContext,
-      });
-
-      if (isResponse(result)) {
-        if (isRedirectResponse(result)) {
-          const location = result.headers.get('Location') || '/';
-          throwTanstackRedirect(location);
-        }
-        if (result.status === 404) {
-          throw notFound();
-        }
-      }
-
-      return result as LoaderResult;
+      return Promise.resolve(
+        (modernLoader as any)({
+          request,
+          params,
+          context: ctx?.context?.requestContext,
+        }),
+      )
+        .then((result: LoaderResult) => handleModernLoaderResult(result))
+        .catch(handleModernLoaderError);
     } catch (err) {
-      if (isResponse(err)) {
-        if (isRedirectResponse(err)) {
-          const location = err.headers.get('Location') || '/';
-          throwTanstackRedirect(location);
-        }
-        if (err.status === 404) {
-          throw notFound();
-        }
-      }
-      throw err;
+      handleModernLoaderError(err);
     }
   };
 }
@@ -327,6 +414,7 @@ ${statements.join('\n\n')}
 export const routeTree = rootRoute.addChildren([${topLevelVars.join(', ')}]);
 
 export const router = createRouter({
+  ...modernTanstackRouterFastDefaults,
   routeTree,
   history: createMemoryHistory({
     initialEntries: ['/'],

package/dist/esm/runtime/hydrationBoundary.mjs

@@ -0,0 +1,10 @@
+import { jsx } from "react/jsx-runtime";
+import { Suspense } from "react";
+function wrapTanstackSsrHydrationBoundary(routerContent, shouldWrap) {
+    if (shouldWrap) return /*#__PURE__*/ jsx(Suspense, {
+        fallback: null,
+        children: routerContent
+    });
+    return routerContent;
+}
+export { wrapTanstackSsrHydrationBoundary };

package/dist/esm/runtime/index.mjs

@@ -1,6 +1,7 @@
-export * from "@tanstack/react-router";
-export { useMatch } from "@tanstack/react-router";
+export { Asset, Await, Block, CatchBoundary, CatchNotFound, ClientOnly, DEFAULT_PROTOCOL_ALLOWLIST, DefaultGlobalNotFound, ErrorComponent, FileRoute, FileRouteLoader, HeadContent, LazyRoute, Match, MatchRoute, Matches, Navigate, NotFoundRoute, RootRoute, Route, RouteApi, Router, RouterContextProvider, RouterProvider, ScriptOnce, Scripts, ScrollRestoration, SearchParamError, cleanPath, composeRewrites, createBrowserHistory, createControlledPromise, createFileRoute, createHashHistory, createHistory, createLazyFileRoute, createLazyRoute, createLink, createMemoryHistory, createRootRoute, createRootRouteWithContext, createRoute, createRouteMask, createRouter, createRouterConfig, createSerializationAdapter, deepEqual, defaultParseSearch, defaultStringifySearch, defer, functionalUpdate, getRouteApi, interpolatePath, isMatch, isNotFound, isPlainArray, isPlainObject, isRedirect, joinPaths, lazyFn, lazyRouteComponent, linkOptions, notFound, parseSearchWith, reactUse, redirect, replaceEqualDeep, resolvePath, retainSearchParams, rootRouteId, rootRouteWithContext, stringifySearchWith, stripSearchParams, trimPath, trimPathLeft, trimPathRight, useAwaited, useBlocker, useCanGoBack, useChildMatches, useElementScrollRestoration, useHydrated, useLayoutEffect, useLinkProps, useLoaderData, useLoaderDeps, useLocation, useMatch, useMatchRoute, useMatches, useNavigate, useParams, useParentMatches, useRouteContext, useRouter, useRouterState, useSearch, useTags } from "@tanstack/react-router";
 export { Form, RouteActionResponseError, useFetcher } from "./dataMutation.mjs";
+export { Outlet } from "./outlet.mjs";
 export { tanstackRouterPlugin as default, tanstackRouterPlugin } from "./plugin.mjs";
 export { Link, NavLink } from "./prefetchLink.mjs";
 export { CompositeComponent } from "./rsc/client.mjs";
+export { getModernTanstackRouterFastDefaults, modernTanstackRouterFastDefaults } from "./types.mjs";

package/dist/esm/runtime/outlet.mjs

@@ -0,0 +1,17 @@
+import { jsx } from "react/jsx-runtime";
+import { Outlet } from "@tanstack/react-router";
+import { createElement, memo } from "react";
+const outlet_Outlet = /*#__PURE__*/ memo(function() {
+    return /*#__PURE__*/ jsx(Outlet, {});
+});
+function withModernRouteMatchContext(component, _routeId) {
+    if (null == component) return component;
+    const Component = component;
+    const WrappedRouteComponent = (props)=>/*#__PURE__*/ createElement(Component, props);
+    const preloadable = component;
+    if ('function' == typeof preloadable.load) WrappedRouteComponent.load = preloadable.load.bind(preloadable);
+    if ('function' == typeof preloadable.preload) WrappedRouteComponent.preload = preloadable.preload.bind(preloadable);
+    else if ('function' == typeof preloadable.load) WrappedRouteComponent.preload = WrappedRouteComponent.load;
+    return WrappedRouteComponent;
+}
+export { outlet_Outlet as Outlet, withModernRouteMatchContext };