@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

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

@@ -1,140 +0,0 @@
-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 rscProxy = createRscProxy(() => ({ slot: 'server' }), {
-    renderable: true,
-    stream: createStream(),
-  }) as React.ReactElement & Record<PropertyKey, unknown>;
-
-  const mapValue = new Map<unknown, unknown>([
-    ['primitive', 1],
-    ['shared', shared],
-    [shared, circular],
-    ['rscProxy', rscProxy],
-  ]);
-  mapValue.set('self', mapValue);
-
-  const setValue = new Set<unknown>(['set-item', shared, circular, rscProxy]);
-  setValue.add(setValue);
-
-  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(isValidElement(revived.mapValue.get('rscProxy'))).toBe(true);
-
-  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].some(value => isValidElement(value))).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

@@ -1,146 +0,0 @@
-// The headless entry must drive the real TanStack artifact writer. Checking
-// only the createRunOptions/cli.init choreography would allow a no-op CLI to
-// pass while leaving router.gen.ts stale or missing.
-const createRunOptionsMock = rstest.fn(async (options: unknown) => ({
-  mockRunOptions: true,
-  received: options,
-}));
-const cliInitMock = rstest.fn(async () => ({ appContext: {} }));
-
-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,
-  writeTanstackRouterTypesForEntries,
-} 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('writes a real route artifact through the prepare-only CLI drive', async () => {
-    const previousArgv = process.env.MODERN_ARGV;
-    const appDirectory = makeAppDir(true);
-    const srcDirectory = path.join(appDirectory, 'src');
-    const componentPath = path.join(srcDirectory, 'routes', 'page.tsx');
-    fs.mkdirSync(path.dirname(componentPath), { recursive: true });
-    fs.writeFileSync(
-      componentPath,
-      'export default function Page() { return null; }\n',
-      'utf-8',
-    );
-
-    const runOptions = {
-      cwd: appDirectory,
-      version: '9.9.9-test',
-      internalPlugins: INTERNAL_RUNTIME_PLUGINS,
-      configFile: path.resolve(appDirectory, 'modern.config'),
-    };
-    createRunOptionsMock.mockResolvedValue({
-      mockRunOptions: true,
-      received: runOptions,
-    });
-    cliInitMock.mockImplementation(async () => {
-      await writeTanstackRouterTypesForEntries({
-        appContext: {
-          srcDirectory,
-          internalSrcAlias: '@/_',
-          entrypoints: [{ entryName: 'main', isMainEntry: true }],
-        } as any,
-        routesByEntry: {
-          main: [
-            {
-              type: 'nested',
-              id: 'layout',
-              isRoot: true,
-              children: [
-                {
-                  type: 'nested',
-                  id: 'page',
-                  index: true,
-                  _component: '@/_/routes/page',
-                },
-              ],
-            },
-          ] as any,
-        },
-      });
-      return { appContext: {} };
-    });
-
-    try {
-      await generateTanstackRouteArtifacts({
-        appDirectory,
-        version: '9.9.9-test',
-      });
-
-      expect(createRunOptionsMock).toHaveBeenCalledTimes(1);
-      const runOptionsArg = createRunOptionsMock.mock.calls[0][0] as Record<
-        string,
-        unknown
-      >;
-      // 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);
-
-      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(registerArtifact).toContain('./main/router.gen');
-    } 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 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/loaderBridge.test.ts

@@ -1,207 +0,0 @@
-import { isNotFound, isRedirect } from '@tanstack/react-router';
-import {
-  mapSplatParamsForModernLoader,
-  modernLoaderToTanstack,
-  throwTanstackRedirect,
-} from '../../src/runtime/loaderBridge';
-
-type RedirectLike = {
-  options?: {
-    href?: string;
-    to?: string;
-  };
-};
-
-function catchThrown(fn: () => unknown): unknown {
-  try {
-    fn();
-  } catch (err) {
-    return err;
-  }
-  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' },
-    params: { id: '1' },
-  };
-
-  test('passes request/params/context through to the modern loader', async () => {
-    const seen: { request?: Request; params?: unknown; context?: unknown } = {};
-    const loader = modernLoaderToTanstack({ hasSplat: false }, (args: any) => {
-      seen.request = args.request;
-      seen.params = args.params;
-      seen.context = args.context;
-      return { ok: true };
-    });
-
-    await expect(
-      loader({
-        ...baseCtx,
-        context: { requestContext: { user: 'u1' } },
-      }),
-    ).resolves.toEqual({ ok: true });
-    expect(seen.request).toBeInstanceOf(Request);
-    expect(seen.request?.url).toBe('http://localhost/products/1');
-    expect(seen.params).toEqual({ id: '1' });
-    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),
-    );
-
-    const thrown = (await loader(baseCtx).then(
-      () => {
-        throw new Error('expected redirect');
-      },
-      (err: unknown) => err,
-    )) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.href).toBe('https://example.com/away');
-    expect(thrown.options?.to).toBeUndefined();
-  });
-
-  test('translates a relative redirect Response into redirect({ to })', async () => {
-    const loader = modernLoaderToTanstack(
-      { hasSplat: false },
-      () =>
-        new Response(null, { status: 302, headers: { Location: '/login' } }),
-    );
-
-    const thrown = (await loader(baseCtx).then(
-      () => {
-        throw new Error('expected redirect');
-      },
-      (err: unknown) => err,
-    )) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.to).toBe('/login');
-  });
-
-  test('translates a 404 Response into notFound()', async () => {
-    const loader = modernLoaderToTanstack(
-      { hasSplat: false },
-      () => new Response(null, { status: 404 }),
-    );
-
-    const thrown = await loader(baseCtx).then(
-      () => {
-        throw new Error('expected notFound');
-      },
-      (err: unknown) => err,
-    );
-
-    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, {
-        status: 301,
-        headers: { Location: 'https://example.com/moved' },
-      });
-    });
-
-    // A synchronous loader throw surfaces synchronously (TanStack handles
-    // thrown redirects from the loader call itself).
-    const thrown = catchThrown(() => loader(baseCtx)) as RedirectLike;
-
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.href).toBe('https://example.com/moved');
-  });
-
-  test('re-throws TanStack redirects thrown by the loader untouched', async () => {
-    const loader = modernLoaderToTanstack({ hasSplat: false }, async () => {
-      throwTanstackRedirect('/inner');
-    });
-
-    const thrown = (await loader(baseCtx).then(
-      () => {
-        throw new Error('expected redirect');
-      },
-      (err: unknown) => err,
-    )) as RedirectLike;
-
-    // The bridge must not re-translate its own redirect (a Response without
-    // a Location header) — that used to collapse internal targets to '/'.
-    expect(isRedirect(thrown)).toBe(true);
-    expect(thrown.options?.to).toBe('/inner');
-  });
-});

