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

package/tests/router/preloadRedirect.test.ts

@@ -1,64 +0,0 @@
-import { createMemoryHistory } from '@tanstack/history';
-import {
-  createRootRoute,
-  createRoute,
-  createRouter,
-  redirect,
-} from '@tanstack/react-router';
-
-describe('tanstack router-core preload redirects', () => {
-  afterEach(() => {
-    rstest.restoreAllMocks();
-  });
-
-  test('resolves concurrent preload redirects without stale loader work', async () => {
-    const consoleErrorSpy = rstest
-      .spyOn(console, 'error')
-      .mockImplementation(() => {});
-    const rootRoute = createRootRoute();
-    const indexRoute = createRoute({
-      getParentRoute: () => rootRoute,
-      path: '/',
-      component: () => null,
-    });
-    let redirectLoaderCalls = 0;
-    const redirectRoute = createRoute({
-      getParentRoute: () => rootRoute,
-      path: '/redirect',
-      loader: async () => {
-        redirectLoaderCalls += 1;
-        await Promise.resolve();
-        throw redirect({ to: '/target' });
-      },
-      component: () => null,
-    });
-    const targetLoader = rstest.fn(async () => 'target');
-    const targetRoute = createRoute({
-      getParentRoute: () => rootRoute,
-      path: '/target',
-      loader: targetLoader,
-      component: () => null,
-    });
-    const router = createRouter({
-      routeTree: rootRoute.addChildren([
-        indexRoute,
-        redirectRoute,
-        targetRoute,
-      ]),
-      history: createMemoryHistory({
-        initialEntries: ['/'],
-      }),
-      defaultStructuralSharing: true,
-    });
-
-    await Promise.all([
-      router.preloadRoute({ to: '/redirect' }),
-      router.preloadRoute({ to: '/redirect' }),
-    ]);
-
-    expect(consoleErrorSpy).not.toHaveBeenCalled();
-    expect(router.options.defaultStructuralSharing).toBe(true);
-    expect(redirectLoaderCalls).toBe(1);
-    expect(targetLoader).toHaveBeenCalledTimes(1);
-  });
-});

package/tests/router/register.test.ts

@@ -1,8 +0,0 @@
-import { resolveRouterProvider } from '@modern-js/runtime/context';
-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');
-  });
-});

package/tests/router/routerCompatibility.test.ts

@@ -1,239 +0,0 @@
-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');
-      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/rscPayloadRouterMatrix.test.ts

