@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/tests/router/hydrationBoundary.test.tsx

@@ -1,23 +0,0 @@
-import { isValidElement, Suspense } from 'react';
-import { wrapTanstackSsrHydrationBoundary } from '../../src/runtime/hydrationBoundary';
-
-describe('tanstack SSR hydration boundary', () => {
-  it('wraps SSR hydration content in a Suspense boundary', () => {
-    const routerContent = <main data-testid="router" />;
-
-    const wrapped = wrapTanstackSsrHydrationBoundary(routerContent, true);
-
-    expect(isValidElement(wrapped)).toBe(true);
-    expect(wrapped.type).toBe(Suspense);
-    expect(wrapped.props.fallback).toBe(null);
-    expect(wrapped.props.children).toBe(routerContent);
-  });
-
-  it('keeps non-SSR router content unwrapped', () => {
-    const routerContent = <main data-testid="router" />;
-
-    expect(wrapTanstackSsrHydrationBoundary(routerContent, false)).toBe(
-      routerContent,
-    );
-  });
-});

package/tests/router/packageSurface.test.ts

@@ -1,24 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-
-describe('tanstack package public surface', () => {
-  test('package manifest exposes the runtime subpath used by app fixtures', () => {
-    const packageJson = JSON.parse(
-      readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'),
-    ) as {
-      exports: Record<string, unknown>;
-      typesVersions?: Record<string, Record<string, string[]>>;
-    };
-
-    expect(packageJson.exports['./runtime']).toEqual({
-      types: './dist/types/runtime/index.d.ts',
-      node: {
-        module: './dist/esm/runtime/index.mjs',
-      },
-      default: './dist/esm/runtime/index.mjs',
-    });
-    expect(packageJson.typesVersions?.['*']?.runtime).toEqual([
-      './dist/types/runtime/index.d.ts',
-    ]);
-  });
-});

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