@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.9 → 3.9.3-ultramodern.1

package/tests/router/tanstackTypes.test.ts

@@ -1,384 +0,0 @@
-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 { promisify } from 'node:util';
-
-import { writeTanstackRegisterFile } from '../../src/cli/artifacts';
-import {
-  collectCanonicalRoutesForEntry,
-  generateTanstackRouterTypesSourceForEntry,
-} from '../../src/cli/tanstackTypes';
-
-const execFileAsync = promisify(execFile);
-const strictestTsconfigPath = path.resolve(
-  __dirname,
-  '../../node_modules/@tsconfig/strictest/tsconfig.json',
-);
-const installedReactRouterPath = path.resolve(
-  __dirname,
-  '../../node_modules/@tanstack/react-router',
-);
-
-async function writeTsconfig(
-  projectDirectory: string,
-  compilerOptions: Record<string, unknown>,
-) {
-  await writeFile(
-    path.join(projectDirectory, 'tsconfig.json'),
-    JSON.stringify(
-      {
-        extends: strictestTsconfigPath,
-        compilerOptions: {
-          jsx: 'react-jsx',
-          lib: ['ESNext', 'DOM'],
-          noEmit: true,
-          target: 'ESNext',
-          types: [],
-          ...compilerOptions,
-        },
-        include: ['src/**/*.ts', 'src/**/*.tsx', 'src/**/*.d.ts'],
-      },
-      null,
-      2,
-    ),
-  );
-}
-
-/** Runs the same compiler a consumer build runs; surfaces its diagnostics. */
-async function runTsgo(projectDirectory: string) {
-  try {
-    await execFileAsync(
-      process.platform === 'win32' ? 'tsgo.cmd' : 'tsgo',
-      ['-p', 'tsconfig.json'],
-      { cwd: projectDirectory, shell: process.platform === 'win32' },
-    );
-  } catch (error) {
-    const { stdout, stderr } = (error ?? {}) as {
-      stdout?: string;
-      stderr?: string;
-    };
-    if (stdout || stderr) {
-      throw new Error([stdout, stderr].filter(Boolean).join('\n'), {
-        cause: error,
-      });
-    }
-    throw error;
-  }
-}
-
-async function compileGeneratedRouterAgainstInstalledDeclarations(options: {
-  projectDirectory: string;
-  routerGenTs: string;
-}) {
-  const { projectDirectory, routerGenTs } = options;
-  const generatedDirectory = path.join(
-    projectDirectory,
-    'src',
-    'modern-tanstack',
-    'golden',
-  );
-  await mkdir(generatedDirectory, { recursive: true });
-  await writeFile(path.join(generatedDirectory, 'router.gen.ts'), routerGenTs);
-
-  // The runtime package re-exports the *installed* @tanstack/react-router
-  // declarations, so the generated file is checked against the real router
-  // types a consumer resolves — not a stand-in.
-  const runtimePackageDirectory = path.join(
-    projectDirectory,
-    'node_modules',
-    '@modern-js',
-    'plugin-tanstack',
-  );
-  await mkdir(runtimePackageDirectory, { recursive: true });
-  await writeFile(
-    path.join(runtimePackageDirectory, 'package.json'),
-    JSON.stringify({
-      name: '@modern-js/plugin-tanstack',
-      type: 'commonjs',
-      exports: {
-        './runtime': { types: './runtime.d.ts', default: './runtime.js' },
-      },
-    }),
-  );
-  await writeFile(
-    path.join(runtimePackageDirectory, 'runtime.d.ts'),
-    [
-      "export { createMemoryHistory, createRootRouteWithContext, createRoute, createRouter } from '@tanstack/react-router';",
-      'export type ModernRouterContext = { request?: Request; requestContext?: unknown };',
-      'export const modernTanstackRouterFastDefaults: { readonly defaultStructuralSharing: true };',
-      'export function createRouteStaticData<TData extends { modernRouteId?: string; modernRouteAction?: unknown; modernRouteLoader?: unknown }>(data: TData): TData;',
-      'export function modernLoaderToTanstack<TLoader extends (...args: any[]) => any>(options: { hasSplat: boolean }, modernLoader: TLoader): (context: unknown) => Promise<Awaited<ReturnType<TLoader>>>;',
-    ].join('\n'),
-  );
-  await writeFile(
-    path.join(projectDirectory, 'package.json'),
-    JSON.stringify({ private: true, type: 'commonjs' }),
-  );
-  await writeTsconfig(projectDirectory, {
-    module: 'Node16',
-    moduleResolution: 'Node16',
-    paths: { '@tanstack/react-router': [installedReactRouterPath] },
-    verbatimModuleSyntax: false,
-  });
-  await runTsgo(projectDirectory);
-}
-
-async function typecheckCanonicalRegisterContract(options: {
-  canonicalRoutes: Record<string, string>;
-  contractLines: string[];
-  projectDirectory: string;
-}) {
-  const { canonicalRoutes, contractLines, projectDirectory } = options;
-  const srcDirectory = path.join(projectDirectory, 'src');
-  await mkdir(path.join(srcDirectory, 'modern-tanstack', 'index'), {
-    recursive: true,
-  });
-  await writeFile(
-    path.join(srcDirectory, 'modern-tanstack', 'index', 'router.gen.ts'),
-    'export const router = { context: {} };',
-  );
-  await writeTanstackRegisterFile({
-    canonicalRoutes,
-    entries: ['index'],
-    srcDirectory,
-  });
-  await writeFile(
-    path.join(srcDirectory, 'runtime-shims.d.ts'),
-    [
-      "declare module '@modern-js/plugin-tanstack/runtime' { export interface Register {} }",
-      "declare module '@modern-js/plugin-i18n/runtime' { export interface UltramodernCanonicalRoutes {} }",
-    ].join('\n'),
-  );
-  await writeFile(
-    path.join(srcDirectory, 'canonical-routes-contract.ts'),
-    [
-      "import type { UltramodernCanonicalRoutes } from '@modern-js/plugin-i18n/runtime';",
-      ...contractLines,
-    ].join('\n'),
-  );
-  await writeTsconfig(projectDirectory, {
-    module: 'Preserve',
-    moduleResolution: 'Bundler',
-  });
-  await runTsgo(projectDirectory);
-}
-
-async function generateComprehensiveRouterGen(srcDirectory: string) {
-  const files = new Map([
-    [
-      'routes/(app)/layout.tsx',
-      'export default function AppLayout() { return null; }',
-    ],
-    [
-      'routes/(app)/users/(userId)/page.tsx',
-      'export default function UserPage() { return null; }',
-    ],
-    [
-      'routes/(app)/users/(userId)/page.data.ts',
-      [
-        'export const loader = () => ({ userId: "42" });',
-        'export const action = () => Response.json({ ok: true });',
-      ].join('\n'),
-    ],
-    [
-      'routes/(app)/docs/splat.tsx',
-      'export default function DocsSplatPage() { return null; }',
-    ],
-    [
-      'routes/search.contract.ts',
-      [
-        'export const validateSearch = (search: { tab?: string }) => ({ tab: search.tab ?? "overview" });',
-        'export const loaderDeps = ({ search }: { search: { tab: string } }) => ({ tab: search.tab });',
-      ].join('\n'),
-    ],
-  ]);
-  for (const [relativePath, contents] of files) {
-    const filePath = path.join(srcDirectory, relativePath);
-    await mkdir(path.dirname(filePath), { recursive: true });
-    await writeFile(filePath, contents);
-  }
-
-  const { routerGenTs } = await generateTanstackRouterTypesSourceForEntry({
-    appContext: { srcDirectory, internalSrcAlias: '@/_' } as any,
-    entryName: 'golden',
-    routes: [
-      {
-        type: 'nested',
-        id: 'layout',
-        isRoot: true,
-        children: [
-          {
-            type: 'nested',
-            id: '(app)/layout',
-            _component: '@/_/routes/(app)/layout',
-            children: [
-              {
-                type: 'nested',
-                id: '(app)/users/(userId)/page',
-                path: 'users/:userId',
-                _component: '@/_/routes/(app)/users/(userId)/page',
-                data: '@/_/routes/(app)/users/(userId)/page.data',
-                action: '@/_/routes/(app)/users/(userId)/page.data',
-                validateSearch: '@/_/routes/search.contract',
-                loaderDeps: '@/_/routes/search.contract',
-              },
-              {
-                type: 'nested',
-                id: '(app)/docs/splat/page',
-                path: 'docs/*',
-                _component: '@/_/routes/(app)/docs/splat',
-              },
-            ],
-          },
-        ],
-      },
-    ] as any,
-  });
-
-  return routerGenTs;
-}
-
-describe('tanstack router type generation', () => {
-  let tempDir: string | undefined;
-
-  afterEach(async () => {
-    if (tempDir) {
-      await rm(tempDir, { recursive: true, force: true });
-      tempDir = undefined;
-    }
-  });
-
-  test('strictly compiles generated routes against installed router declarations', async () => {
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-types-'));
-    const routerGenTs = await generateComprehensiveRouterGen(
-      path.join(tempDir, 'src'),
-    );
-
-    await compileGeneratedRouterAgainstInstalledDeclarations({
-      projectDirectory: tempDir,
-      routerGenTs,
-    });
-  });
-
-  test('maps a locale-prefixed route tree to the canonical paths consumers navigate to', () => {
-    const routes = [
-      {
-        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' },
-              {
-                type: 'nested',
-                id: '(lang)/optional/(slug$)/page',
-                path: 'optional/:slug?',
-              },
-              { type: 'nested', id: '(lang)/files/page', path: 'files/*' },
-            ],
-          },
-        ],
-      },
-    ] as any;
-
-    // Without plugin-i18n installed, a hand-rolled `/:lang/` param must NOT
-    // produce a canonical surface — the emitted module augmentation would
-    // break typechecking in an app that never opted into i18n.
-    expect(
-      collectCanonicalRoutesForEntry(routes, { localeParamHeuristic: false }),
-    ).toBeNull();
-
-    const result = collectCanonicalRoutesForEntry(routes);
-    expect(result).not.toBeNull();
-    expect(Object.keys(result!)).toEqual([
-      '/',
-      '/about',
-      '/files/$',
-      '/optional/{-$slug}',
-    ]);
-  });
-
-  test('collapses localized variants to one canonical key with typed params', async () => {
-    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();
-    expect(Object.keys(result!)).toEqual([
-      '/optional/{-$slug}',
-      '/products/$slug',
-    ]);
-    expect('/produkty/$slug' in result!).toBe(false);
-
-    tempDir = await mkdtemp(path.join(tmpdir(), 'modern-tanstack-canonical-'));
-    await typecheckCanonicalRegisterContract({
-      canonicalRoutes: {
-        '/': 'Record<string, never>',
-        '/files/$': '{ _splat?: string }',
-        ...result!,
-      },
-      contractLines: [
-        "const rootParams: UltramodernCanonicalRoutes['/'] = {};",
-        '// @ts-expect-error index canonical routes reject unexpected params',
-        "const invalidRootParams: UltramodernCanonicalRoutes['/'] = { slug: 'unexpected' };",
-        "const productParams: UltramodernCanonicalRoutes['/products/$slug'] = { slug: 'tractor' };",
-        "const optionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = {};",
-        "const presentOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = { slug: 'tractor' };",
-        '// @ts-expect-error optional canonical params still retain their string type',
-        "const invalidOptionalParams: UltramodernCanonicalRoutes['/optional/{-$slug}'] = { slug: 42 };",
-        "const splatParams: UltramodernCanonicalRoutes['/files/$'] = { _splat: 'guides/intro' };",
-        '// @ts-expect-error localized physical variants do not become canonical keys',
-        "declare const localizedParams: UltramodernCanonicalRoutes['/produkty/$slug'];",
-        '// @ts-expect-error the deduplicated product route still requires its param',
-        "const missingProductParams: UltramodernCanonicalRoutes['/products/$slug'] = {};",
-        'void rootParams;',
-        'void productParams;',
-        'void optionalParams;',
-        'void presentOptionalParams;',
-        'void splatParams;',
-        'void invalidRootParams;',
-        'void invalidOptionalParams;',
-        'void localizedParams;',
-        'void missingProductParams;',
-      ],
-      projectDirectory: tempDir,
-    });
-  });
-});

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "@modern-js/tsconfig/base",
-  "compilerOptions": {
-    "declaration": false,
-    "lib": ["DOM", "ESNext", "dom.iterable"],
-    "jsx": "preserve",
-    "isolatedModules": true,
-    "paths": {},
-    "rootDir": "./src"
-  },
-  "include": ["src"]
-}

package/tsconfig.tsgo.json

@@ -1,6 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "moduleResolution": "Bundler"
-  }
-}