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

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/register.test.ts

@@ -1,4 +1,4 @@
-import { resolveRouterProvider } from '@modern-js/runtime/context';
+import { resolveRouterProvider } from '@modern-js/runtime-extensions/router-provider';
 import '../../src/runtime/register';
 
 describe("'@modern-js/plugin-tanstack/runtime' import side effects", () => {

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');
 });