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

package/tests/realm-isolation.test.ts

@@ -1,104 +0,0 @@
-import type { RouterProviderFactory } from '@modern-js/runtime-extensions/router-provider';
-import { rstest } from '@rstest/core';
-import type { RouterExtendsHooks } from '../src/runtime/hooks';
-
-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(() => {
-    rstest.resetModules();
-    (
-      globalThis as typeof globalThis & {
-        __webpack_require__?: { u: (chunkId: unknown) => string };
-      }
-    ).__webpack_require__ = { u: chunkId => String(chunkId) };
-  });
-
-  afterEach(() => {
-    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);
-    } finally {
-      warnSpy.mockRestore();
-    }
-  });
-});

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