@bleedingdev/modern-js-plugin-tanstack 3.9.0-ultramodern.8 → 3.9.3-ultramodern.1

package/tests/router/prefetchLink.test.tsx

@@ -1,122 +0,0 @@
-import { createMemoryHistory } from '@tanstack/history';
-import {
-  createRootRoute,
-  createRoute,
-  createRouter,
-  RouterProvider,
-} from '@tanstack/react-router';
-import { act, render, waitFor } from '@testing-library/react';
-import React from 'react';
-import { Link, NavLink } from '../../src/runtime/prefetchLink';
-
-// 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>
-      );
-    },
-  });
-  const homeRoute = createRoute({
-    getParentRoute: () => rootRoute,
-    path: '/',
-    component: () => null,
-  });
-  const settingsRoute = createRoute({
-    getParentRoute: () => rootRoute,
-    path: '/settings',
-    component: () => null,
-  });
-
-  const routeTree = rootRoute.addChildren([homeRoute, settingsRoute]);
-
-  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;
-  });
-
-  return { anchor, router, ...utils };
-}
-
-describe('tanstack prefetch link adapter - aria-current override', () => {
-  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('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);
-  });
-
-  it('updates render-prop children across an inactive-to-active transition', async () => {
-    const { anchor, router } = await renderLink({
-      initialPath: '/',
-      children: ({ isActive }: { isActive: boolean }) =>
-        isActive ? 'Active settings' : 'Settings',
-    });
-
-    expect(anchor.textContent).toBe('Settings');
-
-    await act(async () => {
-      await router.navigate({ to: '/settings' });
-    });
-
-    await waitFor(() => expect(anchor.textContent).toBe('Active settings'));
-  });
-
-  it('passes the native anchor ref through the router hook', async () => {
-    const ref = React.createRef<HTMLAnchorElement>();
-    const { anchor } = await renderLink({
-      initialPath: '/',
-      linkProps: { ref, prefetch: 'none' },
-    });
-    expect(ref.current).toBe(anchor);
-  });
-});

package/tests/router/prefetchLinkPreload.test.tsx

@@ -1,65 +0,0 @@
-import { render } from '@testing-library/react';
-import React from 'react';
-import { Link } 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('preserves an explicit false preload override', () => {
-    render(
-      <Link to="/settings" prefetch="render" preload={false}>
-        Settings
-      </Link>,
-    );
-
-    expect(capturedOptions[0]?.preload).toBe(false);
-  });
-
-  it('defaults to viewport preload when no prefetch is given', () => {
-    render(<Link to="/settings">Settings</Link>);
-
-    expect(capturedOptions[0]?.preload).toBe('viewport');
-  });
-
-  it('maps none prefetch to disabled TanStack preload', () => {
-    render(
-      <Link to="/settings" prefetch="none">
-        Settings
-      </Link>,
-    );
-
-    expect(capturedOptions[0]?.preload).toBe(false);
-  });
-
-  it('lets explicit preload re-enable prefetch=none', () => {
-    render(
-      <Link to="/settings" prefetch="none" preload="render">
-        Settings
-      </Link>,
-    );
-
-    expect(capturedOptions.map(o => o.preload)).toEqual(['render']);
-  });
-});

package/tests/router/routeHooks.test.ts

@@ -1,49 +0,0 @@
-import { createMemoryHistory } from '@tanstack/history';
-import {
-  createRootRoute,
-  createRoute,
-  createRouter,
-  RouterProvider,
-} from '@tanstack/react-router';
-import React from 'react';
-import { renderToString } from 'react-dom/server';
-import { useMatches } from '../../src/runtime/routeHooks';
-
-function MatchIds() {
-  const matches = useMatches();
-  return React.createElement(
-    'output',
-    { 'data-testid': 'route-ids' },
-    matches.map(match => match.routeId).join(','),
-  );
-}
-
-test('updates whole match objects after navigation with the structural-sharing guard', async () => {
-  const rootRoute = createRootRoute({ component: MatchIds });
-  const homeRoute = createRoute({
-    getParentRoute: () => rootRoute,
-    path: '/',
-    component: () => null,
-  });
-  const settingsRoute = createRoute({
-    getParentRoute: () => rootRoute,
-    path: '/settings',
-    component: () => null,
-  });
-  const router = createRouter({
-    routeTree: rootRoute.addChildren([homeRoute, settingsRoute]),
-    history: createMemoryHistory({ initialEntries: ['/'] }),
-    defaultStructuralSharing: true,
-  });
-
-  await router.load();
-  expect(
-    renderToString(React.createElement(RouterProvider, { router })),
-  ).toContain('__root__');
-
-  await router.navigate({ to: '/settings' });
-
-  expect(
-    renderToString(React.createElement(RouterProvider, { router })),
-  ).toContain('/settings');
-});

