@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.89 → 3.2.0-ultramodern.90

package/src/cli/tanstackTypes.ts

@@ -86,6 +86,17 @@ function pickModernLoaderModule(route: NestedRouteForCli | PageRoute) {
   return { loaderPath, inline };
 }
 
+function pickRouteSearchContractModules(route: NestedRouteForCli | PageRoute) {
+  const validateSearchPath = (route as any).validateSearch;
+  const loaderDepsPath = (route as any).loaderDeps;
+
+  return {
+    validateSearchPath:
+      typeof validateSearchPath === 'string' ? validateSearchPath : null,
+    loaderDepsPath: typeof loaderDepsPath === 'string' ? loaderDepsPath : null,
+  };
+}
+
 function isPathlessLayout(route: NestedRouteForCli | PageRoute) {
   return (
     (route as any).type === 'nested' &&
@@ -182,10 +193,29 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
   const statements: string[] = [];
 
   const loaderImportMap = new Map<string, string>();
+  const searchContractImportMap = new Map<string, string>();
   const usedRouteVarNames = new Set<string>();
   let loaderIndex = 0;
+  let validateSearchIndex = 0;
+  let loaderDepsIndex = 0;
   let routeIndex = 0;
 
+  const resolveRouteModuleNoExt = async (aliasedNoExtPath: string) => {
+    const prefix = `${appContext.internalSrcAlias}/`;
+    let absNoExt: string;
+    if (aliasedNoExtPath.startsWith(prefix)) {
+      const rel = aliasedNoExtPath.slice(prefix.length);
+      absNoExt = path.join(appContext.srcDirectory, rel);
+    } else if (path.isAbsolute(aliasedNoExtPath)) {
+      absNoExt = aliasedNoExtPath;
+    } else {
+      // Unknown format; treat as already relative to src.
+      absNoExt = path.join(appContext.srcDirectory, aliasedNoExtPath);
+    }
+
+    return resolveFileNoExt(absNoExt);
+  };
+
   const getImportNamesForLoader = async (
     aliasedNoExtPath: string,
     inline: boolean,
@@ -202,19 +232,7 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
       };
     }
 
-    const prefix = `${appContext.internalSrcAlias}/`;
-    let absNoExt: string;
-    if (aliasedNoExtPath.startsWith(prefix)) {
-      const rel = aliasedNoExtPath.slice(prefix.length);
-      absNoExt = path.join(appContext.srcDirectory, rel);
-    } else if (path.isAbsolute(aliasedNoExtPath)) {
-      absNoExt = aliasedNoExtPath;
-    } else {
-      // Unknown format; treat as already relative to src.
-      absNoExt = path.join(appContext.srcDirectory, aliasedNoExtPath);
-    }
-
-    const resolvedNoExt = await resolveFileNoExt(absNoExt);
+    const resolvedNoExt = await resolveRouteModuleNoExt(aliasedNoExtPath);
     if (!resolvedNoExt) {
       return null;
     }
@@ -243,6 +261,35 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
     return { loaderName: importName, actionName };
   };
 
+  const getImportNameForSearchContract = async (
+    aliasedNoExtPath: string,
+    exportName: 'validateSearch' | 'loaderDeps',
+  ) => {
+    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 =
+      exportName === 'validateSearch'
+        ? `validateSearch_${validateSearchIndex++}`
+        : `loaderDeps_${loaderDepsIndex++}`;
+    imports.push(
+      `import { ${exportName} as ${importName} } from ${quote(relImport)};`,
+    );
+    searchContractImportMap.set(key, importName);
+    return importName;
+  };
+
   const reserveRouteVarName = (preferred: string) => {
     let candidate = preferred;
     let suffix = 1;
@@ -278,6 +325,19 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
       : 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 as any).path as string | undefined;
     const hasSplat = typeof rawPath === 'string' && rawPath.includes('*');
@@ -297,6 +357,12 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
         `loader: modernLoaderToTanstack({ hasSplat: ${hasSplat} }, ${loaderName}),`,
       );
     }
+    if (validateSearchName) {
+      routeOpts.push(`validateSearch: ${validateSearchName},`);
+    }
+    if (loaderDepsName) {
+      routeOpts.push(`loaderDeps: ${loaderDepsName},`);
+    }
 
     const staticDataSnippet = createRouteStaticDataSnippet({
       modernRouteId: (route as any).id as string | undefined,
@@ -346,6 +412,21 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
     : 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 })),
