@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.3 → 3.9.0-ultramodern.5

package/tests/routerProvider.test.ts

@@ -0,0 +1,38 @@
+import {
+  createRouterPlugin,
+  registerRouterProvider,
+  unsafe_resetRouterProvidersForTesting,
+} from '../src/routerProvider';
+
+afterEach(() => unsafe_resetRouterProvidersForTesting());
+
+test('selects the injected app-local factory from runtime config and preserves native hook objects', () => {
+  const registryHooks = { afterCreate: { call() {} } };
+  const defaultFactory = rstest.fn(() => ({ setup: rstest.fn() }));
+  const setup = rstest.fn();
+  const localFactory = rstest.fn(() => ({ registryHooks, setup }));
+  const plugin = createRouterPlugin({
+    defaultProvider: { name: 'native', factory: defaultFactory },
+    registryHooks,
+    localProviders: [{ name: 'custom', factory: localFactory }],
+  })();
+  const api = { getRuntimeConfig: () => ({ router: { framework: 'custom' } }) };
+  expect(plugin.registryHooks).toBe(registryHooks);
+  plugin.setup(api);
+  expect(localFactory).toHaveBeenCalledWith({});
+  expect(setup).toHaveBeenCalledWith(api);
+  expect(defaultFactory).not.toHaveBeenCalled();
+});
+
+test('does not resolve missing local providers through the global compatibility registry', () => {
+  const foreign = rstest.fn(() => ({}));
+  registerRouterProvider('foreign', foreign);
+  const factory = createRouterPlugin({
+    defaultProvider: { name: 'native', factory: () => ({}) },
+    registryHooks: {},
+  });
+  expect(() =>
+    factory({ framework: 'foreign' }).setup({ getRuntimeConfig: () => ({}) }),
+  ).toThrow(/app-owned router provider realm/);
+  expect(foreign).not.toHaveBeenCalled();
+});

package/tests/routerState.test.ts