@@ -1,197 +0,0 @@
-import {
-  __setTanstackRscPayloadDecoderForTests,
-  createTanstackRscServerPayload,
-  handleTanstackRscRedirect,
-  loadTanstackRscRouteData,
-} from '../../src/runtime/rsc/payloadRouter';
-
-function createPayload(
-  routeId: string,
-  loaderData: unknown,
-  options: { errors?: Record<string, unknown> | null } = {},
-) {
-  return {
-    type: 'render',
-    actionData: null,
-    errors: options.errors ?? null,
-    loaderData: loaderData === undefined ? {} : { [routeId]: loaderData },
-    location: { href: routeId },
-    routes: [{ id: routeId, hasLoader: true }],
-  };
-}
-
-async function decodeJsonPayload(stream: ReadableStream<Uint8Array>) {
-  return JSON.parse(await new Response(stream).text());
-}
-
-describe('tanstack rsc payload router matrix', () => {
-  afterEach(() => {
-    __setTanstackRscPayloadDecoderForTests();
-    rstest.restoreAllMocks();
-  });
-
-  test('normalizes redirect basenames while preserving status and non-location headers', () => {
-    const scenarios = [
-      {
-        location: '/base',
-        name: 'exact basename',
-        redirect: '/',
-      },
-      {
-        location: '/base/login?from=%2Fbase',
-        name: 'leading basename',
-        redirect: '/login?from=%2Fbase',
-      },
-      {
-        location: '/shop/base/login',
-        name: 'mid-path basename',
-        redirect: '/shop/base/login',
-      },
-    ] as const;
-
-    for (const scenario of scenarios) {
-      const response = handleTanstackRscRedirect(
-        new Headers({
-          Location: scenario.location,
-          'X-Trace': scenario.name,
-        }),
-        '/base',
-        307,
-      );
-
-      expect(response.status).toBe(307);
-      expect(response.headers.get('Location')).toBeNull();
-      expect(response.headers.get('X-Modernjs-BaseUrl')).toBe('/base');
-      expect(response.headers.get('X-Modernjs-Redirect')).toBe(
-        scenario.redirect,
-      );
-      expect(response.headers.get('X-Trace')).toBe(scenario.name);
-    }
-  });
-
-  test('separates payload fetch cache entries by URL and request method', async () => {
-    const payloads = [
-      createPayload('/resource', { method: 'GET' }),
-      createPayload('/resource', { method: 'POST' }),
-    ];
-    let payloadIndex = 0;
-    const fetchMock = rstest.fn(() =>
-      Promise.resolve(new Response(JSON.stringify(payloads[payloadIndex++]))),
-    );
-    rstest.stubGlobal('fetch', fetchMock);
-    __setTanstackRscPayloadDecoderForTests(decodeJsonPayload);
-
-    const [getData, postData] = await Promise.all([
-      loadTanstackRscRouteData({
-        loadClientData: async () => ({ fallback: 'get' }),
-        request: new Request('http://localhost/resource', { method: 'GET' }),
-        routeId: '/resource',
-      }),
-      loadTanstackRscRouteData({
-        loadClientData: async () => ({ fallback: 'post' }),
-        request: new Request('http://localhost/resource', { method: 'POST' }),
-        routeId: '/resource',
-      }),
-    ]);
-
-    expect(getData).toEqual({ method: 'GET' });
-    expect(postData).toEqual({ method: 'POST' });
-    expect(fetchMock).toHaveBeenCalledTimes(2);
-    expect(fetchMock.mock.calls.map(call => call[0])).toEqual([
-      'http://localhost/resource',
-      'http://localhost/resource',
-    ]);
-  });
-
-  test('rethrows matched route errors from the decoded payload', async () => {
-    const routeError = new Error('route loader failed');
-    const payload = createPayload('/broken', undefined, {
-      errors: { '/broken': routeError },
-    });
-    rstest.stubGlobal(
-      'fetch',
-      rstest.fn(() => Promise.resolve(new Response('payload'))),
-    );
-    __setTanstackRscPayloadDecoderForTests(async () => payload);
-
-    await expect(
-      loadTanstackRscRouteData({
-        loadClientData: async () => ({ fallback: true }),
-        request: new Request('http://localhost/broken'),
-        routeId: '/broken',
-      }),
-    ).rejects.toBe(routeError);
-  });
-
-  test('returns undefined for route ids missing from the decoded payload', async () => {
-    const loadClientData = rstest.fn(async () => ({ fallback: true }));
-    const payload = createPayload('/known', { known: true });
-    rstest.stubGlobal(
-      'fetch',
-      rstest.fn(() => Promise.resolve(new Response('payload'))),
-    );
-    __setTanstackRscPayloadDecoderForTests(async () => payload);
-
-    await expect(
-      loadTanstackRscRouteData({
-        loadClientData,
-        request: new Request('http://localhost/missing'),
-        routeId: '/missing',
-      }),
-    ).resolves.toBeUndefined();
-    expect(loadClientData).not.toHaveBeenCalled();
-  });
-
-  test('omits server payload matches with no route identity', () => {
-    const payload = createTanstackRscServerPayload({
-      state: {
-        location: { href: '/kept' },
-        matches: [
-          {
-            loaderData: { omitted: true },
-            params: {},
-            pathname: '/missing-id',
-            pathnameBase: '/missing-id',
-            route: {
-              options: {
-                path: 'missing-id',
-                staticData: { modernRouteHasLoader: true },
-              },
-            },
-          },
-          {
-            loaderData: { kept: true },
-            params: {},
-            pathname: '/kept',
-            pathnameBase: '/kept',
-            route: {
-              id: '/kept',
-              options: {
-                path: 'kept',
-                staticData: { modernRouteHasLoader: true },
-              },
-            },
-          },
-        ],
-      },
-    });
-
-    expect(payload.loaderData).toEqual({ '/kept': { kept: true } });
-    expect(payload.routes).toEqual([
-      {
-        handle: undefined,
-        hasAction: false,
-        hasClientLoader: false,
-        hasErrorBoundary: false,
-        hasLoader: true,
-        id: '/kept',
-        index: undefined,
-        params: {},
-        parentId: undefined,
-        path: 'kept',
-        pathname: '/kept',
-        pathnameBase: '/kept',
-      },
-    ]);
-  });
-});