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

package/tests/realm-isolation.test.ts

@@ -1,114 +0,0 @@
-import type { RouterProviderFactory } from '@modern-js/runtime/context';
-import { rstest } from '@rstest/core';
-import type { RouterExtendsHooks } from '../src/runtime/hooks';
-
-const REGISTRY_SLOT: unique symbol = Symbol.for(
-  '@modern-js/runtime:router-providers:v3',
-);
-const host = globalThis as { [REGISTRY_SLOT]?: unknown };
-
-type RuntimeContextModule = typeof import('@modern-js/runtime/context');
-type RouterModule = typeof import('../src/runtime/router');
-
-type Vertical = {
-  context: RuntimeContextModule;
-  factory: RouterProviderFactory;
-  hooks: RouterExtendsHooks;
-  Link: unknown;
-  routerPlugin: RouterModule['routerPlugin'];
-  useMatches: unknown;
-};
-
-async function loadVertical(): Promise<Vertical> {
-  rstest.resetModules();
-  const routerModule = (await import('../src/runtime/router')) as RouterModule;
-  const context = (await import(
-    '@modern-js/runtime/context'
-  )) as RuntimeContextModule;
-  const { tanstackRouterProviderFactory } = await import(
-    '../src/runtime/register'
-  );
-  const { routerProviderRegistryHooks } = await import('../src/runtime/hooks');
-  const { Link } = await import('../src/runtime/prefetchLink');
-  const { useMatches } = await import('../src/runtime/routeHooks');
-
-  return {
-    context,
-    factory: tanstackRouterProviderFactory,
-    hooks: routerProviderRegistryHooks,
-    Link,
-    routerPlugin: routerModule.routerPlugin,
-    useMatches,
-  };
-}
-
-function setupRouterWrapper(vertical: Vertical) {
-  let onBeforeRender:
-    | ((context: any, interrupt: (value?: unknown) => unknown) => unknown)
-    | undefined;
-
-  const plugin = vertical.routerPlugin({ framework: 'tanstack' });
-  plugin.setup?.({
-    getHooks: () => vertical.hooks,
-    getRuntimeConfig: () => ({ router: { framework: 'tanstack' } }),
-    onBeforeRender: listener => {
-      onBeforeRender = listener;
-    },
-    wrapRoot: () => undefined,
-  });
-
-  expect(typeof onBeforeRender).toBe('function');
-  const runtimeContext: any = {};
-  onBeforeRender?.(runtimeContext, () => undefined);
-  return runtimeContext.router as { Link: unknown; useMatches: unknown };
-}
-
-describe('TanStack provider runtime-realm isolation', () => {
-  beforeEach(() => {
-    delete host[REGISTRY_SLOT];
-    rstest.resetModules();
-    (
-      globalThis as typeof globalThis & {
-        __webpack_require__?: { u: (chunkId: unknown) => string };
-      }
-    ).__webpack_require__ = { u: chunkId => String(chunkId) };
-  });
-
-  afterEach(() => {
-    delete host[REGISTRY_SLOT];
-    rstest.resetModules();
-  });
-
-  it('binds each production router wrapper to its own real provider graph', async () => {
-    const warnSpy = rstest.spyOn(console, 'warn').mockImplementation(() => {});
-    try {
-      const verticalA = await loadVertical();
-      const routerA = setupRouterWrapper(verticalA);
-      expect(routerA.Link).toBe(verticalA.Link);
-      expect(routerA.useMatches).toBe(verticalA.useMatches);
-
-      const verticalB = await loadVertical();
-      expect(verticalB.context).not.toBe(verticalA.context);
-      expect(verticalB.factory).not.toBe(verticalA.factory);
-      expect(verticalB.Link).not.toBe(verticalA.Link);
-      expect(verticalB.useMatches).not.toBe(verticalA.useMatches);
-
-      const routerB = setupRouterWrapper(verticalB);
-      expect(routerB.Link).toBe(verticalB.Link);
-      expect(routerB.useMatches).toBe(verticalB.useMatches);
-      expect(routerB.Link).not.toBe(verticalA.Link);
-      expect(routerB.useMatches).not.toBe(verticalA.useMatches);
-
-      // Mixed-version callers that do not supply a realm still see the shared
-      // keep-first fallback, but production wrappers no longer consume it.
-      expect(verticalB.context.resolveRouterProvider('tanstack')).toBe(
-        verticalA.factory,
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringMatching(/keeping the first registration/),
-      );
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-});

package/tests/router/fastDefaults.test.ts

@@ -1,32 +0,0 @@
-import {
-  getModernTanstackRouterFastDefaults,
-  modernTanstackRouterFastDefaults,
-} from '../../src/runtime/types';
-
-describe('tanstack router fast defaults', () => {
-  test('enables structural sharing by default', () => {
-    expect(modernTanstackRouterFastDefaults).toEqual({
-      defaultStructuralSharing: true,
-    });
-    expect(getModernTanstackRouterFastDefaults()).toEqual({
-      defaultStructuralSharing: true,
-    });
-  });
-
-  test('allows explicit structural sharing override', () => {
-    expect(
-      getModernTanstackRouterFastDefaults({
-        defaultStructuralSharing: true,
-      }),
-    ).toEqual({
-      defaultStructuralSharing: true,
-    });
-    expect(
-      getModernTanstackRouterFastDefaults({
-        defaultStructuralSharing: false,
-      }),
-    ).toEqual({
-      defaultStructuralSharing: false,
-    });
-  });
-});

package/tests/router/fixtures/legacyRuntimeRouter.ts

@@ -1,10 +0,0 @@
-let invocationCount = 0;
-
-export const routerPlugin = (
-  _userConfig: Record<string, unknown> = {},
-): { name?: string; setup?: (...args: unknown[]) => unknown } => {
-  invocationCount += 1;
-  throw new Error('The legacy global router wrapper must not be invoked.');
-};
-
-export const getLegacyRouterPluginInvocationCount = () => invocationCount;

package/tests/router/fixtures/rscDecoderSecurityChild.cjs

@@ -1,162 +0,0 @@
-const path = require('node:path');
-
-const scenario = process.argv[2];
-const serverPath = process.argv[3];
-const clientPath = process.argv[4];
-let moduleLoads = 0;
-
-global.__webpack_chunk_load__ = async () => {};
-global.__webpack_require__ = () => {
-  moduleLoads += 1;
-  return {
-    action(formData) {
-      return formData;
-    },
-  };
-};
-global.__rspack_rsc_hot_reloader__ = { on: () => () => {} };
-global.__rspack_rsc_manifest__ = {
-  clientManifest: {},
-  entryCssFiles: {},
-  entryJsFiles: [],
-  moduleLoading: { prefix: '', crossOrigin: '' },
-  serverConsumerModuleMap: {},
-  serverManifest: Object.fromEntries(
-    Array.from({ length: 8 }, (_, index) => [
-      `action-${index}`,
-      { id: 'server-module', chunks: [], name: 'action' },
-    ]),
-  ),
-};
-
-let mapArrayConstructions = 0;
-if (scenario === 'cycle') {
-  const NativeMap = Map;
-  global.Map = class CountedMap extends NativeMap {
-    constructor(iterable) {
-      if (Array.isArray(iterable)) {
-        mapArrayConstructions += 1;
-      }
-      super(iterable);
-    }
-  };
-}
-
-const server = require(path.resolve(serverPath));
-
-function output(value) {
-  process.stdout.write(JSON.stringify(value), () => process.exit(0));
-}
-
-async function main() {
-  switch (scenario) {
-    case 'cycle': {
-      const body = new FormData();
-      body.set(
-        '0',
-        JSON.stringify([
-          ...Array.from({ length: 8 }, (_, index) => [`key-${index}`, index]),
-          ...Array.from({ length: 8 }, () => '$Q0'),
-        ]),
-      );
-      let error;
-      try {
-        await server.decodeReply(body);
-      } catch (caught) {
-        error = caught;
-      }
-      output({ mapArrayConstructions, rejected: error instanceof Error });
-      return;
-    }
-    case 'referenced-form-data': {
-      const body = new FormData();
-      body.append('_1_item', 'first');
-      body.append('_2_item', 'second');
-      body.append('0', JSON.stringify(['$K1', '$K2']));
-      let keyIterations = 0;
-      const originalKeys = body.keys.bind(body);
-      body.keys = () => {
-        keyIterations += 1;
-        return originalKeys();
-      };
-      const decoded = await server.decodeReply(body);
-      output({
-        keyIterations,
-        values: decoded.map(value => value.get('item')),
-      });
-      return;
-    }
-    case 'blob-type': {
-      const body = new FormData();
-      body.set('1', 'not-a-blob');
-      body.set('0', JSON.stringify('$B1'));
-      let error;
-      try {
-        await server.decodeReply(body);
-      } catch (caught) {
-        error = caught;
-      }
-      output({
-        rejected: error instanceof Error,
-        returnedString: error === undefined,
-      });
-      return;
-    }
-    case 'async-iterator': {
-      let throwCalls = 0;
-      const reason = new Error('iterator failed');
-      const iterator = {
-        next: () => Promise.reject(reason),
-        throw: () => {
-          throwCalls += 1;
-          return throwCalls < 6
-            ? Promise.reject(reason)
-            : {
-                // biome-ignore lint/suspicious/noThenProperty: The regression requires a deliberately pending thenable to bound the vulnerable recursion.
-                then: () => {},
-              };
-        },
-      };
-      const iterable = { [Symbol.asyncIterator]: () => iterator };
-      try {
-        await server.decodeReplyFromAsyncIterable(iterable);
-      } catch {}
-      await new Promise(resolve => setImmediate(resolve));
-      output({ throwCalls });
-      return;
-    }
-    case 'action-load': {
-      const body = new FormData();
-      for (let index = 0; index < 8; index += 1) {
-        body.append(`$ACTION_ID_action-${index}`, '');
-      }
-      const action = await server.decodeAction(body);
-      if (action === null) {
-        throw new Error('Expected an action');
-      }
-      const submitted = await action();
-      output({
-        moduleLoads,
-        submittedEntries: Array.from(submitted.entries()),
-      });
-      return;
-    }
-    case 'form-data-roundtrip': {
-      const client = require(path.resolve(clientPath));
-      const nested = new FormData();
-      nested.append('item', 'first');
-      nested.append('item', 'second');
-      const encoded = await client.encodeReply({ nested });
-      const decoded = await server.decodeReply(encoded);
-      output({ values: decoded.nested.getAll('item') });
-      return;
-    }
-    default:
-      throw new Error(`Unknown scenario: ${scenario}`);
-  }
-}
-
-main().catch(error => {
-  console.error(error);
-  process.exitCode = 1;
-});

package/tests/router/hooks.test.ts

@@ -1,40 +0,0 @@
-import {
-  modifyRoutes as canonicalModifyRoutes,
-  routerProviderRegistryHooks,
-} from '@modern-js/runtime/context';
-import * as tanstackHooks from '../../src/runtime/hooks';
-import { applyRouterRuntimeState } from '../../src/runtime/lifecycle';
-import { tanstackRouterPlugin as browserPlugin } from '../../src/runtime/plugin';
-import { tanstackRouterPlugin as nodePlugin } from '../../src/runtime/plugin.node';
-import { getTanstackRouterState } from '../../src/runtime/state';
-
-describe('tanstack router hooks single declaration source', () => {
-  test('re-exports the canonical hook instances owned by @modern-js/runtime', () => {
-    // Identity matters: separate instances would split the hook registry
-    // between the built-in router wrapper and this provider.
-    expect(tanstackHooks.modifyRoutes).toBe(canonicalModifyRoutes);
-    expect(tanstackHooks.routerProviderRegistryHooks).toBe(
-      routerProviderRegistryHooks,
-    );
-    expect(tanstackHooks.modifyRoutes).toBe(
-      routerProviderRegistryHooks.modifyRoutes,
-    );
-  });
-
-  test('both runtime plugins register the canonical hook registry object', () => {
-    expect(browserPlugin().registryHooks).toBe(routerProviderRegistryHooks);
-    expect(nodePlugin().registryHooks).toBe(routerProviderRegistryHooks);
-  });
-});
-
-describe('tanstack router runtime state accessor', () => {
-  test('returns undefined before a tanstack router instance is created', () => {
-    const context = {};
-
-    applyRouterRuntimeState(context as never, {
-      framework: 'tanstack',
-    });
-
-    expect(getTanstackRouterState(context)).toBeUndefined();
-  });
-});

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