@@ -0,0 +1,157 @@
+import { createRuntimeContextExtension } from '../src/contextExtensions';
+import {
+  applyRouterRuntimeState,
+  applyRouterServerPrepareResult,
+  cleanupRouterRuntimeState,
+  createRouterRuntimeState,
+  createRouterServerSnapshot,
+  getRouterHydrationScripts,
+  getRouterMatchedRouteIds,
+  getRouterRuntimeState,
+  getRouterServerSnapshot,
+  type InternalRouterRuntimeState,
+} from '../src/routerState';
+
+describe('router state primitives', () => {
+  it('normalizes snapshots without changing explicit values or input objects', () => {
+    const matches = [
+      { routeId: 'route-a', assetRouteId: 'asset-a' },
+      { routeId: 'route-b' },
+    ];
+    const snapshot = {
+      framework: 'custom',
+      hydrationScript: '<script>first()</script>',
+      matches,
+    };
+
+    expect(createRouterServerSnapshot(snapshot)).toEqual({
+      ...snapshot,
+      hydrationScripts: ['<script>first()</script>'],
+      matchedRouteIds: ['asset-a', 'route-b'],
+    });
+    expect(snapshot).not.toHaveProperty('hydrationScripts');
+    expect(snapshot).not.toHaveProperty('matchedRouteIds');
+    expect(
+      createRouterServerSnapshot({
+        ...snapshot,
+        hydrationScripts: ['<script>explicit()</script>'],
+        matchedRouteIds: [],
+      }),
+    ).toMatchObject({
+      hydrationScript: '<script>first()</script>',
+      hydrationScripts: ['<script>explicit()</script>'],
+      matchedRouteIds: [],
+    });
+  });
+
+  it('preserves snapshot precedence and a captured snapshot across client state updates', () => {
+    const context = { requestId: 'one' };
+    expect(
+      applyRouterRuntimeState(context, {
+        framework: 'custom',
+        basename: '/client',
+        hydrationScripts: ['client'],
+        matchedRouteIds: ['client-route'],
+        serverSnapshot: {
+          basename: '/server',
+          hydrationScripts: ['server'],
+          matchedRouteIds: ['server-route'],
+        },
+      }),
+    ).toBe(context);
+    const snapshot = getRouterServerSnapshot(context);
+    expect(snapshot).toMatchObject({
+      framework: 'custom',
+      basename: '/server',
+      hydrationScripts: ['server'],
+      matchedRouteIds: ['server-route'],
+    });
+    expect(getRouterHydrationScripts(context)).toEqual(['server']);
+    expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
+
+    applyRouterRuntimeState(context, {
+      framework: 'custom',
+      instance: { client: true },
+    });
+    expect(getRouterRuntimeState(context)?.serverSnapshot).toBeUndefined();
+    expect(getRouterServerSnapshot(context)).toBe(snapshot);
+    expect(getRouterHydrationScripts(context)).toEqual(['server']);
+    expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
+  });
+
+  it('shares interned slots across accessors and context spreads without serializing state', () => {
+    const context = { requestId: 'one' };
+    const state: InternalRouterRuntimeState = {
+      framework: 'custom',
+      instance: { private: true },
+      hydrationScript: 'legacy',
+      matches: [{ routeId: 'route', assetRouteId: 'asset' }],
+    };
+    const otherAccessor =
+      createRuntimeContextExtension<InternalRouterRuntimeState>(
+        '@modern-js/runtime:router-runtime-state',
+      );
+    otherAccessor.set(context, state);
+    expect(getRouterRuntimeState({ ...context })).toBe(state);
+    expect(getRouterHydrationScripts(context)).toEqual(['legacy']);
+    expect(getRouterMatchedRouteIds(context)).toEqual(['asset']);
+    expect(Object.keys(context)).toEqual(['requestId']);
+    expect(JSON.stringify(context)).toBe('{"requestId":"one"}');
+    expect(getRouterRuntimeState({})).toBeUndefined();
+  });
+
+  it('applies server prepare overrides and awaits cleanup without propagating failures', async () => {
+    const context = {};
+    const stateCleanup = rstest.fn();
+    const cleanup = rstest.fn(async () => {
+      await Promise.resolve();
+    });
+    expect(
+      applyRouterServerPrepareResult(context, {
+        state: {
+          framework: 'custom',
+          cleanup: stateCleanup,
+          serverSnapshot: { statusCode: 200 },
+        },
+        snapshot: { statusCode: 299 },
+        cleanup,
+      }),
+    ).toBe(context);
+    expect(getRouterServerSnapshot(context)?.statusCode).toBe(299);
+    await cleanupRouterRuntimeState(context);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+    expect(stateCleanup).not.toHaveBeenCalled();
+
+    applyRouterRuntimeState(context, {
+      framework: 'custom',
+      cleanup: async () => {
+        throw new Error('cleanup failed');
+      },
+    });
+    await expect(cleanupRouterRuntimeState(context)).resolves.toBeUndefined();
+    await expect(cleanupRouterRuntimeState({})).resolves.toBeUndefined();
+  });
+
+  it('keeps empty state empty and derives server data only when present', () => {
+    expect(createRouterRuntimeState({ framework: 'custom' })).toEqual({
+      framework: 'custom',
+    });
+    expect(getRouterHydrationScripts({})).toEqual([]);
+    expect(getRouterMatchedRouteIds({})).toBeUndefined();
+    expect(
+      createRouterRuntimeState({
+        framework: 'custom',
+        matches: [{ routeId: 'root' }],
+        hydrationScripts: ['first', 'second'],
+      }),
+    ).toMatchObject({
+      hydrationScript: 'first',
+      matchedRouteIds: ['root'],
+      serverSnapshot: {
+        framework: 'custom',
+        hydrationScripts: ['first', 'second'],
+        matchedRouteIds: ['root'],
+      },
+    });
+  });
+});

package/tests/routerStatePlugin.test.ts

