@bleedingdev/modern-js-plugin-tanstack 3.5.0-ultramodern.9 → 3.5.0-ultramodern.91

package/tests/router/fixtures/router-gen.golden.txt

@@ -0,0 +1,71 @@
+// This file is auto-generated by Modern.js. Do not edit manually.
+
+import {
+  createMemoryHistory,
+  createRootRouteWithContext,
+  createRoute,
+  createRouter,
+  createRouteStaticData,
+  type ModernRouterContext,
+  modernLoaderToTanstack,
+  modernTanstackRouterFastDefaults,
+} from '@modern-js/plugin-tanstack/runtime';
+
+import component_0 from "../../routes/(app)/layout";
+import { loader as loader_0, action as action_0 } from "../../routes/(app)/users/(userId)/page.data";
+import { validateSearch as validateSearch_0 } from "../../routes/search.contract";
+import { loaderDeps as loaderDeps_0 } from "../../routes/search.contract";
+import component_1 from "../../routes/(app)/users/(userId)/page";
+import component_2 from "../../routes/(app)/docs/splat";
+
+export const rootRoute = createRootRouteWithContext<ModernRouterContext>()({
+  
+  staticData: createRouteStaticData({
+    modernRouteId: "layout",
+  }),
+});
+
+const route__app__layout__base = createRoute({
+  getParentRoute: () => rootRoute,
+  component: component_0,
+  id: "(app)/layout",
+  staticData: createRouteStaticData({
+    modernRouteId: "(app)/layout",
+  }),
+});
+
+const route__app__users__userId__page = createRoute({
+  getParentRoute: () => route__app__layout__base,
+  component: component_1,
+  path: "users/$userId",
+  loader: modernLoaderToTanstack({ hasSplat: false }, loader_0),
+  validateSearch: validateSearch_0,
+  loaderDeps: loaderDeps_0,
+  staticData: createRouteStaticData({
+    modernRouteId: "(app)/users/(userId)/page",
+    modernRouteLoader: loader_0,
+    modernRouteAction: action_0,
+  }),
+});
+
+const route__app__docs_splat_page = createRoute({
+  getParentRoute: () => route__app__layout__base,
+  component: component_2,
+  path: "docs/$",
+  staticData: createRouteStaticData({
+    modernRouteId: "(app)/docs/splat/page",
+  }),
+});
+
+const route__app__layout = route__app__layout__base.addChildren([route__app__users__userId__page, route__app__docs_splat_page]);
+
+export const routeTree = rootRoute.addChildren([route__app__layout]);
+
+export const router = createRouter({
+  ...modernTanstackRouterFastDefaults,
+  routeTree,
+  history: createMemoryHistory({
+    initialEntries: ['/'],
+  }),
+  context: {} as ModernRouterContext,
+});

package/tests/router/fixtures/router-gen.oxlint.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-unused-vars": "error"
+  }
+}

package/tests/router/flightSerialization.roundtrip.test.tsx

