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

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];

package/tests/router/routerCompatibility.test.ts

@@ -0,0 +1,245 @@
+import { execFileSync } from 'node:child_process';
+import {
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+const REGISTRY_SLOT: unique symbol = Symbol.for(
+  '@modern-js/runtime:router-providers:v3',
+);
+const registryHost = globalThis as { [REGISTRY_SLOT]?: unknown };
+const webpackHost = globalThis as typeof globalThis & {
+  __webpack_require__?: { u: (chunkId: unknown) => string };
+};
+const installWebpackRequire = () => {
+  webpackHost.__webpack_require__ = { u: chunkId => String(chunkId) };
+};
+
+type LegacyRuntimeRouterModule = {
+  getLegacyRouterPluginInvocationCount: () => number;
+  routerPlugin: (...args: unknown[]) => unknown;
+};
+
+type CompatibilityGraph = {
+  factory: (...args: any[]) => any;
+  legacyRuntimeRouter: LegacyRuntimeRouterModule;
+  resolveRouterProvider: (
+    framework?: string,
+  ) => (...args: unknown[]) => unknown;
+  routerPlugin: (...args: any[]) => any;
+};
+
+async function loadCompatibilityGraph(): Promise<CompatibilityGraph> {
+  rstest.resetModules();
+  installWebpackRequire();
+
+  const legacyRuntimeRouter = (await import(
+    '@modern-js/runtime/router/internal'
+  )) as unknown as LegacyRuntimeRouterModule;
+  const { routerPlugin } = await import('../../src/runtime/router');
+  const { tanstackRouterProviderFactory } = await import(
+    '../../src/runtime/register'
+  );
+  const { resolveRouterProvider } = await import('@modern-js/runtime/context');
+
+  return {
+    factory: tanstackRouterProviderFactory,
+    legacyRuntimeRouter,
+    resolveRouterProvider,
+    routerPlugin,
+  };
+}
+
+function resolveTsgoBin(): string {
+  const packageJsonPath = require.resolve(
+    '@typescript/native-preview/package.json',
+  );
+  const packageDirectory = path.dirname(packageJsonPath);
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as {
+    bin?: string | { tsgo?: string };
+  };
+  const binEntry =
+    typeof packageJson.bin === 'string'
+      ? packageJson.bin
+      : packageJson.bin?.tsgo;
+
+  return path.resolve(packageDirectory, binEntry ?? 'bin/tsgo.js');
+}
+
+function runTsgo(tsgoBin: string, configPath: string): void {
+  try {
+    execFileSync(process.execPath, [tsgoBin, '-p', configPath], {
+      stdio: 'pipe',
+    });
+  } catch (error) {
+    const result = error as { stderr?: Buffer; stdout?: Buffer };
+    throw new Error(
+      `TS-Go compatibility check failed:\n${String(result.stdout ?? '')}${String(
+        result.stderr ?? '',
+      )}`,
+    );
+  }
+}
+
+installWebpackRequire();
+
+describe('runtime router compatibility', () => {
+  beforeEach(() => {
+    delete registryHost[REGISTRY_SLOT];
+    rstest.resetModules();
+    installWebpackRequire();
+  });
+
+  afterEach(() => {
+    delete registryHost[REGISTRY_SLOT];
+  });
+
+  it('uses the app-local factory instead of the legacy global wrapper', async () => {
+    const graph = await loadCompatibilityGraph();
+
+    expect('createRouterPlugin' in graph.legacyRuntimeRouter).toBe(false);
+    expect(graph.routerPlugin).toBe(graph.factory);
+    expect(graph.routerPlugin({ framework: 'tanstack' })).toMatchObject({
+      name: '@modern-js/plugin-router-tanstack',
+    });
+    expect(
+      graph.legacyRuntimeRouter.getLegacyRouterPluginInvocationCount(),
+    ).toBe(0);
+  });
+
+  it('keeps independently evaluated legacy module graphs app-local', async () => {
+    const graphA = await loadCompatibilityGraph();
+    const graphB = await loadCompatibilityGraph();
+
+    expect(graphB.factory).not.toBe(graphA.factory);
+    expect(graphB.routerPlugin).toBe(graphB.factory);
+    expect(graphB.resolveRouterProvider('tanstack')).toBe(graphA.factory);
+    expect(graphB.routerPlugin({ framework: 'tanstack' })).toMatchObject({
+      name: '@modern-js/plugin-router-tanstack',
+    });
+    expect(
+      graphA.legacyRuntimeRouter.getLegacyRouterPluginInvocationCount(),
+    ).toBe(0);
+    expect(
+      graphB.legacyRuntimeRouter.getLegacyRouterPluginInvocationCount(),
+    ).toBe(0);
+  });
+
+  it('emits declarations compatible with the oldest runtime router shape', () => {
+    const packageRoot = path.resolve(__dirname, '../..');
+    const sourcePath = path.join(packageRoot, 'src/runtime/router.ts');
+    const legacyFixturePath = path.join(
+      __dirname,
+      'fixtures/legacyRuntimeRouter.ts',
+    );
+    const tempRoot = mkdtempSync(
+      path.join(tmpdir(), 'plugin-tanstack-router-compatibility-'),
+    );
+    const sourceRoot = path.join(tempRoot, 'src');
+    const emittedRoot = path.join(tempRoot, 'types');
+    const tsgoBin = resolveTsgoBin();
+
+    try {
+      mkdirSync(sourceRoot, { recursive: true });
+      writeFileSync(
+        path.join(sourceRoot, 'router.ts'),
+        readFileSync(sourcePath, 'utf8'),
+      );
+      writeFileSync(
+        path.join(sourceRoot, 'register.ts'),
+        [
+          'export declare const tanstackRouterProviderFactory:',
+          '  (userConfig?: Record<string, unknown>) => { name?: string };',
+        ].join('\n'),
+      );
+      writeFileSync(
+        path.join(tempRoot, 'currentRuntimeRouter.d.ts'),
+        [
+          'export type RouterPluginFactory =',
+          '  (userConfig?: Record<string, unknown>) => { name?: string };',
+          'export declare const routerPlugin: RouterPluginFactory;',
+          'export declare const createRouterPlugin:',
+          '  (providers: readonly unknown[]) => RouterPluginFactory;',
+        ].join('\n'),
+      );
+      writeFileSync(
+        path.join(tempRoot, 'emit.json'),
+        JSON.stringify(
+          {
+            compilerOptions: {
+              declaration: true,
+              emitDeclarationOnly: true,
+              module: 'Preserve',
+              moduleResolution: 'Bundler',
+              noCheck: true,
+              outDir: emittedRoot,
+              paths: {
+                '@modern-js/runtime/router/internal': [
+                  './currentRuntimeRouter.d.ts',
+                ],
+              },
+              rootDir: sourceRoot,
+              skipLibCheck: false,
+              strict: true,
+              target: 'ESNext',
+              types: [],
+            },
+            files: [path.join(sourceRoot, 'router.ts')],
+          },
+          null,
+          2,
+        ),
+      );
+
+      runTsgo(tsgoBin, path.join(tempRoot, 'emit.json'));
+
+      const declarationPath = path.join(emittedRoot, 'router.d.ts');
+      const declaration = readFileSync(declarationPath, 'utf8');
+      expect(declaration).not.toMatch(
+        /\b(?:createRouterPlugin|RouterPluginFactory)\b/u,
+      );
+      expect(declaration).toContain("['routerPlugin']");
+
+      writeFileSync(
+        path.join(tempRoot, 'legacyRuntimeRouter.ts'),
+        readFileSync(legacyFixturePath, 'utf8'),
+      );
+      writeFileSync(
+        path.join(tempRoot, 'compatibility.json'),
+        JSON.stringify(
+          {
+            compilerOptions: {
+              module: 'Preserve',
+              moduleResolution: 'Bundler',
+              noEmit: true,
+              paths: {
+                '@modern-js/runtime/router/internal': [
+                  './legacyRuntimeRouter.ts',
+                ],
+              },
+              skipLibCheck: false,
+              strict: true,
+              target: 'ESNext',
+              types: [],
+            },
+            files: [
+              declarationPath,
+              path.join(tempRoot, 'legacyRuntimeRouter.ts'),
+            ],
+          },
+          null,
+          2,
+        ),
+      );
+
+      runTsgo(tsgoBin, path.join(tempRoot, 'compatibility.json'));
+    } finally {
+      rmSync(tempRoot, { force: true, recursive: true });
+    }
+  });
+});

package/tests/router/rsc.test.tsx

@@ -2,6 +2,10 @@ import { UNSAFE_ErrorResponseImpl as ErrorResponseImpl } from '@modern-js/runtim
 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 {
   __setTanstackRscPayloadDecoderForTests,
   createTanstackRscServerPayload,
@@ -65,6 +69,54 @@ describe('tanstack rsc runtime helpers', () => {
     ]);
   });
 