@@ -0,0 +1,108 @@
+import {
+  applyRouterRuntimeState,
+  getRouterRuntimeState,
+  getRouterServerSnapshot,
+} from '../src/routerState';
+import { createRouterStatePlugin } from '../src/routerStatePlugin';
+
+function install() {
+  const registryHooks = { onAfterCreateRouter: { call() {} } };
+  const plugin = createRouterStatePlugin({ registryHooks });
+  let beforeRender!: (context: object) => void;
+  let afterCreate!: Parameters<
+    Parameters<typeof plugin.setup>[0]['onAfterCreateRouter']
+  >[0];
+  plugin.setup({
+    onBeforeRender: callback => {
+      beforeRender = callback;
+    },
+    onAfterCreateRouter: callback => {
+      afterCreate = callback;
+    },
+  });
+  return { plugin, registryHooks, beforeRender, afterCreate };
+}
+
+test('keeps injected hooks and per-context policies stable without sharing app values', () => {
+  const { plugin, registryHooks, beforeRender } = install();
+  expect(plugin.registryHooks).toBe(registryHooks);
+  const first: any = {};
+  const second: any = {};
+  beforeRender(first);
+  const policy = first.linkPrefetchPolicy;
+  beforeRender(first);
+  beforeRender(second);
+  expect(first.linkPrefetchPolicy).toBe(policy);
+  expect(second.linkPrefetchPolicy).not.toBe(policy);
+});
+
+test('stores the exact native client instance and retains an earlier server snapshot', () => {
+  const { afterCreate } = install();
+  const context = {};
+  applyRouterRuntimeState(context, {
+    framework: 'react-router',
+    serverSnapshot: { statusCode: 207, matchedRouteIds: ['server'] },
+  });
+  const router = { navigate() {} };
+  afterCreate({
+    framework: 'react-router',
+    phase: 'client-create',
+    runtimeContext: context,
+    router,
+    basename: '/app',
+  });
+  expect(getRouterRuntimeState(context)?.instance).toBe(router);
+  expect(getRouterServerSnapshot(context)?.statusCode).toBe(207);
+});
+
+test('projects loader data, errors and valid route ids from injected SSR input', () => {
+  const { afterCreate } = install();
+  const errors = { route: new Error('route error') };
+  const context = {
+    routerContext: {
+      statusCode: 503,
+      errors,
+      loaderData: { root: { ok: true } },
+      matches: [{ route: { id: 'root' } }, { route: {} }],
+    },
+  };
+  afterCreate({
+    framework: 'react-router',
+    phase: 'ssr-prepare',
+    runtimeContext: context,
+    router: context.routerContext,
+    basename: '/nested',
+  });
+  expect(getRouterRuntimeState(context)?.instance).toBe(context.routerContext);
+  expect(getRouterServerSnapshot(context)).toMatchObject({
+    framework: 'react-router',
+    basename: '/nested',
+    statusCode: 503,
+    matchedRouteIds: ['root'],
+    routerData: { loaderData: context.routerContext.loaderData, errors },
+  });
+});
+
+test('leaves other providers and incomplete native preparation untouched', () => {
+  const { afterCreate } = install();
+  const context = {};
+  applyRouterRuntimeState(context, {
+    framework: 'tanstack',
+    hydrationScripts: ['<script>hydrate()</script>'],
+    matches: [{ routeId: 'r', assetRouteId: 'asset' }],
+  });
+  const state = getRouterRuntimeState(context);
+  afterCreate({
+    framework: 'tanstack',
+    phase: 'ssr-prepare',
+    runtimeContext: context,
+  });
+  expect(getRouterRuntimeState(context)).toBe(state);
+  const incomplete = {};
+  afterCreate({
+    framework: 'react-router',
+    phase: 'ssr-prepare',
+    runtimeContext: incomplete,
+  });
+  expect(getRouterRuntimeState(incomplete)).toBeUndefined();
+});

package/tests/runtimeContextProjection.test.ts

