@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.4 → 3.5.0-ultramodern.41

package/tests/router/generateRouteArtifacts.test.ts

@@ -0,0 +1,106 @@
+// 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.
+const createRunOptionsMock = rstest.fn(async (options: unknown) => ({
+  mockRunOptions: true,
+  received: options,
+}));
+const cliInitMock = rstest.fn(async (options: unknown) => ({
+  appContext: {},
+  received: options,
+}));
+
+rstest.mock('@modern-js/app-tools/cli/run', () => ({
+  createRunOptions: createRunOptionsMock,
+}));
+rstest.mock('@modern-js/plugin/cli', () => ({
+  cli: { init: cliInitMock },
+}));
+
+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';
+
+function makeAppDir(withConfig: boolean): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'tanstack-routes-gen-'));
+  if (withConfig) {
+    fs.writeFileSync(
+      path.join(dir, 'modern.config.ts'),
+      'export default {};\n',
+      'utf-8',
+    );
+  }
+  return dir;
+}
+
+describe('generateTanstackRouteArtifacts (headless routes-generate)', () => {
+  beforeEach(() => {
+    createRunOptionsMock.mockClear();
+    cliInitMock.mockClear();
+  });
+
+  it('drives a prepare-only cli.init with build-command semantics', async () => {
+    const previousArgv = process.env.MODERN_ARGV;
+    const appDirectory = makeAppDir(true);
+
+    try {
+      await generateTanstackRouteArtifacts({
+        appDirectory,
+        version: '9.9.9-test',
+      });
+
+      expect(createRunOptionsMock).toHaveBeenCalledTimes(1);
+      const runOptionsArg = createRunOptionsMock.mock.calls[0][0] as Record<
+        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(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');
+    } finally {
+      fs.rmSync(appDirectory, { force: true, recursive: true });
+      if (previousArgv === undefined) {
+        delete process.env.MODERN_ARGV;
+      } else {
+        process.env.MODERN_ARGV = previousArgv;
+      }
+    }
+  });
+
+  it('throws a clear error (never a boolean path crash) when no config file exists', async () => {
+    const appDirectory = makeAppDir(false);
+
+    try {
+      await expect(
+        generateTanstackRouteArtifacts({ appDirectory }),
+      ).rejects.toThrow(/Unable to locate a Modern\.js config file/u);
+      expect(createRunOptionsMock).not.toHaveBeenCalled();
+    } finally {
+      fs.rmSync(appDirectory, { force: true, recursive: true });
+    }
+  });
+});

package/tests/router/hooks.test.ts

@@ -3,8 +3,10 @@ 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', () => {
@@ -24,3 +26,15 @@ describe('tanstack router hooks single declaration source', () => {
     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

@@ -117,6 +117,27 @@ describe('modernLoaderToTanstack', () => {
     expect(seen.context).toEqual({ user: 'u1' });
   });
 
+  test('uses current location when context carries a previous request', async () => {
+    const seen: { request?: Request } = {};
+    const loader = modernLoaderToTanstack({ hasSplat: false }, (args: any) => {
+      seen.request = args.request;
+      return { ok: true };
+    });
+
+    await expect(
+      loader({
+        ...baseCtx,
+        location: { href: 'http://localhost/products/2?sort=price' },
+        context: {
+          request: new Request('http://localhost/products/1?sort=name'),
+        },
+      }),
+    ).resolves.toEqual({ ok: true });
+
+    expect(seen.request).toBeInstanceOf(Request);
+    expect(seen.request?.url).toBe('http://localhost/products/2?sort=price');
+  });
+
   test('translates an absolute-URL redirect Response into redirect({ href })', async () => {
     const loader = modernLoaderToTanstack({ hasSplat: false }, () =>
       Response.redirect('https://example.com/away', 302),

package/tests/router/prefetchLink.test.tsx

@@ -1,79 +1,126 @@
-import { render } from '@testing-library/react';
+import { createMemoryHistory } from '@tanstack/history';
+import {
+  createRootRoute,
+  createRoute,
+  createRouter,
+  RouterProvider,
+} from '@tanstack/react-router';
+import { render, waitFor } from '@testing-library/react';
 import React from 'react';
 import { Link, NavLink } from '../../src/runtime/prefetchLink';
 
-type MockLinkProps = {
-  children?: React.ReactNode;
-  preload?: unknown;
-};
-
-let capturedPreloads: unknown[] = [];
-
-rstest.mock('@tanstack/react-router', () => ({
-  Link: (props: MockLinkProps) => {
-    capturedPreloads.push(props.preload);
-    return <a href="/settings">{props.children}</a>;
-  },
-}));
-
-describe('tanstack prefetch link adapter', () => {
-  beforeEach(() => {
-    capturedPreloads = [];
+// Real-router harness (no module mocking): STATIC_ACTIVE_PROPS (the
+// TanStack behavior this adapter works around) is injected by
+// useLinkProps() based on live route match state, which a mocked
+// useLinkProps() cannot reproduce faithfully. We tried spying on
+// useLinkProps via rstest.mock()+importActual while re-exporting the rest
+// of the module untouched, but rstest's module-mock hoisting resolves the
+// "actual" import for a module through its own in-progress mock
+// registration, so every named export (createRootRoute included) comes
+// back undefined -- see the sibling prefetchLinkPreload.test.tsx file for
+// the fully-mocked preload-mapping coverage instead. This file renders
+// through an actual createRouter()/RouterProvider tree with in-memory
+// history so the active/inactive aria-current behavior is exercised for
+// real.
+function buildRouter(options: {
+  initialPath: string;
+  linkProps?: Record<string, unknown>;
+  useNavLink?: boolean;
+  children?:
+    | React.ReactNode
+    | ((state: { isActive: boolean }) => React.ReactNode);
+}) {
+  // The Link lives on the always-rendered root component (not a route
+  // that's only matched at "/settings") so the "inactive link" case -
+  // sitting at "/" while linking to "/settings" - actually mounts it.
+  const rootRoute = createRootRoute({
+    component: () => {
+      const Component = options.useNavLink ? NavLink : Link;
+      return (
+        <Component to="/settings" {...(options.linkProps ?? {})}>
+          {options.children ?? 'Settings'}
+        </Component>
+      );
+    },
   });
-
-  it('defaults TanStack preload to viewport', () => {
-    render(<Link to="/settings">Settings</Link>);
-
-    expect(capturedPreloads).toEqual(['viewport']);
+  const homeRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/',
+    component: () => null,
+  });
+  const settingsRoute = createRoute({
+    getParentRoute: () => rootRoute,
+    path: '/settings',
+    component: () => null,
   });
 
-  it('preserves explicit preload', () => {
-    render(
-      <Link to="/settings" prefetch="render" preload="intent">
-        Settings
-      </Link>,
-    );
+  const routeTree = rootRoute.addChildren([homeRoute, settingsRoute]);
 
-    expect(capturedPreloads).toEqual(['intent']);
+  return createRouter({
+    routeTree,
+    history: createMemoryHistory({ initialEntries: [options.initialPath] }),
+  });
+}
+
+async function renderLink(options: Parameters<typeof buildRouter>[0]) {
+  const router = buildRouter(options);
+  const utils = render(<RouterProvider router={router} />);
+
+  const anchor = await waitFor(() => {
+    const found = utils.container.querySelector('a[href="/settings"]');
+    if (!found) {
+      throw new Error('anchor not rendered yet');
+    }
+    return found as HTMLAnchorElement;
   });
 
-  it('preserves explicit disabled preload', () => {
-    render(
-      <Link to="/settings" prefetch="render" preload={false}>
-        Settings
-      </Link>,
-    );
+  return { anchor, ...utils };
+}
 
-    expect(capturedPreloads).toEqual([false]);
+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('maps none prefetch to disabled TanStack preload', () => {
-    render(
-      <Link to="/settings" prefetch="none">
-        Settings
-      </Link>,
-    );
-
-    expect(capturedPreloads).toEqual([false]);
+  it('lets caller aria-current="true" win over the TanStack-forced value', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      linkProps: { 'aria-current': 'true' },
+    });
+    expect(anchor.getAttribute('aria-current')).toBe('true');
+    expect(anchor.outerHTML.match(/aria-current=/g)).toHaveLength(1);
   });
 
-  it.each([
-    'intent',
-    'render',
-    'viewport',
-  ] as const)('maps %s prefetch to TanStack preload', prefetch => {
-    render(
-      <Link to="/settings" prefetch={prefetch}>
-        Settings
-      </Link>,
-    );
+  it('suppresses aria-current entirely when caller passes false', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      linkProps: { 'aria-current': false },
+    });
+    expect(anchor.hasAttribute('aria-current')).toBe(false);
+  });
 
-    expect(capturedPreloads).toEqual([prefetch]);
+  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('defaults NavLink preload to viewport', () => {
-    render(<NavLink to="/settings">Settings</NavLink>);
+  it('resolves render-prop children with the active state like TanStack Link', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/settings',
+      children: ({ isActive }: { isActive: boolean }) =>
+        isActive ? 'Active settings' : 'Settings',
+    });
+    expect(anchor.textContent).toBe('Active settings');
+  });
 
-    expect(capturedPreloads).toEqual(['viewport']);
+  it('resolves render-prop children as inactive on a non-matching route', async () => {
+    const { anchor } = await renderLink({
+      initialPath: '/',
+      children: ({ isActive }: { isActive: boolean }) =>
+        isActive ? 'Active settings' : 'Settings',
+    });
+    expect(anchor.textContent).toBe('Settings');
   });
 });

package/tests/router/prefetchLinkPreload.test.tsx

@@ -0,0 +1,85 @@
+import { render } from '@testing-library/react';
+import React from 'react';
+import { Link, NavLink } from '../../src/runtime/prefetchLink';
+
+type CapturedOptions = {
+  preload?: unknown;
+};
+
+type MockLinkAnchorProps = Record<string, unknown> & {
+  href?: string;
+  ref?: unknown;
+};
+
+let capturedOptions: CapturedOptions[] = [];
+let mockReturnProps: MockLinkAnchorProps = { href: '/settings' };
+
+rstest.mock('@tanstack/react-router', () => ({
+  useLinkProps: (options: CapturedOptions) => {
+    capturedOptions.push(options);
+    return mockReturnProps;
+  },
+}));
+
+describe('tanstack prefetch link adapter - preload mapping', () => {
+  beforeEach(() => {
+    capturedOptions = [];
+    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', () => {
+    render(
+      <Link to="/settings" prefetch="render" preload="intent">
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual(['intent']);
+  });
+
+  it('preserves explicit disabled preload', () => {
+    render(
+      <Link to="/settings" prefetch="render" preload={false}>
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual([false]);
+  });
+
+  it('maps none prefetch to disabled TanStack preload', () => {
+    render(
+      <Link to="/settings" prefetch="none">
+        Settings
+      </Link>,
+    );
+
+    expect(capturedOptions.map(o => o.preload)).toEqual([false]);
+  });
+
+  it.each([
+    'intent',
+    'render',
+    'viewport',
+  ] as const)('maps %s prefetch to TanStack preload', prefetch => {
+    render(
+      <Link to="/settings" prefetch={prefetch}>
+        Settings
+      </Link>,
+    );
+
+    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']);
+  });
+});

package/tests/router/register.test.ts

@@ -1,46 +1,8 @@
 import { resolveRouterProvider } from '@modern-js/runtime/context';
-import {
-  Form,
-  Link,
-  NavLink,
-  Outlet,
-  RouteActionResponseError,
-  useFetcher,
-} from '../../src/runtime';
-import { tanstackRouterCompatBindings } from '../../src/runtime/register';
-
-const COMPAT_BINDINGS_SLOT = Symbol.for(
-  '@modern-js/plugin-tanstack:runtime-compat-bindings',
-);
+import '../../src/runtime/register';
 
 describe("'@modern-js/plugin-tanstack/runtime' import side effects", () => {
   it('registers the tanstack router provider', () => {
     expect(typeof resolveRouterProvider('tanstack')).toBe('function');
   });
-
-  it("publishes the compat bindings consumed by '@modern-js/runtime/tanstack-router'", () => {
-    const bindings = (globalThis as Record<symbol, unknown>)[
-      COMPAT_BINDINGS_SLOT
-    ] as typeof tanstackRouterCompatBindings;
-
-    expect(bindings).toBeDefined();
-    expect(bindings).toBe(tanstackRouterCompatBindings);
-    expect(bindings.Form).toBe(Form);
-    expect(bindings.Link).toBe(Link);
-    expect(bindings.NavLink).toBe(NavLink);
-    expect(bindings.Outlet).toBe(Outlet);
-    expect(bindings.RouteActionResponseError).toBe(RouteActionResponseError);
-    expect(bindings.useFetcher).toBe(useFetcher);
-  });
-
-  it('keeps the first published bindings when a duplicate module copy evaluates', () => {
-    // Simulates a Module Federation remote evaluating its own copy of
-    // register.ts: `??=` must keep the established bindings.
-    const host = globalThis as Record<symbol, unknown>;
-    const established = host[COMPAT_BINDINGS_SLOT];
-    expect(established).toBeDefined();
-
-    host[COMPAT_BINDINGS_SLOT] ??= { duplicate: true };
-    expect(host[COMPAT_BINDINGS_SLOT]).toBe(established);
-  });
 });

package/tests/router/routeTree.test.ts

@@ -15,7 +15,7 @@ import {
   getModernRouteIdsFromMatches,
 } from '../../src/runtime/routeTree';
 import { __setTanstackRscPayloadDecoderForTests } from '../../src/runtime/rsc/payloadRouter';
-import { createRouteObjectsFromConfig } from '../../src/runtime/utils';
+import { createTanstackRouteObjectsFromConfig } from '../../src/runtime/utils';
 
 type LoaderArgs = {
   params: Record<string, string>;
@@ -151,15 +151,15 @@ describe('tanstack runtime public exports', () => {
     };
 
     expect(packageJson.exports['./runtime/rsc']).toBeUndefined();
-    expect(packageJson.exports['./runtime/rsc/client']).toBeUndefined();
-    expect(packageJson.exports['./runtime/rsc/server']).toBeUndefined();
+    expect(packageJson.exports['./runtime/rsc/client']).toBeDefined();
+    expect(packageJson.exports['./runtime/rsc/server']).toBeDefined();
     expect(packageJson.typesVersions?.['*']?.['runtime/rsc']).toBeUndefined();
-    expect(
-      packageJson.typesVersions?.['*']?.['runtime/rsc/client'],
-    ).toBeUndefined();
-    expect(
-      packageJson.typesVersions?.['*']?.['runtime/rsc/server'],
-    ).toBeUndefined();
+    expect(packageJson.typesVersions?.['*']?.['runtime/rsc/client']).toEqual([
+      './dist/types/runtime/rsc/client.d.ts',
+    ]);
+    expect(packageJson.typesVersions?.['*']?.['runtime/rsc/server']).toEqual([
+      './dist/types/runtime/rsc/server.d.ts',
+    ]);
   });
 });
 
@@ -201,6 +201,41 @@ describe('tanstack route tree from RouteObject[]', () => {
     expect(userMatch?.loaderData).toEqual({ id: '123' });
   });
 
+  test('keeps unnamed sibling pathless layouts distinct', async () => {
+    const routes: RouteObject[] = [
+      {
+        Component: () => null,
+        children: [
+          {
+            path: 'alpha',
+            loader: () => ({ value: 'alpha' }),
+            Component: () => null,
+          },
+        ],
+      },
+      {
+        Component: () => null,
+        children: [
+          {
+            path: 'beta',
+            loader: () => ({ value: 'beta' }),
+            Component: () => null,
+          },
+        ],
+      },
+    ];
+
+    const routeTree = createRouteTreeFromRouteObjects(routes);
+    const router = await loadRouteTree(routeTree, '/beta');
+
+    const matchedLoaderData = router.state.matches
+      .map(match => match.loaderData)
+      .filter(Boolean);
+
+    expect(matchedLoaderData).toContainEqual({ value: 'beta' });
+    expect(matchedLoaderData).not.toContainEqual({ value: 'alpha' });
+  });
+
   test('reports native TanStack unknown routes as HTTP 404', async () => {
     const routes: RouteObject[] = [
       {
@@ -774,13 +809,16 @@ describe('tanstack route tree from RouteObject[]', () => {
             path: 'client',
             clientData: './client.data',
             data: './data',
+            hasAction: true,
+            hasClientLoader: true,
+            hasLoader: true,
             inValidSSRRoute: true,
             isClientComponent: true,
           },
         ],
       },
     ];
-    const routeObjects = createRouteObjectsFromConfig({
+    const routeObjects = createTanstackRouteObjectsFromConfig({
       routesConfig: { routes: modernRoutes },
     });
     const routeTree = createRouteTreeFromRouteObjects(routeObjects || []);
@@ -795,7 +833,9 @@ describe('tanstack route tree from RouteObject[]', () => {
 
     expect(clientRoute.options.ssr).toBe(false);
     expect(clientRoute.options.staticData).toMatchObject({
+      modernRouteHasAction: true,
       modernRouteHasClientLoader: true,
+      modernRouteHasLoader: true,
       modernRouteIsClientComponent: true,
     });
   });
@@ -825,7 +865,7 @@ describe('tanstack route tree from RouteObject[]', () => {
       },
     ];
 
-    const routeObjects = createRouteObjectsFromConfig({
+    const routeObjects = createTanstackRouteObjectsFromConfig({
       routesConfig: { routes: modernRoutes },
     });
     const rootRoute = routeObjects?.[0];