@@ -0,0 +1,137 @@
+import type React from 'react';
+import { isValidElement } from 'react';
+import { createRscProxy } from '../../src/runtime/rsc/createRscProxy';
+import {
+  reviveTanstackRscFlightValues,
+  serializeTanstackRscFlightValues,
+} from '../../src/runtime/rsc/flightSerialization';
+import {
+  RENDERABLE_RSC,
+  SERVER_COMPONENT_STREAM,
+  type ServerComponentStream,
+} from '../../src/runtime/rsc/symbols';
+
+type RoundTripFixture = {
+  bigintValue: bigint;
+  booleanValue: boolean;
+  circular: Record<string, unknown>;
+  dateValue: Date;
+  falseValue: boolean;
+  mapValue: Map<unknown, unknown>;
+  nested: {
+    array: unknown[];
+    object: {
+      child: unknown;
+    };
+  };
+  nullValue: null;
+  numberValue: number;
+  rscProxy: React.ReactElement & Record<PropertyKey, unknown>;
+  setValue: Set<unknown>;
+  sharedA: Record<string, unknown>;
+  sharedB: Record<string, unknown>;
+  stringValue: string;
+  undefinedValue: undefined;
+};
+
+function createStream(): ServerComponentStream {
+  return {
+    createReplayStream: () => new ReadableStream<Uint8Array>(),
+  };
+}
+
+test('round-trips TanStack RSC flight values across supported value types', async () => {
+  const shared = { marker: 'shared' };
+  const circular: Record<string, unknown> = { marker: 'circular' };
+  circular.self = circular;
+
+  const mapValue = new Map<unknown, unknown>([
+    ['primitive', 1],
+    ['shared', shared],
+    [shared, circular],
+  ]);
+  mapValue.set('self', mapValue);
+
+  const setValue = new Set<unknown>(['set-item', shared, circular]);
+  setValue.add(setValue);
+
+  const rscProxy = createRscProxy(() => ({ slot: 'server' }), {
+    renderable: true,
+    stream: createStream(),
+  }) as React.ReactElement & Record<PropertyKey, unknown>;
+
+  const fixture: RoundTripFixture = {
+    bigintValue: 9007199254740993n,
+    booleanValue: true,
+    circular,
+    dateValue: new Date('2026-07-08T12:34:56.789Z'),
+    falseValue: false,
+    mapValue,
+    nested: {
+      array: [shared, [null, undefined, 7n]],
+      object: {
+        child: shared,
+      },
+    },
+    nullValue: null,
+    numberValue: 42,
+    rscProxy,
+    setValue,
+    sharedA: shared,
+    sharedB: shared,
+    stringValue: 'flight',
+    undefinedValue: undefined,
+  };
+
+  const serialized = serializeTanstackRscFlightValues(
+    fixture,
+  ) as RoundTripFixture;
+  const revived = (await reviveTanstackRscFlightValues(
+    serialized,
+  )) as RoundTripFixture;
+
+  expect(revived).not.toBe(fixture);
+  expect(revived.stringValue).toBe('flight');
+  expect(revived.numberValue).toBe(42);
+  expect(revived.booleanValue).toBe(true);
+  expect(revived.falseValue).toBe(false);
+  expect(revived.nullValue).toBeNull();
+  expect(Object.hasOwn(revived, 'undefinedValue')).toBe(true);
+  expect(revived.undefinedValue).toBeUndefined();
+  expect(revived.bigintValue).toBe(9007199254740993n);
+  expect(revived.dateValue).toBeInstanceOf(Date);
+  expect(revived.dateValue.toISOString()).toBe('2026-07-08T12:34:56.789Z');
+
+  expect(revived.nested.array[0]).toBe(revived.sharedA);
+  expect(revived.nested.object.child).toBe(revived.sharedA);
+  expect(revived.sharedB).toBe(revived.sharedA);
+
+  expect(revived.circular).not.toBe(circular);
+  expect(revived.circular.self).toBe(revived.circular);
+
+  expect(revived.mapValue).toBeInstanceOf(Map);
+  expect(revived.mapValue).not.toBe(mapValue);
+  expect(revived.mapValue.get('primitive')).toBe(1);
+  expect(revived.mapValue.get('shared')).toBe(revived.sharedA);
+  expect(revived.mapValue.get(revived.sharedA)).toBe(revived.circular);
+  expect(revived.mapValue.get('self')).toBe(revived.mapValue);
+
+  expect(revived.setValue).toBeInstanceOf(Set);
+  expect(revived.setValue).not.toBe(setValue);
+  expect(revived.setValue.has('set-item')).toBe(true);
+  expect(revived.setValue.has(revived.sharedA)).toBe(true);
+  expect(revived.setValue.has(revived.circular)).toBe(true);
+  expect(revived.setValue.has(revived.setValue)).toBe(true);
+
+  expect(serialized.rscProxy).not.toBe(rscProxy);
+  expect(serialized.rscProxy).toMatchObject({
+    __modernTanstackRsc: true,
+    kind: 'renderable',
+  });
+  expect(serialized.rscProxy.stream).toBeInstanceOf(ReadableStream);
+
+  expect(revived.rscProxy).not.toBe(rscProxy);
+  expect(isValidElement(revived.rscProxy)).toBe(true);
+  expect(revived.rscProxy[RENDERABLE_RSC]).toBe(true);
+  expect(revived.rscProxy[SERVER_COMPONENT_STREAM]).toBeDefined();
+});

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