package/tests/router/routeTree.test.ts

@@ -1,240 +0,0 @@
-import type { RouteObject } from '@modern-js/runtime-utils/router';
-import { createMemoryHistory } from '@tanstack/history';
-import {
-  createRouter,
-  Outlet,
-  RouterProvider,
-  redirect,
-} from '@tanstack/react-router';
-import type { ComponentType } from 'react';
-import { createElement, lazy } from 'react';
-import { renderToStaticMarkup, renderToString } from 'react-dom/server';
-import { Outlet as ModernOutlet } from '../../src/runtime/outlet';
-import { createRouteTreeFromRouteObjects } from '../../src/runtime/routeTree';
-
-type LoaderArgs = { params: Record<string, string> };
-
-type TestRouteObject = RouteObject & {
-  children?: TestRouteObject[];
-  lazyImport?: () => Promise<unknown>;
-};
-
-type TestRouter = {
-  _serverResult?:
-    | { type: 'redirect'; redirect: Response }
-    | { type: 'render'; status: number };
-  state: {
-    matches: Array<{ error?: unknown; loaderData?: unknown; routeId: string }>;
-  };
-};
-
-const nullComponent = () => null;
-
-const root = (
-  children: TestRouteObject[],
-  Component: RouteObject['Component'] = nullComponent,
-): TestRouteObject[] => [{ id: 'root', path: '/', Component, children }];
-
-async function loadRouteTree(
-  routes: TestRouteObject[],
-  pathname: string,
-): Promise<TestRouter> {
-  const router = createRouter({
-    routeTree: createRouteTreeFromRouteObjects(routes as RouteObject[]),
-    history: createMemoryHistory({ initialEntries: [pathname] }),
-    context: {
-      request: new Request(`http://localhost${pathname}`),
-      requestContext: {},
-    },
-  });
-
-  await router.load();
-  return router as unknown as TestRouter;
-}
-
-const matchOf = (router: TestRouter, routeId: string) =>
-  router.state.matches.find(match => match.routeId === routeId);
-
-describe('tanstack route tree from RouteObject[]', () => {
-  test('resolves loader data for root, dynamic and splat params', async () => {
-    const routes: TestRouteObject[] = root(
-      [
-        {
-          id: 'user',
-          path: 'user/:id',
-          loader: ({ params }: LoaderArgs) => ({ id: params.id }),
-          Component: nullComponent,
-        },
-        {
-          id: 'files',
-          path: 'files/*',
-          loader: ({ params }: LoaderArgs) => ({ value: params['*'] }),
-          Component: nullComponent,
-        },
-      ],
-      nullComponent,
-    );
-    routes[0].loader = () => ({ root: 'ok' });
-
-    const userRouter = await loadRouteTree(routes, '/user/123');
-    expect(matchOf(userRouter, '__root__')?.loaderData).toEqual({ root: 'ok' });
-    expect(matchOf(userRouter, '/user/$id')?.loaderData).toEqual({ id: '123' });
-
-    const splatRouter = await loadRouteTree(routes, '/files/a/b/c');
-    expect(matchOf(splatRouter, '/files/$')?.loaderData).toEqual({
-      value: 'a/b/c',
-    });
-  });
-
-  test('keeps unnamed sibling pathless layouts distinct', async () => {
-    const pathless = (path: string): TestRouteObject => ({
-      Component: nullComponent,
-      children: [
-        { path, loader: () => ({ value: path }), Component: nullComponent },
-      ],
-    });
-
-    const router = await loadRouteTree(
-      [pathless('alpha'), pathless('beta')],
-      '/beta',
-    );
-    const loaderData = router.state.matches
-      .map(match => match.loaderData)
-      .filter(Boolean);
-
-    expect(loaderData).toContainEqual({ value: 'beta' });
-    expect(loaderData).not.toContainEqual({ value: 'alpha' });
-  });
-
-  test('reports native TanStack unknown routes as HTTP 404', async () => {
-    const router = await loadRouteTree(
-      root([{ id: 'known', path: 'known', Component: nullComponent }]),
-      '/missing',
-    );
-
-    expect(router._serverResult).toMatchObject({ type: 'render', status: 404 });
-  });
-
-  test('reports native TanStack loader redirects as server responses', async () => {
-    const router = await loadRouteTree(
-      root([
-        {
-          id: 'redirect',
-          path: 'redirect',
-          loader: () => {
-            throw redirect({ to: '/target' });
-          },
-          Component: nullComponent,
-        },
-        { id: 'target', path: 'target', Component: nullComponent },
-      ]),
-      '/redirect',
-    );
-
-    if (router._serverResult?.type !== 'redirect') {
-      throw new Error('Expected a TanStack redirect server result');
-    }
-    expect(router._serverResult.redirect.status).toBe(307);
-    expect(router._serverResult.redirect.headers.get('Location')).toBe(
-      '/target',
-    );
-  });
-
-  test('renders Modern Outlet through TanStack native outlet', async () => {
-    const router = await loadRouteTree(
-      root(
-        [
-          {
-            id: 'plain',
-            path: 'plain',
-            Component: () => createElement('main', null, 'Plain child route'),
-          },
-        ],
-        () => createElement('section', null, createElement(ModernOutlet)),
-      ),
-      '/plain',
-    );
-
-    expect(
-      renderToString(createElement(RouterProvider, { router } as never)),
-    ).toContain('Plain child route');
-  });
-
-  for (const [shape, wrap] of [
-    ['flat', (Component: ComponentType) => ({ default: Component })],
-    [
-      'nested',
-      (Component: ComponentType) => ({ default: { default: Component } }),
-    ],
-  ] as const) {
-    test(`server renders lazy child routes from ${shape} ESM module defaults`, async () => {
-      const LazyRouteComponent = () =>
-        createElement('main', null, 'Lazy child route ready');
-      const lazyImport = () => Promise.resolve(wrap(LazyRouteComponent));
-      const router = await loadRouteTree(
-        root(
-          [
-            {
-              id: 'lazy',
-              path: 'lazy',
-              Component: lazy(
-                lazyImport as () => Promise<{ default: ComponentType }>,
-              ),
-              lazyImport,
-            },
-          ],
-          () => createElement('section', null, createElement(Outlet)),
-        ),
-        '/lazy',
-      );
-
-      expect(
-        renderToStaticMarkup(
-          createElement(RouterProvider, { router } as never),
-        ),
-      ).toContain('Lazy child route ready');
-    });
-  }
-
-  test('normalizes Modern deferred loader data for TanStack SSR', async () => {
-    const router = await loadRouteTree(
-      root([
-        {
-          id: 'deferred',
-          path: 'deferred',
-          loader: () => ({
-            __modern_deferred: true,
-            data: { immediate: 'ok', later: Promise.resolve('done') },
-          }),
-          Component: nullComponent,
-        },
-      ]),
-      '/deferred',
-    );
-    const loaderData = matchOf(router, '/deferred')?.loaderData as
-      | { immediate: string; later: Promise<string> }
-      | undefined;
-
-    expect(loaderData?.immediate).toBe('ok');
-    await expect(loaderData?.later).resolves.toBe('done');
-  });
-
-  test('preserves returned non-404 Response loaders as loader data', async () => {
-    const response = new Response('route status payload', { status: 500 });
-    const router = await loadRouteTree(
-      root([
-        {
-          id: 'broken',
-          path: 'broken',
-          loader: () => response,
-          Component: nullComponent,
-        },
-      ]),
-      '/broken',
-    );
-
-    expect(router._serverResult).toMatchObject({ type: 'render', status: 200 });
-    expect(matchOf(router, '/broken')?.loaderData).toBe(response);
-    expect(matchOf(router, '/broken')?.error).toBeUndefined();
-  });
-});