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

package/tests/router/dataMutation.test.tsx

@@ -169,6 +169,42 @@ describe('tanstack data mutation fetcher', () => {
     expect(states).toEqual(['idle', 'submitting', 'loading', 'idle']);
   });
 
+  test('passes built href and matched route params to mutation actions', async () => {
+    const action = rstest.fn(
+      async ({ request, params }: Parameters<RouteHandler>[0]) => ({
+        params,
+        requestUrl: request.url,
+      }),
+    );
+    currentRouter = createRouter({
+      action,
+      params: { userId: '42' },
+    });
+
+    render(<FetcherHarness />);
+
+    await act(async () => {
+      await latestFetcher!.submit(
+        { amount: 2 },
+        {
+          method: 'post',
+          action: '/users/42?tab=edit#details',
+        },
+      );
+    });
+
+    expect(action).toHaveBeenCalledTimes(1);
+    const actionArgs = action.mock.calls[0][0];
+    const expectedRequestUrl = `${window.location.origin}/users/42?tab=edit#details`;
+    expect(actionArgs.params).toEqual({ userId: '42' });
+    expect(actionArgs.request.url).toBe(expectedRequestUrl);
+    expect(latestFetcher?.data).toEqual({
+      params: { userId: '42' },
+      requestUrl: expectedRequestUrl,
+    });
+    expect(currentRouter.invalidate).toHaveBeenCalledTimes(1);
+  });
+
   test('surfaces non-2xx action responses as fetcher errors', async () => {
     const actionResult = createDeferred<Response>();
     currentRouter = createRouter({

package/tests/router/generateRouteArtifacts.test.ts

@@ -102,24 +102,24 @@ describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
         string,
         unknown
       >;
-      expect(runOptionsArg).toEqual(runOptions);
+      // The headless entry must resolve cwd/configFile from the target app
+      // directory, not the process's own cwd — that was the actual bug.
+      expect(runOptionsArg.cwd).toBe(appDirectory);
+      expect(runOptionsArg.configFile).toBe(
+        path.resolve(appDirectory, 'modern.config'),
+      );
 
       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);
-      expect(process.env.MODERN_ARGV).toBe('node modern build');
 
-      const routerArtifact = fs.readFileSync(
-        path.join(srcDirectory, 'modern-tanstack', 'main', 'router.gen.ts'),
-        'utf-8',
-      );
+      expect(
+        fs.existsSync(
+          path.join(srcDirectory, 'modern-tanstack', 'main', 'router.gen.ts'),
+        ),
+      ).toBe(true);
       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 });

package/tests/router/loaderBridge.test.ts

@@ -1,5 +1,6 @@
 import { isNotFound, isRedirect } from '@tanstack/react-router';
 import {
+  mapSplatParamsForModernLoader,
   modernLoaderToTanstack,
   throwTanstackRedirect,
 } from '../../src/runtime/loaderBridge';
@@ -20,6 +21,50 @@ 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('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('modernLoaderToTanstack', () => {
   const baseCtx = {
     location: { href: 'http://localhost/products/1' },
@@ -119,6 +164,13 @@ 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

@@ -78,11 +78,6 @@ async function renderLink(options: Parameters<typeof buildRouter>[0]) {
 }
 
 describe('tanstack prefetch link adapter - aria-current override', () => {
-  it('defaults active link to aria-current="page" when caller passes nothing', async () => {
-    const { anchor } = await renderLink({ initialPath: '/settings' });
-    expect(anchor.getAttribute('aria-current')).toBe('page');
-  });
-
   it('lets caller aria-current="true" win over the TanStack-forced value', async () => {
     const { anchor } = await renderLink({
       initialPath: '/settings',
@@ -124,15 +119,4 @@ describe('tanstack prefetch link adapter - aria-current override', () => {
     });
     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

@@ -1,6 +1,6 @@
 import { render } from '@testing-library/react';
 import React from 'react';
-import { Link, NavLink } from '../../src/runtime/prefetchLink';
+import { Link } from '../../src/runtime/prefetchLink';
 
 type CapturedOptions = {
   preload?: unknown;
@@ -27,20 +27,20 @@ describe('tanstack prefetch link adapter - preload mapping', () => {
     mockReturnProps = { href: '/settings' };
   });
 
-  it.each([
-    { expected: 'intent', preload: 'intent' },
-    { expected: false, preload: false },
-  ])('preserves an explicit $expected preload override', ({
-    expected,
-    preload,
-  }) => {
+  it('preserves an explicit false preload override', () => {
     render(
-      <Link to="/settings" prefetch="render" preload={preload}>
+      <Link to="/settings" prefetch="render" preload={false}>
         Settings
       </Link>,
     );
 
-    expect(capturedOptions[0]?.preload).toBe(expected);
+    expect(capturedOptions[0]?.preload).toBe(false);
+  });
+
+  it('defaults to viewport preload when no prefetch is given', () => {
+    render(<Link to="/settings">Settings</Link>);
+
+    expect(capturedOptions[0]?.preload).toBe('viewport');
   });
 
   it('maps none prefetch to disabled TanStack preload', () => {
@@ -53,26 +53,13 @@ describe('tanstack prefetch link adapter - preload mapping', () => {
     expect(capturedOptions[0]?.preload).toBe(false);
   });
 
-  it('forwards a supported prefetch mode to TanStack preload', () => {
+  it('lets explicit preload re-enable prefetch=none', () => {
     render(
-      <Link to="/settings" prefetch="intent">
+      <Link to="/settings" prefetch="none" preload="render">
         Settings
       </Link>,
     );
 
-    expect(capturedOptions[0]?.preload).toBe('intent');
-  });
-
-  it.each([
-    Link,
-    NavLink,
-  ])('lets explicit preload re-enable prefetch=none', Component => {
-    render(
-      <Component to="/settings" prefetch="none" preload="render">
-        Settings
-      </Component>,
-    );
-
     expect(capturedOptions.map(o => o.preload)).toEqual(['render']);
   });
 });