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

package/tests/router/tanstackTypes.test.ts

@@ -1,7 +1,14 @@
+import { execFile } from 'node:child_process';
 import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
-import { generateTanstackRouterTypesSourceForEntry } from '../../src/cli/tanstackTypes';
+import { promisify } from 'node:util';
+import {
+  collectCanonicalRoutesForEntry,
+  generateTanstackRouterTypesSourceForEntry,
+} from '../../src/cli/tanstackTypes';
+
+const execFileAsync = promisify(execFile);
 
 describe('tanstack router type generation', () => {
   let tempDir: string | undefined;
@@ -55,8 +62,415 @@ describe('tanstack router type generation', () => {
     );
     expect(routerGenTs).toContain('modernRouteLoader: loader_0');
     expect(routerGenTs).toContain('modernRouteAction: action_0');
+    expect(routerGenTs).toContain('modernRouteId?: string;');
+    expect(routerGenTs).not.toContain(
+      'return Object.keys(staticData).length > 0 ? staticData : undefined;',
+    );
     expect(routerGenTs).toContain(
       "} from '@modern-js/plugin-tanstack/runtime';",
     );
+    expect(routerGenTs).toContain('modernTanstackRouterFastDefaults,');
+    expect(routerGenTs).toContain('...modernTanstackRouterFastDefaults,');
+  });
+
+  test('typechecks generated TanStack search contracts', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
+    const srcDirectory = path.join(tempDir, 'src');
+    const routeDir = path.join(srcDirectory, 'routes');
+    const generatedDir = path.join(srcDirectory, 'modern-tanstack', 'index');
+    await mkdir(routeDir, { recursive: true });
+    await mkdir(generatedDir, { recursive: true });
+    await writeFile(
+      path.join(routeDir, 'search.contract.ts'),
+      [
+        'export const validateSearch = (search: { q?: string }) => ({ q: search.q ?? "" });',
+        'export const loaderDeps = ({ search }: { search: { q: string } }) => ({ q: search.q });',
+      ].join('\n'),
+    );
+
+    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+      appContext: {
+        srcDirectory,
+        internalSrcAlias: '@/_',
+      } as any,
+      entryName: 'index',
+      routes: [
+        {
+          type: 'nested',
+          id: 'layout',
+          isRoot: true,
+          validateSearch: '@/_/routes/search.contract',
+          loaderDeps: '@/_/routes/search.contract',
+          children: [
+            {
+              type: 'nested',
+              id: 'search/page',
+              path: 'search',
+              validateSearch: '@/_/routes/search.contract',
+              loaderDeps: '@/_/routes/search.contract',
+            },
+          ],
+        },
+      ] as any,
+    });
+
+    await writeFile(path.join(generatedDir, 'router.gen.ts'), routerGenTs);
+    await writeFile(
+      path.join(srcDirectory, 'runtime-shim.d.ts'),
+      [
+        "declare module '@modern-js/plugin-tanstack/runtime' {",
+        '  type RouteOptions = {',
+        '    getParentRoute?: () => unknown;',
+        '    id?: string;',
+        '    loader?: unknown;',
+        '    loaderDeps?: unknown;',
+        '    path?: string;',
+        '    staticData?: unknown;',
+        '    validateSearch?: unknown;',
+        '  };',
+        '  type Route<TOptions extends RouteOptions> = {',
+        '    options: TOptions;',
+        '    addChildren<TChildren extends readonly unknown[]>(children: TChildren): Route<TOptions> & { children: TChildren };',
+        '  };',
+        '  export function createMemoryHistory(options: unknown): unknown;',
+        '  export const modernTanstackRouterFastDefaults: Record<string, unknown>;',
+        '  export function createRootRouteWithContext<TContext>(): <TOptions extends RouteOptions>(options: TOptions) => Route<TOptions>;',
+        '  export function createRoute<TOptions extends RouteOptions>(options: TOptions): Route<TOptions>;',
+        '  export function createRouter<TOptions extends Record<string, unknown>>(options: TOptions): TOptions;',
+        '  export function notFound(): never;',
+        '  export function redirect(options: unknown): never;',
+        '}',
+      ].join('\n'),
+    );
+    await writeFile(
+      path.join(srcDirectory, 'assert-search-contracts.ts'),
+      [
+        "import { rootRoute, routeTree } from './modern-tanstack/index/router.gen';",
+        "import { loaderDeps, validateSearch } from './routes/search.contract';",
+        '',
+        'const rootValidateSearch: typeof validateSearch = rootRoute.options.validateSearch;',
+        'const rootLoaderDeps: typeof loaderDeps = rootRoute.options.loaderDeps;',
+        'const childValidateSearch: typeof validateSearch = routeTree.children[0].options.validateSearch;',
+        'const childLoaderDeps: typeof loaderDeps = routeTree.children[0].options.loaderDeps;',
+        '',
+        "rootValidateSearch({ q: 'root' });",
+        "rootLoaderDeps({ search: { q: 'root' } });",
+        "childValidateSearch({ q: 'child' });",
+        "childLoaderDeps({ search: { q: 'child' } });",
+      ].join('\n'),
+    );
+    await writeFile(
+      path.join(tempDir, 'tsconfig.json'),
+      JSON.stringify(
+        {
+          compilerOptions: {
+            lib: ['ESNext', 'DOM'],
+            module: 'Preserve',
+            moduleResolution: 'Bundler',
+            noEmit: true,
+            skipLibCheck: true,
+            strict: true,
+            target: 'ESNext',
+            types: [],
+          },
+          include: ['src/**/*.ts', 'src/**/*.d.ts'],
+        },
+        null,
+        2,
+      ),
+    );
+
+    await expect(
+      execFileAsync('tsgo', ['--noEmit', '-p', 'tsconfig.json'], {
+        cwd: tempDir,
+      }),
+    ).resolves.toBeDefined();
+  });
+
+  test('preserves typed child trees for localized nested route aliases', async () => {
+    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
+    const srcDirectory = path.join(tempDir, 'src');
+
+    const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
+      appContext: {
+        srcDirectory,
+        internalSrcAlias: '@/_',
+      } as any,
+      entryName: 'index',
+      routes: [
+        {
+          type: 'nested',
+          id: 'layout',
+          isRoot: true,
+          children: [
+            {
+              type: 'nested',
+              id: '(lang)/layout',
+              path: ':lang',
+              children: [
+                {
+                  type: 'nested',
+                  id: '(lang)/products/(slug)/page',
+                  path: 'products/:slug',
+                },
+                {
+                  type: 'nested',
+                  id: '(lang)/products/(slug)/page__localised_produkty_slug',
+                  path: 'produkty/:slug',
+                },
+                {
+                  type: 'nested',
+                  id: '(lang)/optional/(slug$)/page__localised_volitelne_slug',
+                  path: 'volitelne/:slug?',
+                },
+              ],
+            },
+          ],
+        },
+      ] as any,
+    });
+
+    expect(routerGenTs).toContain(
+      'const route__lang__layout__base = createRoute({',
+    );
+    expect(routerGenTs).toContain(
+      'getParentRoute: () => route__lang__layout__base,',
+    );
+    expect(routerGenTs).toContain('path: "produkty/$slug",');
+    expect(routerGenTs).toContain('path: "volitelne/{-$slug}",');
+    expect(routerGenTs).toContain(
+      'const route__lang__layout = route__lang__layout__base.addChildren([route__lang__products__slug__page, route__lang__products__slug__page__localised_produkty_slug, route__lang__optional__slug$__page__localised_volitelne_slug]);',
+    );
+    expect(routerGenTs).toContain(
+      'export const routeTree = rootRoute.addChildren([route__lang__layout]);',
+    );
+    expect(routerGenTs).not.toContain('route__lang__layout.addChildren([');
+  });
+});
+
+describe('collectCanonicalRoutesForEntry', () => {
+  test('returns null for a route tree with no locale param and no canonical metadata', () => {
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: 'about/page',
+            path: 'about',
+          },
+          {
+            type: 'nested',
+            id: 'contact/page',
+            path: 'contact',
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).toBeNull();
+  });
+
+  test('strips leading :lang param and maps index under :lang to "/"', () => {
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/page',
+                index: true,
+              },
+              {
+                type: 'nested',
+                id: '(lang)/about/page',
+                path: 'about',
+              },
+            ],
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).not.toBeNull();
+    expect(result!['/']).toBe('Record<string, never>');
+    expect(result!['/about']).toBe('Record<string, never>');
+  });
+
+  test('converts :slug to $slug with required params type', () => {
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/products/(slug)/page',
+                path: 'products/:slug',
+              },
+            ],
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).not.toBeNull();
+    expect(result!['/products/$slug']).toBe('{ "slug": string }');
+  });
+
+  test('converts :slug? to optional {-$slug} with optional params type', () => {
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/optional/(slug$)/page',
+                path: 'optional/:slug?',
+              },
+            ],
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).not.toBeNull();
+    expect(result!['/optional/{-$slug}']).toBe('{ "slug"?: string }');
+  });
+
+  test('converts * splat to $ with optional _splat param', () => {
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/files/page',
+                path: 'files/*',
+              },
+            ],
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).not.toBeNull();
+    expect(result!['/files/$']).toBe("{ '_splat'?: string }");
+  });
+
+  test('collapses localized variants with shared modernCanonicalPath to one canonical key', () => {
+    // This reuses the same fixture shape as the 'preserves typed child trees'
+    // test but adds modernCanonicalPath fields as plugin-i18n now emits.
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/products/(slug)/page',
+                path: 'products/:slug',
+                modernCanonicalPath: '/products/:slug',
+              },
+              {
+                type: 'nested',
+                id: '(lang)/products/(slug)/page__localised_produkty_slug',
+                path: 'produkty/:slug',
+                modernCanonicalPath: '/products/:slug',
+              },
+              {
+                type: 'nested',
+                id: '(lang)/optional/(slug$)/page__localised_volitelne_slug',
+                path: 'volitelne/:slug?',
+                modernCanonicalPath: '/optional/:slug?',
+              },
+            ],
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).not.toBeNull();
+    // Two physical variants share the same canonical path — only one entry.
+    const keys = Object.keys(result!);
+    // /products/$slug and /optional/{-$slug} — exactly 2 keys with params
+    expect(keys.filter(k => k.startsWith('/products'))).toHaveLength(1);
+    expect(result!['/products/$slug']).toBe('{ "slug": string }');
+    expect(result!['/optional/{-$slug}']).toBe('{ "slug"?: string }');
+    // The Czech localized path must not appear as a separate key.
+    expect('/produkty/$slug' in result!).toBe(false);
+  });
+
+  test('output is sorted alphabetically by canonical key', () => {
+    const result = collectCanonicalRoutesForEntry([
+      {
+        type: 'nested',
+        id: 'layout',
+        isRoot: true,
+        children: [
+          {
+            type: 'nested',
+            id: '(lang)/layout',
+            path: ':lang',
+            children: [
+              {
+                type: 'nested',
+                id: '(lang)/products/(slug)/page',
+                path: 'products/:slug',
+              },
+              {
+                type: 'nested',
+                id: '(lang)/about/page',
+                path: 'about',
+              },
+              {
+                type: 'nested',
+                id: '(lang)/page',
+                index: true,
+              },
+            ],
+          },
+        ],
+      },
+    ] as any);
+
+    expect(result).not.toBeNull();
+    const keys = Object.keys(result!);
+    expect(keys).toEqual([...keys].sort((a, b) => a.localeCompare(b)));
   });
 });