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

package/tests/realm-isolation.test.ts

@@ -1,120 +0,0 @@
-import type { RouterProviderFactory } from '@modern-js/runtime-extensions/router-provider';
-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;
-  providers: typeof import('@modern-js/runtime-extensions/router-provider');
-  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');
-
-  const providers = await import(
-    '@modern-js/runtime-extensions/router-provider'
-  );
-  return {
-    context,
-    providers,
-    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,
-    onAfterCreateRouter: () => undefined,
-    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.providers.resolveRouterProvider('tanstack')).toBe(
-        verticalA.factory,
-      );
-      expect(warnSpy).toHaveBeenCalledWith(
-        expect.stringMatching(/keeping the first registration/),
-      );
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-});

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,23 +0,0 @@
-import {
-  modifyRoutes as canonicalModifyRoutes,
-  routerProviderRegistryHooks,
-} from '@modern-js/runtime/context';
-import * as tanstackHooks from '../../src/runtime/hooks';
-import { tanstackRouterPlugin as browserPlugin } from '../../src/runtime/plugin';
-import { tanstackRouterPlugin as nodePlugin } from '../../src/runtime/plugin.node';
-
-describe('tanstack router hooks single declaration source', () => {
-  test('re-exports and registers the canonical hook instances', () => {
-    // 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,
-    );
-    expect(browserPlugin().registryHooks).toBe(routerProviderRegistryHooks);
-    expect(nodePlugin().registryHooks).toBe(routerProviderRegistryHooks);
-  });
-});

package/tests/router/register.test.ts

@@ -1,8 +0,0 @@
-import { resolveRouterProvider } from '@modern-js/runtime-extensions/router-provider';
-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,262 +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;
-  Link: unknown;
-  hooks: Record<string, unknown>;
-  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-extensions/router-provider'
-  );
-  const { routerProviderRegistryHooks } = await import(
-    '../../src/runtime/hooks'
-  );
-  const { Link } = await import('../../src/runtime/prefetchLink');
-
-  return {
-    factory: tanstackRouterProviderFactory,
-    Link,
-    hooks: routerProviderRegistryHooks,
-    legacyRuntimeRouter,
-    resolveRouterProvider,
-    routerPlugin,
-  };
-}
-
-function initializeRouter(graph: CompatibilityGraph) {
-  const beforeRender: ((context: any, interrupt: () => void) => unknown)[] = [];
-  const plugin = graph.routerPlugin({ framework: 'tanstack' });
-  plugin.setup({
-    getHooks: () => graph.hooks,
-    getRuntimeConfig: () => ({ router: { framework: 'tanstack' } }),
-    onAfterCreateRouter: () => undefined,
-    onBeforeRender: (
-      callback: (context: any, interrupt: () => void) => unknown,
-    ) => beforeRender.push(callback),
-    wrapRoot: () => undefined,
-  });
-  const context: any = {};
-  for (const callback of beforeRender) callback(context, () => {});
-  return context.router as { Link: unknown };
-}
-
-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(initializeRouter(graph).Link).toBe(graph.Link);
-    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).not.toBe(graphA.routerPlugin);
-    expect(graphB.resolveRouterProvider('tanstack')).toBe(graphA.factory);
-    expect(initializeRouter(graphA).Link).toBe(graphA.Link);
-    expect(initializeRouter(graphB).Link).toBe(graphB.Link);
-    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/rscDecoderSecurity.test.ts

@@ -1,84 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-
-type DecoderScenario =
-  | 'async-iterator'
-  | 'blob-type'
-  | 'cycle'
-  | 'form-data-roundtrip';
-
-const resolvePackage = createRequire(
-  path.join(__dirname, 'rsc-decoder-security-resolver.cjs'),
-).resolve;
-const childPath = path.join(
-  __dirname,
-  'fixtures',
-  'rscDecoderSecurityChild.cjs',
-);
-
-function runDecoderScenario(options: {
-  entry: 'edge' | 'node';
-  scenario: DecoderScenario;
-}): Record<string, unknown> {
-  const result = spawnSync(
-    process.execPath,
-    [
-      '--conditions=react-server',
-      childPath,
-      options.scenario,
-      resolvePackage(`react-server-dom-rspack/server.${options.entry}`),
-      resolvePackage(`react-server-dom-rspack/client.${options.entry}`),
-    ],
-    {
-      encoding: 'utf8',
-      env: { ...process.env, NODE_ENV: 'production' },
-      timeout: 5_000,
-    },
-  );
-
-  if (result.error || result.status !== 0) {
-    throw new Error(
-      [
-        `RSC decoder child failed for ${options.entry}/production/${options.scenario}`,
-        result.stdout,
-        result.stderr,
-      ]
-        .filter(Boolean)
-        .join('\n'),
-      { cause: result.error },
-    );
-  }
-
-  return JSON.parse(result.stdout) as Record<string, unknown>;
-}
-
-for (const entry of ['node', 'edge'] as const) {
-  describe(`${entry} production Flight decoder security`, () => {
-    test('bounds cyclic Map reconstruction before invoking constructors', () => {
-      const result = runDecoderScenario({ entry, scenario: 'cycle' });
-
-      expect(result.rejected).toBe(true);
-      expect(result.mapArrayConstructions).toBeLessThanOrEqual(2);
-    });
-
-    test('round-trips referenced FormData through the public client and server APIs', () => {
-      expect(
-        runDecoderScenario({ entry, scenario: 'form-data-roundtrip' }),
-      ).toEqual({ values: ['first', 'second'] });
-    });
-
-    test('rejects a Blob reference backed by a string', () => {
-      expect(runDecoderScenario({ entry, scenario: 'blob-type' })).toEqual({
-        rejected: true,
-        returnedString: false,
-      });
-    });
-
-    test('does not recursively throw into a rejecting async iterator', () => {
-      expect(runDecoderScenario({ entry, scenario: 'async-iterator' })).toEqual(
-        { throwCalls: 1 },
-      );
-    });
-  });
-}