package/tests/router/localisedIdentity.test.tsx

@@ -1,95 +0,0 @@
-import { applyLocalisedUrlsToRoutes } from '@modern-js/i18n-runtime-extensions';
-import {
-  createMemoryHistory,
-  createRouter,
-  Outlet,
-  RouterProvider,
-  useLoaderData,
-  useParams,
-} from '@tanstack/react-router';
-import { createElement } from 'react';
-import { renderToString } from 'react-dom/server';
-import { createModernBasepathRewrite } from '../../src/runtime/basepathRewrite';
-import { createRouteTreeFromRouteObjects } from '../../src/runtime/routeTree';
-import { createTanstackRouteObjectsFromConfig } from '../../src/runtime/utils';
-
-function SearchPage() {
-  const data = useLoaderData({ from: '/$lang/search' }) as { language: string };
-  return createElement('p', null, `search:${data.language}`);
-}
-
-function ResourcePage() {
-  const params = useParams({ from: '/$lang/resources/$id' }) as { id: string };
-  return createElement('p', null, `resource:${params.id}`);
-}
-
-test('localized URLs preserve native loader and params route identity in SSR and navigation', async () => {
-  const routes = applyLocalisedUrlsToRoutes(
-    [
-      {
-        type: 'nested',
-        id: 'lang',
-        path: ':lang',
-        component: Outlet,
-        children: [
-          {
-            type: 'nested',
-            id: 'search',
-            path: 'search',
-            component: SearchPage,
-            loader: ({ params }: { params: { lang: string } }) => ({
-              language: params.lang,
-            }),
-          },
-          {
-            type: 'nested',
-            id: 'resource',
-            path: 'resources/:id',
-            component: ResourcePage,
-          },
-        ],
-      },
-    ],
-    ['en', 'cs'],
-    {
-      '/search': { en: '/find', cs: '/hledat' },
-      '/resources/:id': { en: '/resources/:id', cs: '/zdroje/:id' },
-    },
-  );
-  const routeObjects = createTanstackRouteObjectsFromConfig({
-    routesConfig: { routes },
-  })!;
-  const history = createMemoryHistory({
-    initialEntries: ['/base/cs/hledat?q=tractor#results'],
-  });
-  const router = createRouter({
-    context: {
-      request: new Request(
-        'https://example.test/base/cs/hledat?q=tractor#results',
-      ),
-    },
-    routeTree: createRouteTreeFromRouteObjects(routeObjects),
-    history,
-    rewrite: createModernBasepathRewrite('/base', false, routeObjects),
-  });
-  await router.load();
-  expect(router.state.matches.at(-1)?.routeId).toBe('/$lang/search');
-  expect(renderToString(createElement(RouterProvider, { router }))).toContain(
-    'search:cs',
-  );
-  expect(history.location.href).toBe('/base/cs/hledat?q=tractor#results');
-
-  await router.navigate({ to: '/en/search', search: { q: 'tractor' } });
-  expect(history.location.href).toBe('/base/en/find?q=tractor');
-  expect(router.state.matches.at(-1)?.routeId).toBe('/$lang/search');
-  expect(renderToString(createElement(RouterProvider, { router }))).toContain(
-    'search:en',
-  );
-
-  await router.navigate({ to: '/cs/zdroje/a%2Fb' });
-  expect(history.location.href).toBe('/base/cs/zdroje/a%2Fb');
-  expect(router.state.matches.at(-1)?.routeId).toBe('/$lang/resources/$id');
-  expect(renderToString(createElement(RouterProvider, { router }))).toContain(
-    'resource:a/b',
-  );
-});