@@ -0,0 +1,135 @@
+import { createRuntimeContextExtension } from '../src/contextExtensions';
+import { projectRuntimeContext } from '../src/runtimeContextProjection';
+
+describe('fork runtime context projection', () => {
+  it('removes copied enumerable extension state only from the public projection', () => {
+    const context = { isBrowser: false, requestId: 'original' };
+    const extension = createRuntimeContextExtension<object>('test:projection');
+    const state = { router: 'private' };
+    extension.set(context, state);
+    const publicInput = { ...context };
+
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext: publicInput },
+      { context, isRsc: false },
+    );
+
+    expect(result.internalContext).toBe(context);
+    expect(result.publicContext).not.toBe(publicInput);
+    expect(extension.get(result.internalContext)).toBe(state);
+    expect(extension.get(publicInput)).toBe(state);
+    expect(extension.get(result.publicContext)).toBeUndefined();
+    expect(Object.getOwnPropertySymbols(result.publicContext)).not.toContain(
+      Symbol.for('@modern-js/runtime:context-extensions'),
+    );
+  });
+
+  it('projects RSC request fields and locals without mutating the original response', () => {
+    const response = {
+      setHeader: rstest.fn(),
+      status: rstest.fn(),
+      locals: { tenant: 'tractor-store' },
+    };
+    const request = {
+      params: { category: 'compact' },
+      pathname: '/tractors',
+      query: { sort: 'price' },
+      headers: { accept: 'text/html' },
+      host: 'example.test',
+      url: 'https://example.test/tractors?sort=price',
+      raw: new Request('https://example.test/tractors'),
+    };
+    const context = { isBrowser: false, ssrContext: { request, response } };
+    const extension = createRuntimeContextExtension<object>('test:rsc');
+    const state = { original: true };
+    extension.set(context, state);
+    const publicContext = { isBrowser: false };
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext },
+      { context, isRsc: true },
+    );
+    const internal = result.internalContext as typeof result.internalContext & {
+      context: { request: object; response: typeof response };
+      requestContext: { request: object; response: typeof response };
+    };
+    const publicValue = result.publicContext as typeof internal;
+
+    expect(internal).not.toBe(context);
+    expect(internal.ssrContext).toBeUndefined();
+    expect(internal.requestContext).toBe(publicValue.requestContext);
+    expect(internal.context).toBe(internal.requestContext);
+    expect(publicValue.context).toBe(internal.requestContext);
+    expect(internal.requestContext.request).toEqual({
+      params: { category: 'compact' },
+      pathname: '/tractors',
+      query: { sort: 'price' },
+      headers: { accept: 'text/html' },
+      host: 'example.test',
+      url: 'https://example.test/tractors?sort=price',
+      userAgent: undefined,
+      cookie: undefined,
+      referer: undefined,
+    });
+    expect(internal.requestContext.response).toEqual({
+      locals: response.locals,
+    });
+    expect(internal.requestContext.response.locals).toBe(response.locals);
+    expect(Object.keys(internal.requestContext.response)).toEqual(['locals']);
+    expect(typeof internal.requestContext.response.setHeader).toBe('function');
+    expect(typeof internal.requestContext.response.status).toBe('function');
+    expect(context.ssrContext.response).toBe(response);
+    expect(Object.keys(response)).toEqual(['setHeader', 'status', 'locals']);
+    expect(extension.get(context)).toBe(state);
+    // Internal RSC copy behavior is retained pending separate Flight proof.
+    expect(extension.get(internal)).toBe(state);
+    expect(extension.get(publicValue)).toBeUndefined();
+  });
+
+  it('provides the existing empty RSC request fallback when no SSR context exists', () => {
+    const context = { isBrowser: false };
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext: { ...context } },
+      { context, isRsc: true },
+    );
+    expect(result.internalContext).toMatchObject({
+      context: {
+        request: {
+          params: {},
+          pathname: '',
+          query: {},
+          headers: {},
+          host: '',
+          url: '',
+        },
+        response: { locals: {} },
+      },
+      requestContext: {
+        request: {
+          params: {},
+          pathname: '',
+          query: {},
+          headers: {},
+          host: '',
+          url: '',
+        },
+        response: { locals: {} },
+      },
+    });
+    expect(result.internalContext).not.toHaveProperty('ssrContext');
+    expect(context).toEqual({ isBrowser: false });
+  });
+
+  it('does not apply server request projection to an RSC browser context', () => {
+    const context = {
+      isBrowser: true,
+      ssrContext: { request: {}, response: { locals: { browser: true } } },
+    };
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext: { ...context } },
+      { context, isRsc: true },
+    );
+    expect(result.internalContext).toBe(context);
+    expect(result.internalContext.ssrContext).toBe(context.ssrContext);
+    expect(result.publicContext).not.toHaveProperty('requestContext');
+  });
+});

package/tests/shellStream.test.ts

@@ -83,3 +83,40 @@ describe('conserving web shell stream', () => {
     expect(published).toEqual(['previous']);
   });
 });
+
+test('cancellation waits for the owned source cancellation to finish once', async () => {
+  let release!: () => void;
+  let started!: () => void;
+  const cancelling = new Promise<void>(resolve => {
+    started = resolve;
+  });
+  const gate = new Promise<void>(resolve => {
+    release = resolve;
+  });
+  const cancel = rstest.fn(async () => {
+    started();
+    await gate;
+  });
+  const source = new ReadableStream<Uint8Array>({ cancel });
+  const reader = createConservingWebShellStream(source, {}, MARKER).getReader();
+  let settled = false;
+  const cancellation = reader.cancel('stop').then(() => {
+    settled = true;
+  });
+  await cancelling;
+  expect(settled).toBe(false);
+  release();
+  await cancellation;
+  expect(cancel).toHaveBeenCalledExactlyOnceWith('stop');
+});
+
+test('cancellation propagates an owned source cleanup failure', async () => {
+  const source = new ReadableStream<Uint8Array>({
+    cancel() {
+      throw new Error('cleanup failed');
+    },
+  });
+  await expect(
+    createConservingWebShellStream(source, {}, MARKER).cancel('stop'),
+  ).rejects.toThrow('cleanup failed');
+});