@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.4 → 3.9.0-ultramodern.6

package/tests/router/generateRouteArtifacts.test.ts

@@ -1,19 +1,11 @@
-// Behavioral coverage for the headless routes-generate entry point: the
-// export-shape test in cli.test.ts would pass even if the body were
-// reverted, so this file pins the actual prepare-only drive contract —
-// createRunOptions against the app dir, cli.init with build-command
-// semantics, the MODERN_ARGV gate that makes analyze.onPrepare fire
-// generateEntryCode, and the absolute config-file resolution that keeps
-// headless runs (cwd != appDirectory) from feeding `false` into node's
-// path APIs.
+// The headless entry must drive the real TanStack artifact writer. Checking
+// only the createRunOptions/cli.init choreography would allow a no-op CLI to
+// pass while leaving router.gen.ts stale or missing.
 const createRunOptionsMock = rstest.fn(async (options: unknown) => ({
   mockRunOptions: true,
   received: options,
 }));
-const cliInitMock = rstest.fn(async (options: unknown) => ({
-  appContext: {},
-  received: options,
-}));
+const cliInitMock = rstest.fn(async () => ({ appContext: {} }));
 
 rstest.mock('@modern-js/app-tools/cli/run', () => ({
   createRunOptions: createRunOptionsMock,
@@ -26,7 +18,10 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { INTERNAL_RUNTIME_PLUGINS } from '@modern-js/utils';
-import { generateTanstackRouteArtifacts } from '../../src/cli';
+import {
+  generateTanstackRouteArtifacts,
+  writeTanstackRouterTypesForEntries,
+} from '../../src/cli';
 
 function makeAppDir(withConfig: boolean): string {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tanstack-routes-gen-'));
@@ -46,9 +41,55 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
     cliInitMock.mockClear();
   });
 
-  it('drives a prepare-only cli.init with build-command semantics', async () => {
+  it('writes a real route artifact through the prepare-only CLI drive', async () => {
     const previousArgv = process.env.MODERN_ARGV;
     const appDirectory = makeAppDir(true);
+    const srcDirectory = path.join(appDirectory, 'src');
+    const componentPath = path.join(srcDirectory, 'routes', 'page.tsx');
+    fs.mkdirSync(path.dirname(componentPath), { recursive: true });
+    fs.writeFileSync(
+      componentPath,
+      'export default function Page() { return null; }\n',
+      'utf-8',
+    );
+
+    const runOptions = {
+      cwd: appDirectory,
+      version: '9.9.9-test',
+      internalPlugins: INTERNAL_RUNTIME_PLUGINS,
+      configFile: path.resolve(appDirectory, 'modern.config'),
+    };
+    createRunOptionsMock.mockResolvedValue({
+      mockRunOptions: true,
+      received: runOptions,
+    });
+    cliInitMock.mockImplementation(async () => {
+      await writeTanstackRouterTypesForEntries({
+        appContext: {
+          srcDirectory,
+          internalSrcAlias: '@/_',
+          entrypoints: [{ entryName: 'main', isMainEntry: true }],
+        } as any,
+        routesByEntry: {
+          main: [
+            {
+              type: 'nested',
+              id: 'layout',
+              isRoot: true,
+              children: [
+                {
+                  type: 'nested',
+                  id: 'page',
+                  index: true,
+                  _component: '@/_/routes/page',
+                },
+              ],
+            },
+          ] as any,
+        },
+      });
+      return { appContext: {} };
+    });
 
     try {
       await generateTanstackRouteArtifacts({
@@ -61,26 +102,25 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
         string,
         unknown
       >;
-      expect(runOptionsArg.cwd).toBe(appDirectory);
-      expect(runOptionsArg.version).toBe('9.9.9-test');
-      expect(runOptionsArg.internalPlugins).toBe(INTERNAL_RUNTIME_PLUGINS);
-
-      // The config file is resolved to an absolute base path against the app
-      // directory (not process.cwd()). Without this, a headless run from a
-      // different cwd finds no config, `findExists` returns `false`, and that
-      // boolean reaches `path.isAbsolute` deep inside plugin/cli.
-      expect(runOptionsArg.configFile).toBe(
-        path.resolve(appDirectory, 'modern.config'),
-      );
+      expect(runOptionsArg).toEqual(runOptions);
 
       expect(cliInitMock).toHaveBeenCalledTimes(1);
       const initArg = cliInitMock.mock.calls[0][0] as Record<string, unknown>;
       expect(initArg.command).toBe('build');
       expect(initArg.mockRunOptions).toBe(true);
-
-      // checkIsBuildCommands() resolves the command from MODERN_ARGV — this
-      // is what lets analyze.onPrepare fire generateEntryCode headlessly.
       expect(process.env.MODERN_ARGV).toBe('node modern build');
+
+      const routerArtifact = fs.readFileSync(
+        path.join(srcDirectory, 'modern-tanstack', 'main', 'router.gen.ts'),
+        'utf-8',
+      );
+      const registerArtifact = fs.readFileSync(
+        path.join(srcDirectory, 'modern-tanstack', 'register.gen.d.ts'),
+        'utf-8',
+      );
+      expect(routerArtifact).toContain('createRootRouteWithContext');
+      expect(routerArtifact).toContain('routeTree');
+      expect(registerArtifact).toContain('./main/router.gen');
     } finally {
       fs.rmSync(appDirectory, { force: true, recursive: true });
       if (previousArgv === undefined) {
@@ -91,7 +131,7 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
     }
   });
 
-  it('throws a clear error (never a boolean path crash) when no config file exists', async () => {
+  it('throws a clear error when no config file exists', async () => {
     const appDirectory = makeAppDir(false);
 
     try {

package/tests/router/hooks.test.ts

@@ -3,13 +3,11 @@ import {
   routerProviderRegistryHooks,
 } from '@modern-js/runtime/context';
 import * as tanstackHooks from '../../src/runtime/hooks';
-import { applyRouterRuntimeState } from '../../src/runtime/lifecycle';
 import { tanstackRouterPlugin as browserPlugin } from '../../src/runtime/plugin';
 import { tanstackRouterPlugin as nodePlugin } from '../../src/runtime/plugin.node';
-import { getTanstackRouterState } from '../../src/runtime/state';
 
 describe('tanstack router hooks single declaration source', () => {
-  test('re-exports the canonical hook instances owned by @modern-js/runtime', () => {
+  test('re-exports and registers the canonical hook instances', () => {
     // Identity matters: separate instances would split the hook registry
     // between the built-in router wrapper and this provider.
     expect(tanstackHooks.modifyRoutes).toBe(canonicalModifyRoutes);
@@ -19,22 +17,7 @@ describe('tanstack router hooks single declaration source', () => {
     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);
   });
 });
-
-describe('tanstack router runtime state accessor', () => {
-  test('returns undefined before a tanstack router instance is created', () => {
-    const context = {};
-
-    applyRouterRuntimeState(context as never, {
-      framework: 'tanstack',
-    });
-
-    expect(getTanstackRouterState(context)).toBeUndefined();
-  });
-});

package/tests/router/loaderBridge.test.ts

@@ -1,8 +1,5 @@
 import { isNotFound, isRedirect } from '@tanstack/react-router';
 import {
-  createRouteStaticData,
-  isAbsoluteUrl,
-  mapSplatParamsForModernLoader,
   modernLoaderToTanstack,
   throwTanstackRedirect,
 } from '../../src/runtime/loaderBridge';
@@ -23,73 +20,6 @@ function catchThrown(fn: () => unknown): unknown {
   throw new Error('expected the function to throw');
 }
 
-describe('throwTanstackRedirect', () => {
-  test('absolute URLs redirect via href (external), not via to', () => {
-    // The old inline codegen handler threw `redirect({ href })` INSIDE a
-    // try block whose catch replaced it with `redirect({ to: absoluteUrl })`,
-    // making TanStack treat the absolute URL as an internal path.
-    const thrown = catchThrown(() =>
-      throwTanstackRedirect('https://example.com/external'),
-    ) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.href).toBe('https://example.com/external');
-    expect(thrown.options?.to).toBeUndefined();
-  });
-
-  test('relative paths redirect via to so the basepath rewrite applies', () => {
-    const thrown = catchThrown(() =>
-      throwTanstackRedirect('/dashboard'),
-    ) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.to).toBe('/dashboard');
-    expect(thrown.options?.href).toBeUndefined();
-  });
-
-  test('empty location falls back to /', () => {
-    const thrown = catchThrown(() => throwTanstackRedirect('')) as RedirectLike;
-    expect(thrown.options?.to).toBe('/');
-  });
-});
-
-describe('isAbsoluteUrl', () => {
-  test('detects absolute and relative URLs', () => {
-    expect(isAbsoluteUrl('https://example.com/a')).toBe(true);
-    expect(isAbsoluteUrl('mailto:x@example.com')).toBe(true);
-    expect(isAbsoluteUrl('/internal/path')).toBe(false);
-    expect(isAbsoluteUrl('relative')).toBe(false);
-  });
-});
-
-describe('mapSplatParamsForModernLoader', () => {
-  test('maps TanStack _splat to React Router * only for splat routes', () => {
-    expect(
-      mapSplatParamsForModernLoader({ _splat: 'a/b', id: '1' }, true),
-    ).toEqual({ '*': 'a/b', id: '1' });
-    expect(
-      mapSplatParamsForModernLoader({ _splat: 'a/b', id: '1' }, false),
-    ).toEqual({ _splat: 'a/b', id: '1' });
-    expect(mapSplatParamsForModernLoader({ id: '1' }, true)).toEqual({
-      id: '1',
-    });
-  });
-});
-
-describe('createRouteStaticData', () => {
-  test('drops empty fields', () => {
-    const loader = () => null;
-    expect(createRouteStaticData({})).toEqual({});
-    expect(createRouteStaticData({ modernRouteId: '' })).toEqual({});
-    expect(
-      createRouteStaticData({
-        modernRouteId: 'page',
-        modernRouteLoader: loader,
-      }),
-    ).toEqual({ modernRouteId: 'page', modernRouteLoader: loader });
-  });
-});
-
 describe('modernLoaderToTanstack', () => {
   const baseCtx = {
     location: { href: 'http://localhost/products/1' },
@@ -189,13 +119,6 @@ describe('modernLoaderToTanstack', () => {
     expect(isNotFound(thrown)).toBe(true);
   });
 
-  test('preserves returned non-404 error Responses as loader results', async () => {
-    const response = new Response('loader exploded', { status: 500 });
-    const loader = modernLoaderToTanstack({ hasSplat: false }, () => response);
-
-    await expect(loader(baseCtx)).resolves.toBe(response);
-  });
-
   test('translates redirect Responses thrown synchronously by the loader', () => {
     const loader = modernLoaderToTanstack({ hasSplat: false }, () => {
       throw new Response(null, {

package/tests/router/prefetchLink.test.tsx

@@ -5,7 +5,7 @@ import {
   createRouter,
   RouterProvider,
 } from '@tanstack/react-router';
-import { render, waitFor } from '@testing-library/react';
+import { act, render, waitFor } from '@testing-library/react';
 import React from 'react';
 import { Link, NavLink } from '../../src/runtime/prefetchLink';
 
@@ -74,7 +74,7 @@ async function renderLink(options: Parameters<typeof buildRouter>[0]) {
     return found as HTMLAnchorElement;
   });
 
-  return { anchor, ...utils };
+  return { anchor, router, ...utils };
 }
 
 describe('tanstack prefetch link adapter - aria-current override', () => {
@@ -100,27 +100,39 @@ describe('tanstack prefetch link adapter - aria-current override', () => {
     expect(anchor.hasAttribute('aria-current')).toBe(false);
   });
 
-  it('leaves an inactive link untouched when caller passes nothing', async () => {
-    const { anchor } = await renderLink({ initialPath: '/' });
-    expect(anchor.hasAttribute('aria-current')).toBe(false);
-    expect(anchor.getAttribute('data-status')).not.toBe('active');
-  });
-
-  it('resolves render-prop children with the active state like TanStack Link', async () => {
-    const { anchor } = await renderLink({
-      initialPath: '/settings',
+  it('updates render-prop children across an inactive-to-active transition', async () => {
+    const { anchor, router } = await renderLink({
+      initialPath: '/',
       children: ({ isActive }: { isActive: boolean }) =>
         isActive ? 'Active settings' : 'Settings',
     });
-    expect(anchor.textContent).toBe('Active settings');
+
+    expect(anchor.textContent).toBe('Settings');
+
+    await act(async () => {
+      await router.navigate({ to: '/settings' });
+    });
+
+    await waitFor(() => expect(anchor.textContent).toBe('Active settings'));
   });
 
-  it('resolves render-prop children as inactive on a non-matching route', async () => {
+  it('passes the native anchor ref through the router hook', async () => {
+    const ref = React.createRef<HTMLAnchorElement>();
     const { anchor } = await renderLink({
       initialPath: '/',
-      children: ({ isActive }: { isActive: boolean }) =>
-        isActive ? 'Active settings' : 'Settings',
+      linkProps: { ref, prefetch: 'none' },
     });
-    expect(anchor.textContent).toBe('Settings');
+    expect(ref.current).toBe(anchor);
+  });
+
+  it('preserves NavLink render children and aria-current overrides', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      useNavLink: true,
+      linkProps: { 'aria-current': 'step', preload: false },
+      children: ({ isActive }) => (isActive ? 'Current step' : 'Other step'),
+    });
+    expect(anchor.textContent).toBe('Current step');
+    expect(anchor.getAttribute('aria-current')).toBe('step');
   });
 });

package/tests/router/prefetchLinkPreload.test.tsx

@@ -27,59 +27,52 @@ describe('tanstack prefetch link adapter - preload mapping', () => {
     mockReturnProps = { href: '/settings' };
   });
 
-  it('defaults TanStack preload to viewport', () => {
-    render(<Link to="/settings">Settings</Link>);
-
-    expect(capturedOptions.map(o => o.preload)).toEqual(['viewport']);
-  });
-
-  it('preserves explicit preload', () => {
+  it.each([
+    { expected: 'intent', preload: 'intent' },
+    { expected: false, preload: false },
+  ])('preserves an explicit $expected preload override', ({
+    expected,
+    preload,
+  }) => {
     render(
-      <Link to="/settings" prefetch="render" preload="intent">
+      <Link to="/settings" prefetch="render" preload={preload}>
         Settings
       </Link>,
     );
 
-    expect(capturedOptions.map(o => o.preload)).toEqual(['intent']);
+    expect(capturedOptions[0]?.preload).toBe(expected);
   });
 
-  it('preserves explicit disabled preload', () => {
+  it('maps none prefetch to disabled TanStack preload', () => {
     render(
-      <Link to="/settings" prefetch="render" preload={false}>
+      <Link to="/settings" prefetch="none">
         Settings
       </Link>,
     );
 
-    expect(capturedOptions.map(o => o.preload)).toEqual([false]);
+    expect(capturedOptions[0]?.preload).toBe(false);
   });
 
-  it('maps none prefetch to disabled TanStack preload', () => {
+  it('forwards a supported prefetch mode to TanStack preload', () => {
     render(
-      <Link to="/settings" prefetch="none">
+      <Link to="/settings" prefetch="intent">
         Settings
       </Link>,
     );
 
-    expect(capturedOptions.map(o => o.preload)).toEqual([false]);
+    expect(capturedOptions[0]?.preload).toBe('intent');
   });
 
   it.each([
-    'intent',
-    'render',
-    'viewport',
-  ] as const)('maps %s prefetch to TanStack preload', prefetch => {
+    Link,
+    NavLink,
+  ])('lets explicit preload re-enable prefetch=none', Component => {
     render(
-      <Link to="/settings" prefetch={prefetch}>
+      <Component to="/settings" prefetch="none" preload="render">
         Settings
-      </Link>,
+      </Component>,
     );
 
-    expect(capturedOptions.map(o => o.preload)).toEqual([prefetch]);
-  });
-
-  it('defaults NavLink preload to viewport', () => {
-    render(<NavLink to="/settings">Settings</NavLink>);
-
-    expect(capturedOptions.map(o => o.preload)).toEqual(['viewport']);
+    expect(capturedOptions.map(o => o.preload)).toEqual(['render']);
   });
 });

package/tests/router/routeHooks.test.ts

@@ -1,113 +1,49 @@
-const calls: Record<string, unknown[]> = {
-  useChildMatches: [],
-  useMatch: [],
-  useMatches: [],
-  useParentMatches: [],
-  useRouterState: [],
-};
-
-rstest.mock('@tanstack/react-router', () => ({
-  useChildMatches: (options: unknown) => {
-    calls.useChildMatches.push(options);
-    return options;
-  },
-  useMatch: (options: unknown) => {
-    calls.useMatch.push(options);
-    return options;
-  },
-  useMatches: (options: unknown) => {
-    calls.useMatches.push(options);
-    return options;
-  },
-  useParentMatches: (options: unknown) => {
-    calls.useParentMatches.push(options);
-    return options;
-  },
-  useRouterState: (options: unknown) => {
-    calls.useRouterState.push(options);
-    return options;
-  },
-}));
-
+import { createMemoryHistory } from '@tanstack/history';
 import {
-  useChildMatches,
-  useMatch,
-  useMatches,
-  useParentMatches,
-  useRouterState,
-} from '../../src/runtime/routeHooks';
-
-const getLastCall = (hookName: keyof typeof calls) => {
-  const callList = calls[hookName];
-  return callList[callList.length - 1];
-};
-
-describe('tanstack route hook structural sharing guards', () => {
-  beforeEach(() => {
-    for (const hookName of Object.keys(calls)) {
-      calls[hookName] = [];
-    }
+  createRootRoute,
+  createRoute,
+  createRouter,
+  RouterProvider,
+} from '@tanstack/react-router';
+import React from 'react';
+import { renderToString } from 'react-dom/server';
+import { useMatches } from '../../src/runtime/routeHooks';
+
+function MatchIds() {
+  const matches = useMatches();
+  return React.createElement(
+    'output',
+    { 'data-testid': 'route-ids' },
+    matches.map(match => match.routeId).join(','),
+  );
+}
+
+test('updates whole match objects after navigation with the structural-sharing guard', async () => {
+  const rootRoute = createRootRoute({ component: MatchIds });
+  const homeRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    component: () => null,
   });
-
-  test('disables structural sharing for full internal router objects', () => {
-    useMatch({ from: '/' } as never);
-    useMatches();
-    useParentMatches();
-    useChildMatches();
-    useRouterState();
-
-    expect(getLastCall('useMatch')).toEqual({
-      from: '/',
-      structuralSharing: false,
-    });
-    expect(getLastCall('useMatches')).toEqual({
-      structuralSharing: false,
-    });
-    expect(getLastCall('useParentMatches')).toEqual({
-      structuralSharing: false,
-    });
-    expect(getLastCall('useChildMatches')).toEqual({
-      structuralSharing: false,
-    });
-    expect(getLastCall('useRouterState')).toEqual({
-      structuralSharing: false,
-    });
+  const settingsRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/settings',
+    component: () => null,
   });
-
-  test('keeps selected data on the router default', () => {
-    const select = (value: unknown) => value;
-    const matchOptions = { from: '/', select };
-    const matchesOptions = { select };
-    const stateOptions = { select };
-
-    useMatch(matchOptions as never);
-    useMatches(matchesOptions as never);
-    useParentMatches(matchesOptions as never);
-    useChildMatches(matchesOptions as never);
-    useRouterState(stateOptions as never);
-
-    expect(getLastCall('useMatch')).toBe(matchOptions);
-    expect(getLastCall('useMatches')).toBe(matchesOptions);
-    expect(getLastCall('useParentMatches')).toBe(matchesOptions);
-    expect(getLastCall('useChildMatches')).toBe(matchesOptions);
-    expect(getLastCall('useRouterState')).toBe(stateOptions);
+  const router = createRouter({
+    routeTree: rootRoute.addChildren([homeRoute, settingsRoute]),
+    history: createMemoryHistory({ initialEntries: ['/'] }),
+    defaultStructuralSharing: true,
   });
 
-  test('honors explicit structural sharing choices', () => {
-    const enabled = { structuralSharing: true };
-    const disabled = { structuralSharing: false };
-    const matchEnabled = { from: '/', structuralSharing: true };
+  await router.load();
+  expect(
+    renderToString(React.createElement(RouterProvider, { router })),
+  ).toContain('__root__');
 
-    useMatch(matchEnabled as never);
-    useMatches(enabled as never);
-    useParentMatches(disabled as never);
-    useChildMatches(enabled as never);
-    useRouterState(disabled as never);
+  await router.navigate({ to: '/settings' });
 
-    expect(getLastCall('useMatch')).toBe(matchEnabled);
-    expect(getLastCall('useMatches')).toBe(enabled);
-    expect(getLastCall('useParentMatches')).toBe(disabled);
-    expect(getLastCall('useChildMatches')).toBe(enabled);
-    expect(getLastCall('useRouterState')).toBe(disabled);
-  });
+  expect(
+    renderToString(React.createElement(RouterProvider, { router })),
+  ).toContain('/settings');
 });