@bleedingdev/modern-js-plugin-tanstack 3.2.0-ultramodern.12 → 3.2.0-ultramodern.121

package/tests/router/cli.test.ts

@@ -1,9 +1,11 @@
 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,
   tanstackRouterPlugin,
   writeTanstackRegisterFile,
   writeTanstackRouterTypesForEntries,
@@ -16,16 +18,29 @@ const runtimeCliMocks = {
 
 rstest.mock('@modern-js/runtime/cli', () => {
   const routesDirMetaKey = '__modernRoutesDir';
+  // The codegen helpers are pure — forward to the real implementations.
+  const actualCli = rstest.requireActual('@modern-js/runtime/cli') as {
+    getPathWithoutExt: (filename: string) => string;
+    makeLegalIdentifier: (value: string) => string;
+  };
 
   return {
     __esModule: true,
+    getPathWithoutExt: actualCli.getPathWithoutExt,
+    makeLegalIdentifier: actualCli.makeLegalIdentifier,
     getEntrypointRoutesDir: (entrypoint: any) =>
       entrypoint[routesDirMetaKey] ||
       (entrypoint.nestedRoutesEntry
         ? path.basename(entrypoint.nestedRoutesEntry)
         : null),
-    handleFileChange: runtimeCliMocks.handleFileChange,
-    handleGeneratorEntryCode: runtimeCliMocks.handleGeneratorEntryCode,
+    getEntrypointRoutesOwner: (entrypoint: any) =>
+      entrypoint.__modernRoutesOwner || null,
+    // Forward through arrows: the mock factory is hoisted above the
+    // `runtimeCliMocks` initializer, so it must not dereference it eagerly.
+    handleFileChange: (...args: unknown[]) =>
+      runtimeCliMocks.handleFileChange(...args),
+    handleGeneratorEntryCode: (...args: unknown[]) =>
+      runtimeCliMocks.handleGeneratorEntryCode(...args),
     handleModifyEntrypoints: async (
       entrypoints: Entrypoint[],
       routesDir = 'routes',
@@ -120,6 +135,82 @@ describe('tanstack router cli plugin', () => {
     );
   });
 
+  test('writes plugin-i18n module augmentation when canonicalRoutes are provided', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
+    const srcDirectory = path.join(tempDir, 'src');
+
+    await writeTanstackRegisterFile({
+      entries: ['main'],
+      generatedDirName: 'tanstack',
+      srcDirectory,
+      canonicalRoutes: {
+        '/': 'Record<string, never>',
+        '/products/$slug': '{ "slug": string }',
+      },
+    });
+
+    const register = await readFile(
+      path.join(srcDirectory, 'tanstack', 'register.gen.d.ts'),
+      'utf-8',
+    );
+
+    expect(register).toContain(
+      "declare module '@modern-js/plugin-i18n/runtime'",
+    );
+    expect(register).toContain('interface UltramodernCanonicalRoutes');
+    expect(register).toContain("'/': Record<string, never>;");
+    expect(register).toContain('\'/products/$slug\': { "slug": string };');
+  });
+
+  test('does not emit plugin-i18n augmentation when canonicalRoutes is absent (back-compat)', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
+    const srcDirectory = path.join(tempDir, 'src');
+
+    await writeTanstackRegisterFile({
+      entries: ['main'],
+      generatedDirName: 'tanstack',
+      srcDirectory,
+      // No canonicalRoutes provided at all — plain TanStack app
+    });
+
+    const register = await readFile(
+      path.join(srcDirectory, 'tanstack', 'register.gen.d.ts'),
+      'utf-8',
+    );
+
+    expect(register).not.toContain('plugin-i18n');
+    expect(register).not.toContain('UltramodernCanonicalRoutes');
+    // But the standard TanStack runtime augmentation must still be present.
+    expect(register).toContain(
+      "declare module '@modern-js/plugin-tanstack/runtime'",
+    );
+  });
+
+  test('uses a custom i18nRuntimeModule when specified', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
+    const srcDirectory = path.join(tempDir, 'src');
+
+    await writeTanstackRegisterFile({
+      entries: ['main'],
+      generatedDirName: 'tanstack',
+      srcDirectory,
+      canonicalRoutes: {
+        '/talks': 'Record<string, never>',
+      },
+      i18nRuntimeModule: '@my-org/i18n/runtime',
+    });
+
+    const register = await readFile(
+      path.join(srcDirectory, 'tanstack', 'register.gen.d.ts'),
+      'utf-8',
+    );
+
+    expect(register).toContain("declare module '@my-org/i18n/runtime'");
+    expect(register).not.toContain(
+      "declare module '@modern-js/plugin-i18n/runtime'",
+    );
+  });
+
   test('claims custom routes, injects runtime plugin, and merges route specs', async () => {
     tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
     const srcDirectory = path.join(tempDir, 'src');
@@ -193,6 +284,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' }],
@@ -222,6 +319,278 @@ describe('tanstack router cli plugin', () => {
     });
   });
 
+  test('injects the framework-resolving router wrapper for non-file-route entrypoints', async () => {
+    const taps: Record<string, any> = {};
+    const api = {
+      getAppContext: () => ({
+        srcDirectory: '/tmp/app/src',
+        metaName: 'modern-js',
+        serverRoutes: [{ entryName: 'custom', urlPath: '/' }],
+      }),
+      _internalRuntimePlugins: (tap: any) => {
+        taps.internalRuntimePlugins = tap;
+      },
+      checkEntryPoint: () => {},
+      config: () => {},
+      modifyEntrypoints: () => {},
+      generateEntryCode: () => {},
+      onFileChanged: () => {},
+      modifyFileSystemRoutes: () => {},
+      onBeforeGenerateRoutes: () => {},
+    };
+
+    tanstackRouterPlugin().setup!(api as any);
+
+    // Custom entry without a routes dir (e.g. `createRoutes` in
+    // modern.runtime.ts): installing the plugin is the explicit opt-in, no
+    // source sniffing — the wrapper plus the provider registration is
+    // injected through the package's own runtime/router module.
+    const customEntrypoint = {
+      entryName: 'custom',
+      isAutoMount: true,
+    } as Entrypoint;
+    expect(
+      taps.internalRuntimePlugins({ entrypoint: customEntrypoint, plugins: [] })
+        .plugins,
+    ).toEqual([
+      {
+        name: 'router',
+        path: '@modern-js/plugin-tanstack/runtime/router',
+        config: { serverBase: ['/'] },
+      },
+    ]);
+
+    // If the built-in router CLI already installed the internal router for
+    // this custom entry (explicit `runtime.router` config), only the module
+    // path is redirected so the TanStack provider registration is
+    // value-imported with it.
+    const existingRouterPlugin = {
+      name: 'router',
+      path: '@modern-js/runtime/router/internal',
+      config: { serverBase: ['/'] },
+    };
+    const { plugins } = taps.internalRuntimePlugins({
+      entrypoint: customEntrypoint,
+      plugins: [existingRouterPlugin],
+    });
+    expect(plugins).toHaveLength(1);
+    expect(plugins[0]).toEqual({
+      name: 'router',
+      path: '@modern-js/plugin-tanstack/runtime/router',
+      config: { serverBase: ['/'] },
+    });
+  });
+
+  test('leaves built-in and foreign-owned route entrypoints to their own router', () => {
+    const taps: Record<string, any> = {};
+    const api = {
+      getAppContext: () => ({
+        srcDirectory: '/tmp/app/src',
+        metaName: 'modern-js',
+        serverRoutes: [{ entryName: 'home', urlPath: '/' }],
+      }),
+      _internalRuntimePlugins: (tap: any) => {
+        taps.internalRuntimePlugins = tap;
+      },
+      checkEntryPoint: () => {},
+      config: () => {},
+      modifyEntrypoints: () => {},
+      generateEntryCode: () => {},
+      onFileChanged: () => {},
+      modifyFileSystemRoutes: () => {},
+      onBeforeGenerateRoutes: () => {},
+    };
+
+    tanstackRouterPlugin({ routesDir: 'ts-routes' }).setup!(api as any);
+
+    // A classic react-router file-route entry (src/<entry>/routes) living
+    // next to the TanStack entries: its internal router plugin must be left
+    // untouched — redirecting it through the TanStack wrapper would pull
+    // @tanstack/react-router into a pure react-router bundle.
+    const builtInEntrypoint = {
+      entryName: 'home',
+      isAutoMount: true,
+      nestedRoutesEntry: '/tmp/app/src/home/routes',
+      __modernRoutesDir: 'routes',
+    } as Entrypoint;
+    const { plugins: builtInPlugins } = taps.internalRuntimePlugins({
+      entrypoint: builtInEntrypoint,
+      plugins: [
+        {
+          name: 'router',
+          path: '@modern-js/runtime/router/internal',
+          config: { serverBase: ['/'] },
+        },
+      ],
+    });
+    expect(builtInPlugins).toEqual([
+      {
+        name: 'router',
+        path: '@modern-js/runtime/router/internal',
+        config: { serverBase: ['/'] },
+      },
+    ]);
+
+    // An entry tagged by another routes-owner plugin: nothing is pushed.
+    // The replaced sniffing path in @modern-js/runtime excluded
+    // plugin-owned entrypoints for the same reason — pushing a second
+    // `router` plugin can install two routers for one entry.
+    const foreignEntrypoint = {
+      entryName: 'home',
+      isAutoMount: true,
+      nestedRoutesEntry: '/tmp/app/src/home/acme-routes',
+      __modernRoutesDir: 'acme-routes',
+      __modernRoutesOwner: '@acme/plugin-file-router',
+    } as Entrypoint;
+    expect(
+      taps.internalRuntimePlugins({
+        entrypoint: foreignEntrypoint,
+        plugins: [],
+      }).plugins,
+    ).toEqual([]);
+
+    // The built-in pages/ convention is foreign too.
+    const pagesEntrypoint = {
+      entryName: 'home',
+      isAutoMount: true,
+      pageRoutesEntry: '/tmp/app/src/home/pages',
+    } as Entrypoint;
+    expect(
+      taps.internalRuntimePlugins({ entrypoint: pagesEntrypoint, plugins: [] })
+        .plugins,
+    ).toEqual([]);
+  });
+
+  test('source.include covers the package dist and TanStack runtime deps without string surgery', () => {
+    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().setup!(api as any);
+
+    const include = taps.config().source.include as Array<RegExp | string>;
+    const regexes = include.filter(
+      (entry): entry is RegExp => entry instanceof RegExp,
+    );
+    for (const dep of ['react-router', 'router-core', 'react-store']) {
+      const sample = `/repo/node_modules/@tanstack/${dep}/dist/esm/index.js`;
+      expect(regexes.some(regex => regex.test(sample))).toBe(true);
+    }
+
+    const stringEntries = include.filter(
+      (entry): entry is string => typeof entry === 'string',
+    );
+    expect(stringEntries).toHaveLength(1);
+    // The include must point at the package root (two levels above the cli
+    // build dir) so dist/esm, dist/esm-node and dist/cjs are all covered —
+    // the old `.replace('cjs', 'esm')` never matched the bundled dist/esm
+    // runtime when the CLI was loaded through the ESM condition.
+    expect(stringEntries[0]).toBe(path.resolve(__dirname, '..', '..'));
+    expect(stringEntries[0]).not.toContain('esm');
+  });
+
+  test('emits the plugin-i18n augmentation only when plugin-i18n is registered', async () => {
+    const langRoutes = [
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/about/page',
+                path: 'about',
+              },
+            ],
+          },
+        ],
+      },
+    ];
+
+    const runGenerate = async (registeredPlugins: Array<{ name: string }>) => {
+      const dir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
+      const srcDirectory = path.join(dir, 'src');
+      const entrypoint = {
+        entryName: 'main',
+        isAutoMount: true,
+        isMainEntry: true,
+        nestedRoutesEntry: path.join(srcDirectory, 'routes'),
+        __modernRoutesDir: 'routes',
+      } as Entrypoint;
+      runtimeCliMocks.handleGeneratorEntryCode.mockResolvedValueOnce({
+        main: langRoutes,
+      });
+
+      const taps: Record<string, any> = {};
+      const api = {
+        getAppContext: () => ({
+          srcDirectory,
+          internalSrcAlias: '@/_',
+          entrypoints: [entrypoint],
+          plugins: registeredPlugins,
+        }),
+        _internalRuntimePlugins: () => {},
+        checkEntryPoint: () => {},
+        config: () => {},
+        modifyEntrypoints: () => {},
+        generateEntryCode: (tap: any) => {
+          taps.generateEntryCode = tap;
+        },
+        onFileChanged: () => {},
+        modifyFileSystemRoutes: () => {},
+        onBeforeGenerateRoutes: () => {},
+      };
+
+      tanstackRouterPlugin().setup!(api as any);
+      await taps.generateEntryCode({ entrypoints: [entrypoint] });
+
+      const register = await readFile(
+        path.join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts'),
+        'utf-8',
+      );
+      await rm(dir, { recursive: true, force: true });
+      return register;
+    };
+
+    // A hand-rolled `/:lang/` app WITHOUT plugin-i18n must not get the
+    // augmentation — it would reference an unresolvable module (TS2664).
+    const withoutI18n = await runGenerate([{ name: '@modern-js/app-tools' }]);
+    expect(withoutI18n).not.toContain('plugin-i18n');
+    expect(withoutI18n).not.toContain('UltramodernCanonicalRoutes');
+    expect(withoutI18n).toContain(
+      "declare module '@modern-js/plugin-tanstack/runtime'",
+    );
+
+    // With plugin-i18n registered the canonical route map is emitted.
+    const withI18n = await runGenerate([
+      { name: '@modern-js/app-tools' },
+      { name: '@modern-js/plugin-i18n' },
+    ]);
+    expect(withI18n).toContain(
+      "declare module '@modern-js/plugin-i18n/runtime'",
+    );
+    expect(withI18n).toContain("'/about': Record<string, never>;");
+  });
+
   test('generates plugin-owned TanStack route files through core route generation', async () => {
     tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-cli-'));
     const srcDirectory = path.join(tempDir, 'src');
@@ -307,9 +676,6 @@ describe('tanstack router cli plugin', () => {
       [entrypoint],
       {
         entrypointsKey: '@modern-js/plugin-tanstack',
-        generateCodeOptions: {
-          enableTanstackTypes: false,
-        },
       },
     );
 
@@ -383,4 +749,219 @@ 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('route splitting profile carries only the rsbuild config production consumes', () => {
+    expect(createTanstackRsbuildRouteSplittingProfile({})).toEqual({
+      defaultConfig: {
+        output: {
+          splitRouteChunks: true,
+        },
+      },
+    });
+    expect(
+      createTanstackRsbuildRouteSplittingProfile({ routeCodeSplitting: false }),
+    ).toEqual({
+      defaultConfig: {
+        output: {
+          splitRouteChunks: 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,
+    });
+  });
+});

package/tests/router/hooks.test.ts

@@ -0,0 +1,26 @@
+import {
+  modifyRoutes as canonicalModifyRoutes,
+  routerProviderRegistryHooks,
+} from '@modern-js/runtime/context';
+import * as tanstackHooks from '../../src/runtime/hooks';
+import { tanstackRouterPlugin as browserPlugin } from '../../src/runtime/plugin';
+import { tanstackRouterPlugin as nodePlugin } from '../../src/runtime/plugin.node';
+
+describe('tanstack router hooks single declaration source', () => {
+  test('re-exports the canonical hook instances owned by @modern-js/runtime', () => {
+    // Identity matters: separate instances would split the hook registry
+    // between the built-in router wrapper and this provider.
+    expect(tanstackHooks.modifyRoutes).toBe(canonicalModifyRoutes);
+    expect(tanstackHooks.routerProviderRegistryHooks).toBe(
+      routerProviderRegistryHooks,
+    );
+    expect(tanstackHooks.modifyRoutes).toBe(
+      routerProviderRegistryHooks.modifyRoutes,
+    );
+  });
+
+  test('both runtime plugins register the canonical hook registry object', () => {
+    expect(browserPlugin().registryHooks).toBe(routerProviderRegistryHooks);
+    expect(nodePlugin().registryHooks).toBe(routerProviderRegistryHooks);
+  });
+});