+  test('revives shared structures that the Flight serializer preserves', async () => {
+    const shared = { label: 'shared' };
+    const serialized = serializeTanstackRscFlightValues({
+      left: shared,
+      right: shared,
+    }) as { left: unknown; right: unknown };
+
+    const revived = (await reviveTanstackRscFlightValues(serialized)) as {
+      left: unknown;
+      right: unknown;
+    };
+
+    expect(serialized.left).toBe(serialized.right);
+    expect(revived.left).toBe(revived.right);
+  });
+
+  test('serializes TanStack RSC flight values nested in map and set containers', () => {
+    const stream: ServerComponentStream = {
+      createReplayStream: () => new ReadableStream<Uint8Array>(),
+    };
+    const proxy = createRscProxy(() => null, {
+      renderable: true,
+      stream,
+    }) as React.ReactElement & Record<PropertyKey, unknown>;
+
+    const serialized = serializeTanstackRscFlightValues({
+      map: new Map([['slot', proxy]]),
+      set: new Set([proxy]),
+    }) as {
+      map: Map<string, Record<string, unknown>>;
+      set: Set<Record<string, unknown>>;
+    };
+
+    const mapValue = serialized.map.get('slot');
+    const [setValue] = serialized.set;
+
+    expect(mapValue).not.toBe(proxy);
+    expect(setValue).not.toBe(proxy);
+    expect(mapValue).toMatchObject({
+      __modernTanstackRsc: true,
+      kind: 'renderable',
+    });
+    expect(setValue).toMatchObject({
+      __modernTanstackRsc: true,
+      kind: 'renderable',
+    });
+  });
+
   test('renderable RSC proxies preserve React element behavior and metadata', () => {
     const stream: ServerComponentStream = {
       createReplayStream: () => new ReadableStream<Uint8Array>(),
@@ -219,6 +271,36 @@ describe('tanstack rsc runtime helpers', () => {
     expect(JSON.stringify(payload.errors)).not.toContain('stack secret');
   });
 
+  test('redacts production TanStack RSC non-Error server payload errors', () => {
+    const payload = withNodeEnv('production', () =>
+      createTanstackRscServerPayload({
+        state: {
+          location: { href: '/plain' },
+          matches: [
+            {
+              error: { message: 'plain secret', token: 'token secret' },
+              params: {},
+              pathname: '/plain',
+              pathnameBase: '/plain',
+              route: { id: '/plain' },
+              routeId: '/plain',
+            },
+          ],
+        },
+      }),
+    );
+
+    expect(payload.errors).toMatchObject({
+      '/plain': {
+        message: 'Unexpected Server Error',
+        stack: undefined,
+        __type: 'Error',
+      },
+    });
+    expect(JSON.stringify(payload.errors)).not.toContain('plain secret');
+    expect(JSON.stringify(payload.errors)).not.toContain('token secret');
+  });
+
   test('converts TanStack RSC redirects to Modern RSC navigation headers', () => {
     const response = handleTanstackRscRedirect(
       new Headers({ Location: '/base/login' }),
@@ -232,6 +314,54 @@ describe('tanstack rsc runtime helpers', () => {
     expect(response.headers.get('X-Modernjs-BaseUrl')).toBe('/base');
   });
 
+  test('preserves TanStack RSC redirect paths that do not start with the basename', () => {
+    const response = handleTanstackRscRedirect(
+      new Headers({ Location: '/shop/base/login' }),
+      '/base',
+      302,
+    );
+
+    expect(response.headers.get('X-Modernjs-Redirect')).toBe(
+      '/shop/base/login',
+    );
+  });
+
+  test('preserves RSC redirect response status and headers in TanStack redirects', async () => {
+    rstest.stubGlobal(
+      'fetch',
+      rstest.fn(() =>
+        Promise.resolve(
+          new Response(null, {
+            headers: {
+              'X-Modernjs-Redirect': '/login',
+              'X-Trace': 'preserved',
+            },
+            status: 308,
+          }),
+        ),
+      ),
+    );
+
+    const thrown = (await loadTanstackRscRouteData({
+      loadClientData: async () => ({ fallback: true }),
+      request: new Request('http://localhost/products'),
+      routeId: '/products',
+    }).then(
+      () => {
+        throw new Error('expected redirect');
+      },
+      err => err,
+    )) as Response & {
+      options?: { statusCode?: number; to?: string };
+    };
+
+    expect(thrown).toBeInstanceOf(Response);
+    expect(thrown.status).toBe(308);
+    expect(thrown.headers.get('X-Trace')).toBe('preserved');
+    expect(thrown.options?.statusCode).toBe(308);
+    expect(thrown.options?.to).toBe('/login');
+  });
+
   test('loads one RSC payload for multiple server route loaders', async () => {
     const payload = {
       type: 'render',
@@ -275,6 +405,65 @@ describe('tanstack rsc runtime helpers', () => {
     expect(decodeMock).toHaveBeenCalledTimes(1);
   });
 
+  test('separates RSC payload cache entries by forwarded request headers', async () => {
+    const payloadByUser: Record<string, unknown> = {
+      alice: {
+        type: 'render',
+        actionData: null,
+        errors: null,
+        loaderData: {
+          '/profile': { user: 'alice' },
+        },
+        location: { href: '/profile' },
+        routes: [{ id: '/profile', hasLoader: true }],
+      },
+      bob: {
+        type: 'render',
+        actionData: null,
+        errors: null,
+        loaderData: {
+          '/profile': { user: 'bob' },
+        },
+        location: { href: '/profile' },
+        routes: [{ id: '/profile', hasLoader: true }],
+      },
+    };
+    const fetchMock = rstest.fn(
+      (_url: string | URL | Request, init?: RequestInit) => {
+        const user =
+          init?.headers instanceof Headers ? init.headers.get('x-user') : null;
+        return Promise.resolve(
+          new Response(JSON.stringify(payloadByUser[user || ''])),
+        );
+      },
+    );
+    rstest.stubGlobal('fetch', fetchMock);
+    __setTanstackRscPayloadDecoderForTests(async stream =>
+      JSON.parse(await new Response(stream).text()),
+    );
+
+    const [aliceData, bobData] = await Promise.all([
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: 'alice' }),
+        request: new Request('http://localhost/profile', {
+          headers: { 'x-user': 'alice' },
+        }),
+        routeId: '/profile',
+      }),
+      loadTanstackRscRouteData({
+        loadClientData: async () => ({ fallback: 'bob' }),
+        request: new Request('http://localhost/profile', {
+          headers: { 'x-user': 'bob' },
+        }),
+        routeId: '/profile',
+      }),
+    ]);
+
+    expect(aliceData).toEqual({ user: 'alice' });
+    expect(bobData).toEqual({ user: 'bob' });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+  });
+
   test('uses client loader data without requesting an RSC payload for client-loader routes', async () => {
     const fetchMock = rstest.fn();
     const loadClientData = rstest.fn(async () => ({ client: true }));