@@ -357,12 +438,19 @@ export async function generateTanstackRouterTypesSourceForEntry(opts: {
       `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,
@@ -552,6 +640,7 @@ ${statements.join('\n\n')}
 export const routeTree = rootRoute.addChildren([${topLevelVars.join(', ')}]);
 
 export const router = createRouter({
+  ...modernTanstackRouterFastDefaults,
   routeTree,
   history: createMemoryHistory({
     initialEntries: ['/'],

package/src/runtime/index.tsx

@@ -35,3 +35,8 @@ export type {
   CompositeComponentProps,
 } from './rsc/client';
 export { CompositeComponent } from './rsc/client';
+export type { RouterConfig } from './types';
+export {
+  getModernTanstackRouterFastDefaults,
+  modernTanstackRouterFastDefaults,
+} from './types';

package/src/runtime/plugin.node.tsx

@@ -52,7 +52,11 @@ import {
   createTanstackRscServerPayload,
   handleTanstackRscRedirect,
 } from './rsc/payloadRouter';
-import type { InternalRouterServerSnapshot, RouterConfig } from './types';
+import {
+  getModernTanstackRouterFastDefaults,
+  type InternalRouterServerSnapshot,
+  type RouterConfig,
+} from './types';
 import { createRouteObjectsFromConfig, urlJoin } from './utils';
 
 type ModernTanstackRouterContext = {
@@ -439,6 +443,7 @@ export const tanstackRouterPlugin = (
         hooks.onBeforeCreateRouter.call(routerLifecycleContext);
 
         const tanstackRouter = createRouter({
+          ...getModernTanstackRouterFastDefaults(mergedConfig),
           routeTree,
           history,
           basepath: '/',

package/src/runtime/plugin.tsx

@@ -43,7 +43,10 @@ import {
 import { Link } from './prefetchLink';
 import { createRouteTreeFromRouteObjects } from './routeTree';
 import { getTanstackRscSerializationAdapters } from './rsc/client';
-import type { RouterConfig } from './types';
+import {
+  getModernTanstackRouterFastDefaults,
+  type RouterConfig,
+} from './types';
 import { createRouteObjectsFromConfig, urlJoin } from './utils';
 
 const BLOCKING_SUBSCRIBE_SYMBOL = Symbol.for(
@@ -322,6 +325,7 @@ export const tanstackRouterPlugin = (
               : undefined;
 
             cachedRouter = createRouter({
+              ...getModernTanstackRouterFastDefaults(mergedConfig),
               routeTree,
               basepath: '/',
               rewrite,

package/src/runtime/routeTree.ts

@@ -76,8 +76,10 @@ type ModernRouteObject = RouteObject & {
   isClientComponent?: boolean;
   lazyImport?: () => unknown;
   loader?: ModernLoader;
+  loaderDeps?: unknown;
   pendingComponent?: unknown;
   shouldRevalidate?: ModernShouldRevalidate;
+  validateSearch?: unknown;
 };
 
 type ModernGeneratedRoute = (NestedRoute | PageRoute) & {
@@ -102,10 +104,12 @@ type ModernGeneratedRoute = (NestedRoute | PageRoute) & {
   isRoot?: boolean;
   lazyImport?: () => unknown;
   loader?: ModernLoader;
+  loaderDeps?: unknown;
   loading?: unknown;
   pendingComponent?: unknown;
   path?: string;
   shouldRevalidate?: ModernShouldRevalidate;
+  validateSearch?: unknown;
 };
 
 type MutableTanstackRoute = AnyRoute & {
@@ -735,6 +739,8 @@ function createRouteFromRouteObject(opts: {
     component: toRouteComponent(routeObject),
     pendingComponent: toPendingComponent(routeObject),
     errorComponent: toErrorComponent(routeObject),
+    validateSearch: modernRouteObject.validateSearch,
+    loaderDeps: modernRouteObject.loaderDeps,
     wrapInSuspense: true,
     staticData: createRouteStaticData({
       modernRouteId: routeObject.id,
@@ -827,6 +833,8 @@ function createRouteFromModernRoute(opts: {
     component: component || undefined,
     pendingComponent: pendingComponent || undefined,
     errorComponent: errorComponent || undefined,
+    validateSearch: route.validateSearch,
+    loaderDeps: route.loaderDeps,
     wrapInSuspense: true,
     staticData: createRouteStaticData({
       modernRouteId: modernId,
@@ -910,6 +918,8 @@ export function createRouteTreeFromModernRoutes(
     component: rootComponent || undefined,
     pendingComponent: pendingComponent || undefined,
     errorComponent: errorComponent || undefined,
+    validateSearch: rootModern?.validateSearch,
+    loaderDeps: rootModern?.loaderDeps,
     wrapInSuspense: true,
     notFoundComponent: DefaultNotFound,
     staticData: createRouteStaticData({
@@ -981,6 +991,8 @@ export function createRouteTreeFromRouteObjects(
       ? toPendingComponent(rootLikeRoute)
       : undefined,
     errorComponent: rootLikeRoute ? toErrorComponent(rootLikeRoute) : undefined,
+    validateSearch: rootLikeRoute?.validateSearch,
+    loaderDeps: rootLikeRoute?.loaderDeps,
     wrapInSuspense: true,
     notFoundComponent: DefaultNotFound,
     staticData: createRouteStaticData({

package/src/runtime/types.ts

@@ -20,9 +20,22 @@ export type RouterConfig = {
   future?: Partial<{
     v7_startTransition: boolean;
   }>;
+  defaultStructuralSharing?: boolean;
   unstable_reloadOnURLMismatch?: boolean;
 };
 
+export const modernTanstackRouterFastDefaults = {
+  defaultStructuralSharing: true,
+} as const;
+
+export const getModernTanstackRouterFastDefaults = (
+  config: Partial<Pick<RouterConfig, 'defaultStructuralSharing'>> = {},
+) => ({
+  defaultStructuralSharing:
+    config.defaultStructuralSharing ??
+    modernTanstackRouterFastDefaults.defaultStructuralSharing,
+});
+
 export interface RouterRouteMatchSnapshot {
   routeId: string;
   assetRouteId?: string;

package/tests/router/cli.test.ts

@@ -1,9 +1,12 @@
 import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
+import { mergeConfig } from '@modern-js/plugin/cli';
 import type { Entrypoint } from '@modern-js/types';
 import { fs, NESTED_ROUTE_SPEC_FILE } from '@modern-js/utils';
 import {
+  createTanstackRsbuildRouteSplittingProfile,
+  isTanstackStartRouteModuleSource,
   tanstackRouterPlugin,
   writeTanstackRegisterFile,
   writeTanstackRouterTypesForEntries,
@@ -193,6 +196,12 @@ describe('tanstack router cli plugin', () => {
       },
     ]);
 
+    expect(taps.config()).toMatchObject({
+      output: {
+        splitRouteChunks: true,
+      },
+    });
+
     const specPath = path.join(distDirectory, NESTED_ROUTE_SPEC_FILE);
     await fs.outputJSON(specPath, {
       existing: [{ id: 'keep-me' }],
@@ -383,4 +392,234 @@ describe('tanstack router cli plugin', () => {
       }),
     );
   });
+
+  test('can opt out of Modern-owned route code splitting', async () => {
+    const taps: Record<string, any> = {};
+    const api = {
+      getAppContext: () => ({
+        srcDirectory: '/tmp/app/src',
+        serverRoutes: [],
+      }),
+      _internalRuntimePlugins: () => {},
+      checkEntryPoint: () => {},
+      config: (tap: any) => {
+        taps.config = tap;
+      },
+      modifyEntrypoints: () => {},
+      generateEntryCode: () => {},
+      onFileChanged: () => {},
+      modifyFileSystemRoutes: () => {},
+      onBeforeGenerateRoutes: () => {},
+    };
+
+    tanstackRouterPlugin({ routeCodeSplitting: false }).setup!(api as any);
+
+    expect(taps.config()).toMatchObject({
+      output: {
+        splitRouteChunks: false,
+      },
+    });
+  });
+
+  test('documents why TanStack Start Rspack splitter is not registered for Modern routes', () => {
+    const profile = createTanstackRsbuildRouteSplittingProfile({});
+
+    expect(profile).toMatchObject({
+      defaultConfig: {
+        output: {
+          splitRouteChunks: true,
+        },
+      },
+      modernRouteChunks: {
+        enabled: true,
+        owner: 'modern',
+      },
+      builderChunkSplit: {
+        owner: 'modern-rsbuild',
+        preserved: true,
+      },
+      tanstackStartRspackSplitter: {
+        compatible: false,
+        clientDeleteNodes: ['ssr', 'server', 'headers'],
+      },
+    });
+    expect(
+      isTanstackStartRouteModuleSource(
+        "export const Route = createFileRoute('/dashboard')({ component })",
+      ),
+    ).toBe(true);
+    expect(
+      isTanstackStartRouteModuleSource(
+        'export const route = createRoute({ getParentRoute, path })',
+      ),
+    ).toBe(false);
+  });
+
+  test('preserves user-selected route and builder chunk splitting modes', () => {
+    const pluginDefaults = createTanstackRsbuildRouteSplittingProfile(
+      {},
+    ).defaultConfig;
+    const chunkSplits = [
+      { strategy: 'split-by-module' },
+      { strategy: 'split-by-experience' },
+      { strategy: 'all-in-one' },
+      { strategy: 'single-vendor' },
+      { strategy: 'split-by-size', minSize: 10_000, maxSize: 60_000 },
+      {
+        strategy: 'custom',
+        splitChunks: {
+          chunks: 'all',
+          cacheGroups: {
+            tractors: {
+              name: 'tractors',
+              test: /tractors/u,
+            },
+          },
+        },
+      },
+    ];
+
+    for (const chunkSplit of chunkSplits) {
+      expect(
+        mergeConfig([
+          pluginDefaults,
+          {
+            output: {
+              splitRouteChunks: false,
+            },
+            performance: {
+              chunkSplit,
+            },
+            splitChunks: false,
+          },
+        ]),
+      ).toMatchObject({
+        output: {
+          splitRouteChunks: false,
+        },
+        performance: {
+          chunkSplit,
+        },
+        splitChunks: false,
+      });
+    }
+
+    const pageSplitWithManualAsyncChunks = mergeConfig([
+      pluginDefaults,
+      {
+        performance: {
+          chunkSplit: {
+            strategy: 'custom',
+            splitChunks: {
+              chunks: 'async',
+            },
+          },
+        },
+      },
+    ]);
+
+    expect(pageSplitWithManualAsyncChunks).toMatchObject({
+      output: {
+        splitRouteChunks: true,
+      },
+      performance: {
+        chunkSplit: {
+          strategy: 'custom',
+          splitChunks: {
+            chunks: 'async',
+          },
+        },
+      },
+    });
+  });
+
+  test('keeps custom cache group details intact', () => {
+    const pluginDefaults = createTanstackRsbuildRouteSplittingProfile(
+      {},
+    ).defaultConfig;
+
+    const mergedConfig = mergeConfig([
+      pluginDefaults,
+      {
+        performance: {
+          chunkSplit: {
+            strategy: 'custom',
+            splitChunks: {
+              chunks: 'all',
+              cacheGroups: {
+                tractors: {
+                  name: 'tractors',
+                  test: /tractors/u,
+                },
+              },
+            },
+          },
+        },
+      },
+    ]);
+
+    expect(
+      (
+        mergedConfig as {
+          performance?: {
+            chunkSplit?: {
+              splitChunks?: {
+                cacheGroups?: {
+                  tractors?: {
+                    test?: RegExp;
+                  };
+                };
+              };
+            };
+          };
+        }
+      ).performance?.chunkSplit?.splitChunks?.cacheGroups?.tractors?.test,
+    ).toEqual(/tractors/u);
+    expect(mergedConfig).toMatchObject({
+      output: {
+        splitRouteChunks: true,
+      },
+      performance: {
+        chunkSplit: {
+          strategy: 'custom',
+          splitChunks: {
+            chunks: 'all',
+            cacheGroups: {
+              tractors: {
+                name: 'tractors',
+              },
+            },
+          },
+        },
+      },
+    });
+  });
+
+  test('plugin opt-out can still combine with manual builder chunking', () => {
+    const pluginDefaults = createTanstackRsbuildRouteSplittingProfile({
+      routeCodeSplitting: false,
+    }).defaultConfig;
+
+    expect(
+      mergeConfig([
+        pluginDefaults,
+        {
+          performance: {
+            chunkSplit: {
+              strategy: 'single-vendor',
+            },
+          },
+        },
+      ]),
+    ).toMatchObject({
+      output: {
+        splitRouteChunks: false,
+      },
+      performance: {
+        chunkSplit: {
+          strategy: 'single-vendor',
+        },
+      },
+    });
+  });
 });

package/tests/router/fastDefaults.test.ts

@@ -0,0 +1,25 @@
+import {
+  getModernTanstackRouterFastDefaults,
+  modernTanstackRouterFastDefaults,
+} from '../../src/runtime/types';
+
+describe('tanstack router fast defaults', () => {
+  test('enables structural sharing by default', () => {
+    expect(modernTanstackRouterFastDefaults).toEqual({
+      defaultStructuralSharing: true,
+    });
+    expect(getModernTanstackRouterFastDefaults()).toEqual({
+      defaultStructuralSharing: true,
+    });
+  });
+
+  test('allows explicit structural sharing override', () => {
+    expect(
+      getModernTanstackRouterFastDefaults({
+        defaultStructuralSharing: false,
+      }),
+    ).toEqual({
+      defaultStructuralSharing: false,
+    });
+  });
+});