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

package/tests/request-policy/traceparent.test.ts

@@ -0,0 +1,55 @@
+import { parseTraceparent } from '@modern-js/runtime-extensions/request-context';
+
+describe('parseTraceparent', () => {
+  const traceId = '4bf92f3577b34da6a3ce929d0e0e4736';
+  const spanId = '00f067aa0ba902b7';
+
+  test.each([
+    ['01', true],
+    ['00', false],
+  ])('parses a valid traceparent with flags %s', (flags, sampled) => {
+    expect(parseTraceparent(`00-${traceId}-${spanId}-${flags}`)).toEqual({
+      traceId,
+      spanId,
+      sampled,
+    });
+  });
+
+  test('lowercases mixed-case ids and trims surrounding whitespace', () => {
+    expect(
+      parseTraceparent(
+        `  00-${traceId.toUpperCase()}-${spanId.toUpperCase()}-01  `,
+      ),
+    ).toEqual({
+      traceId,
+      spanId,
+      sampled: true,
+    });
+  });
+
+  test('reads the sampled bit from arbitrary flag values', () => {
+    expect(parseTraceparent(`00-${traceId}-${spanId}-03`)?.sampled).toBe(true);
+    expect(parseTraceparent(`00-${traceId}-${spanId}-02`)?.sampled).toBe(false);
+  });
+
+  test('rejects missing, empty, and malformed headers', () => {
+    expect(parseTraceparent(undefined)).toBeUndefined();
+    expect(parseTraceparent(null)).toBeUndefined();
+    expect(parseTraceparent('')).toBeUndefined();
+    expect(parseTraceparent('not-a-traceparent')).toBeUndefined();
+    expect(parseTraceparent(`00-${traceId}-${spanId}`)).toBeUndefined();
+    expect(parseTraceparent(`01-${traceId}-${spanId}-01`)).toBeUndefined();
+    expect(
+      parseTraceparent(`00-${traceId.slice(1)}-${spanId}-01`),
+    ).toBeUndefined();
+  });
+
+  test('rejects all-zero trace and span ids per the W3C spec', () => {
+    expect(
+      parseTraceparent(`00-${'0'.repeat(32)}-${spanId}-01`),
+    ).toBeUndefined();
+    expect(
+      parseTraceparent(`00-${traceId}-${'0'.repeat(16)}-01`),
+    ).toBeUndefined();
+  });
+});

package/tests/request-policy/transport-retry.test.ts

@@ -0,0 +1,370 @@
+import { executeWithResilience } from '../../src/request-policy/transport';
+
+const requestUrl = 'https://modern.test/api';
+const retryableStatusCodes = [408, 425, 429, 500, 502, 503, 504];
+const nonRetryableStatusCodes = [400, 401, 404, 418, 501];
+
+const flushMicrotasks = async () => {
+  await Promise.resolve();
+  await Promise.resolve();
+};
+
+const createNamedError = (name: string) => {
+  const error = new Error(name);
+  (error as any).name = name;
+  return error;
+};
+
+const createStatusError = (status: number) => {
+  const error = new Error(`status ${status}`);
+  (error as any).status = status;
+  return error;
+};
+
+const executeRetryRequest = ({
+  fetcher,
+  method = 'GET',
+  init = { method },
+  retry,
+  onDegraded,
+}: {
+  fetcher: (...args: any[]) => Promise<any>;
+  method?: string;
+  init?: Record<string, any>;
+  retry?: Record<string, any>;
+  onDegraded?: (event: any) => void;
+}) =>
+  executeWithResilience({
+    requestId: 'transport-retry-test',
+    target: 'browser',
+    method,
+    url: requestUrl,
+    init,
+    fetcher,
+    transport: {
+      retry,
+      onDegraded,
+    },
+  });
+
+describe('transport retry behavior', () => {
+  test.each([
+    'FetchError',
+    'TimeoutError',
+  ])('retries %s up to the configured max then rejects', async errorName => {
+    rs.useFakeTimers();
+    const errors = [
+      createNamedError(errorName),
+      createNamedError(errorName),
+      createNamedError(errorName),
+    ];
+    let callCount = 0;
+    const fetcher = rs.fn(async () => {
+      const error = errors[callCount];
+      callCount += 1;
+      throw error;
+    });
+
+    const pending = executeRetryRequest({
+      fetcher,
+      retry: {
+        retries: 2,
+        baseDelayMs: 10,
+        maxDelayMs: 100,
+        jitterRatio: 0,
+      },
+    });
+    const observed = pending.catch(error => error);
+
+    try {
+      await flushMicrotasks();
+      expect(fetcher).toHaveBeenCalledTimes(1);
+
+      await rs.advanceTimersByTimeAsync(9);
+      expect(fetcher).toHaveBeenCalledTimes(1);
+      await rs.advanceTimersByTimeAsync(1);
+      await flushMicrotasks();
+      expect(fetcher).toHaveBeenCalledTimes(2);
+
+      await rs.advanceTimersByTimeAsync(19);
+      expect(fetcher).toHaveBeenCalledTimes(2);
+      await rs.advanceTimersByTimeAsync(1);
+      await flushMicrotasks();
+      expect(fetcher).toHaveBeenCalledTimes(3);
+      await expect(observed).resolves.toBe(errors[2]);
+    } finally {
+      await rs.advanceTimersByTimeAsync(1000);
+      await observed;
+      rs.useRealTimers();
+    }
+  });
+
+  test('should not retry caller-aborted requests', async () => {
+    rs.useFakeTimers();
+    const onDegraded = rs.fn();
+    const abortController = new AbortController();
+    abortController.abort();
+    const abortError = createNamedError('AbortError');
+    const fetcher = rs.fn(async (_url: string, init: RequestInit) => {
+      expect(init.signal).toBe(abortController.signal);
+      throw abortError;
+    });
+
+    const pending = executeRetryRequest({
+      fetcher,
+      init: {
+        method: 'GET',
+        signal: abortController.signal,
+      },
+      retry: {
+        retries: 2,
+        baseDelayMs: 1,
+        maxDelayMs: 1,
+        jitterRatio: 0,
+      },
+      onDegraded,
+    });
+    const observed = pending.catch(error => error);
+
+    try {
+      await flushMicrotasks();
+      expect(fetcher).toHaveBeenCalledTimes(1);
+      expect(onDegraded).not.toHaveBeenCalledWith(
+        expect.objectContaining({ reason: 'retry' }),
+      );
+      await expect(observed).resolves.toBe(abortError);
+    } finally {
+      await rs.advanceTimersByTimeAsync(5);
+      await observed;
+      rs.useRealTimers();
+    }
+  });
+
+  test('retries default retryable status codes after the backoff delay', async () => {
+    rs.useFakeTimers();
+
+    try {
+      for (const statusCode of retryableStatusCodes) {
+        const retryableError = createStatusError(statusCode);
+        const response = { ok: true, status: 200 };
+        let callCount = 0;
+        const fetcher = rs.fn(async () => {
+          callCount += 1;
+          if (callCount === 1) {
+            throw retryableError;
+          }
+          return response;
+        });
+
+        const pending = executeRetryRequest({
+          fetcher,
+          retry: {
+            retries: 1,
+            baseDelayMs: 5,
+            maxDelayMs: 5,
+            jitterRatio: 0,
+          },
+        });
+
+        await flushMicrotasks();
+        expect(fetcher).toHaveBeenCalledTimes(1);
+        await rs.advanceTimersByTimeAsync(4);
+        expect(fetcher).toHaveBeenCalledTimes(1);
+        await rs.advanceTimersByTimeAsync(1);
+        await expect(pending).resolves.toBe(response);
+        expect(fetcher).toHaveBeenCalledTimes(2);
+      }
+    } finally {
+      await rs.advanceTimersByTimeAsync(1000);
+      rs.useRealTimers();
+    }
+  });
+
+  test('does not retry non-retryable status codes', async () => {
+    for (const statusCode of nonRetryableStatusCodes) {
+      const error = createStatusError(statusCode);
+      const fetcher = rs.fn(async () => {
+        throw error;
+      });
+
+      await expect(
+        executeRetryRequest({
+          fetcher,
+          retry: {
+            retries: 2,
+            baseDelayMs: 1,
+            maxDelayMs: 1,
+            jitterRatio: 0,
+          },
+        }),
+      ).rejects.toBe(error);
+      expect(fetcher).toHaveBeenCalledTimes(1);
+    }
+  });
+
+  test('uses a custom shouldRetry predicate instead of default rules', async () => {
+    rs.useFakeTimers();
+    const retryableByPolicy = createStatusError(400);
+    const response = { ok: true, status: 200 };
+    const shouldRetry = rs.fn(() => true);
+    let callCount = 0;
+    const fetcher = rs.fn(async () => {
+      callCount += 1;
+      if (callCount === 1) {
+        throw retryableByPolicy;
+      }
+      return response;
+    });
+
+    const pending = executeRetryRequest({
+      fetcher,
+      method: 'POST',
+      init: { method: 'POST' },
+      retry: {
+        retries: 1,
+        baseDelayMs: 7,
+        maxDelayMs: 7,
+        jitterRatio: 0,
+        shouldRetry,
+      },
+    });
+
+    try {
+      await flushMicrotasks();
+      expect(fetcher).toHaveBeenCalledTimes(1);
+      expect(shouldRetry).toHaveBeenCalledWith(
+        expect.objectContaining({
+          attempt: 1,
+          error: retryableByPolicy,
+          maxAttempts: 2,
+          method: 'POST',
+          statusCode: 400,
+        }),
+      );
+
+      await rs.advanceTimersByTimeAsync(6);
+      expect(fetcher).toHaveBeenCalledTimes(1);
+      await rs.advanceTimersByTimeAsync(1);
+      await expect(pending).resolves.toBe(response);
+      expect(fetcher).toHaveBeenCalledTimes(2);
+    } finally {
+      await rs.advanceTimersByTimeAsync(1000);
+      rs.useRealTimers();
+    }
+  });
+
+  test('does not retry non-idempotent methods by default', async () => {
+    const error = createNamedError('FetchError');
+    const fetcher = rs.fn(async () => {
+      throw error;
+    });
+
+    await expect(
+      executeRetryRequest({
+        fetcher,
+        method: 'POST',
+        init: { method: 'POST' },
+        retry: {
+          retries: 2,
+          baseDelayMs: 1,
+          maxDelayMs: 1,
+          jitterRatio: 0,
+        },
+      }),
+    ).rejects.toBe(error);
+    expect(fetcher).toHaveBeenCalledTimes(1);
+  });
+
+  test('timeout aborts the in-flight request when a caller signal is present', async () => {
+    rs.useFakeTimers();
+    const callerController = new AbortController();
+    const onDegraded = rs.fn();
+    let inFlightSignal: AbortSignal | undefined;
+    const fetcher = rs.fn((_url: string, init: RequestInit) => {
+      inFlightSignal = init.signal || undefined;
+      return new Promise((_, reject) => {
+        init.signal?.addEventListener('abort', () => {
+          reject(createNamedError('AbortError'));
+        });
+      });
+    });
+
+    const pending = executeWithResilience({
+      requestId: 'transport-timeout-with-caller-signal',
+      target: 'browser',
+      method: 'GET',
+      url: requestUrl,
+      init: {
+        method: 'GET',
+        signal: callerController.signal,
+      },
+      fetcher,
+      transport: {
+        timeoutMs: 25,
+        onDegraded,
+      },
+    });
+    const observed = pending.catch(error => error);
+
+    try {
+      await flushMicrotasks();
+      expect(inFlightSignal?.aborted).toBe(false);
+      await rs.advanceTimersByTimeAsync(25);
+
+      await expect(observed).resolves.toMatchObject({ name: 'TimeoutError' });
+      expect(inFlightSignal?.aborted).toBe(true);
+      expect(callerController.signal.aborted).toBe(false);
+      expect(onDegraded).toHaveBeenCalledWith(
+        expect.objectContaining({ reason: 'timeout', timeoutMs: 25 }),
+      );
+    } finally {
+      await rs.advanceTimersByTimeAsync(1000);
+      await observed;
+      rs.useRealTimers();
+    }
+  });
+
+  test('caller abort still cancels a request that has a timeout', async () => {
+    rs.useFakeTimers();
+    const callerController = new AbortController();
+    const onDegraded = rs.fn();
+    let inFlightSignal: AbortSignal | undefined;
+    const abortError = createNamedError('AbortError');
+    const fetcher = rs.fn((_url: string, init: RequestInit) => {
+      inFlightSignal = init.signal || undefined;
+      return new Promise((_, reject) => {
+        init.signal?.addEventListener('abort', () => reject(abortError));
+      });
+    });
+
+    const pending = executeWithResilience({
+      requestId: 'transport-caller-abort-with-timeout',
+      target: 'browser',
+      method: 'GET',
+      url: requestUrl,
+      init: {
+        method: 'GET',
+        signal: callerController.signal,
+      },
+      fetcher,
+      transport: {
+        timeoutMs: 25,
+        onDegraded,
+      },
+    });
+    const observed = pending.catch(error => error);
+
+    try {
+      await flushMicrotasks();
+      callerController.abort();
+
+      await expect(observed).resolves.toBe(abortError);
+      expect(inFlightSignal?.aborted).toBe(true);
+      expect(onDegraded).not.toHaveBeenCalled();
+    } finally {
+      await rs.advanceTimersByTimeAsync(1000);
+      await observed;
+      rs.useRealTimers();
+    }
+  });
+});

package/tests/routeHydration.test.ts

@@ -0,0 +1,180 @@
+import {
+  createRouteHydrationScriptTags,
+  getMatchedRouteChunks,
+  injectBeforeHydrationEntryScript,
+  orderHydrationScriptChunks,
+  replaceChunkJsPlaceholder,
+} from '../src/routeHydration';
+
+const manifest = {
+  routeAssets: {
+    layout: { assets: ['/shared.js', '/layout.css'] },
+    page: { assets: ['/page.js', '/shared.js'] },
+    empty: {},
+    missing: undefined,
+    'async-main': { assets: ['/shared.js', '/async-main.hash.js'] },
+  },
+};
+
+const tag = (src: string) => `<script src="${src}"></script>`;
+
+describe('route hydration policy', () => {
+  it('maps matched assets in route order without deduplicating or filtering', () => {
+    const mapped = getMatchedRouteChunks(
+      manifest,
+      ['layout', 'unknown', 'empty', 'missing', 'page'],
+      asset => ({ url: asset, marker: 'preserved' }),
+    );
+    expect(mapped).toEqual(
+      ['/shared.js', '/layout.css', '/page.js', '/shared.js'].map(url => ({
+        url,
+        marker: 'preserved',
+      })),
+    );
+  });
+
+  it('returns no chunks for an explicit missing manifest or empty matches', () => {
+    const toChunk = rstest.fn((url: string) => ({ url }));
+    expect(getMatchedRouteChunks(undefined, ['page'], toChunk)).toEqual([]);
+    expect(getMatchedRouteChunks({}, ['page'], toChunk)).toEqual([]);
+    expect(getMatchedRouteChunks(manifest, [], toChunk)).toEqual([]);
+    expect(toChunk).not.toHaveBeenCalled();
+    expect(createRouteHydrationScriptTags(undefined, ['page'], 'main')).toBe(
+      '',
+    );
+    expect(createRouteHydrationScriptTags({}, ['page'], 'main')).toBe('');
+  });
+
+  it('keeps dependencies, collected chunks and route chunks before async entry', () => {
+    const dependency = { url: '/dependency.js', marker: 'dependency' };
+    const collected = { url: '/collected.js', marker: 'collected' };
+    const route = { url: '/route.js', marker: 'route' };
+    const entry = { url: '/async-main.hash.js', marker: 'entry' };
+    const asyncEntryChunks = [entry, dependency];
+    const result = orderHydrationScriptChunks({
+      asyncEntryChunks,
+      collectedChunks: [collected, { ...dependency, marker: 'duplicate' }],
+      matchedRouteChunks: [route, { url: '' }, {}, { ...collected }],
+      entryName: 'main',
+    });
+    expect(result).toEqual([dependency, collected, route, entry]);
+    expect(result[0]).toBe(dependency);
+    expect(result[1]).toBe(collected);
+    expect(asyncEntryChunks).toEqual([entry, dependency]);
+  });
+
+  it('classifies async entries using filename while retaining the JS URL rule', () => {
+    const entry = { url: '/opaque.js', filename: 'nested/async-main-hash.js' };
+    const queried = { url: '/async-main.js?hash=1' };
+    const otherEntry = { url: '/async-other.js' };
+    const asset = { url: '/async-main.css' };
+    const route = { url: '/route.js' };
+    expect(
+      orderHydrationScriptChunks({
+        asyncEntryChunks: [entry, queried, otherEntry, asset],
+        collectedChunks: [],
+        matchedRouteChunks: [route],
+        entryName: 'main',
+      }),
+    ).toEqual([queried, otherEntry, asset, route, entry]);
+  });
+
+  it('serializes unique JS route assets then async assets and matches exact src', () => {
+    expect(
+      createRouteHydrationScriptTags(manifest, ['layout', 'page'], 'main', {
+        template: `${tag('/page.js.map')}${tag('/shared.js')}`,
+      }),
+    ).toBe(`${tag('/page.js')} ${tag('/async-main.hash.js')}`);
+    expect(createRouteHydrationScriptTags(manifest, [], 'main')).toBe(
+      `${tag('/shared.js')} ${tag('/async-main.hash.js')}`,
+    );
+  });
+
+  it('escapes asset and nonce attributes and omits empty nonce', () => {
+    const unsafeManifest = {
+      routeAssets: {
+        page: { assets: ['/route" onload="alert(1)&x=<tag>.js'] },
+      },
+    };
+    expect(
+      createRouteHydrationScriptTags(unsafeManifest, ['page'], 'main', {
+        nonce: 'nonce"&<value>',
+      }),
+    ).toBe(
+      '<script src="/route&quot; onload=&quot;alert(1)&amp;x=&lt;tag&gt;.js" nonce="nonce&quot;&amp;&lt;value&gt;"></script>',
+    );
+    expect(
+      createRouteHydrationScriptTags(manifest, ['page'], 'other', {
+        nonce: '',
+      }),
+    ).toBe(`${tag('/page.js')} ${tag('/shared.js')}`);
+  });
+
+  it('prefers the main entry even when an async entry appears earlier', () => {
+    const asyncEntry = tag('/async-main.hash.js');
+    const entry =
+      "<script defer src='/nested/main-hash.js?build=1#hash'></script>";
+    const template = `${asyncEntry}${entry}`;
+    expect(injectBeforeHydrationEntryScript(template, 'ROUTE', 'main')).toBe(
+      `${asyncEntry}ROUTE${entry}`,
+    );
+  });
+
+  it('falls back to async entry and preserves templates with no entry', () => {
+    const asyncEntry = tag('/nested/async-main.js');
+    expect(injectBeforeHydrationEntryScript(asyncEntry, 'ROUTE', 'main')).toBe(
+      `ROUTE${asyncEntry}`,
+    );
+    expect(injectBeforeHydrationEntryScript(tag('/index.js'), 'ROUTE')).toBe(
+      `ROUTE${tag('/index.js')}`,
+    );
+    const other = tag('/other-main.js');
+    expect(injectBeforeHydrationEntryScript(other, 'ROUTE', 'main')).toBe(
+      other,
+    );
+    expect(injectBeforeHydrationEntryScript(asyncEntry, '', 'main')).toBe(
+      asyncEntry,
+    );
+  });
+
+  it('moves placeholder scripts before hydration and replaces literal text safely', () => {
+    const placeholder = '<!-- chunks -->';
+    const scripts = '<script src="/$&-$`-$\'.js"></script>';
+    const entry = tag('/main.js');
+    expect(
+      replaceChunkJsPlaceholder(
+        `${entry}${placeholder}`,
+        scripts,
+        'main',
+        placeholder,
+      ),
+    ).toBe(`${scripts}${entry}`);
+    expect(
+      replaceChunkJsPlaceholder(
+        `before${placeholder}after`,
+        scripts,
+        'main',
+        placeholder,
+      ),
+    ).toBe(`before${scripts}after`);
+    expect(replaceChunkJsPlaceholder(entry, scripts, 'main', placeholder)).toBe(
+      entry,
+    );
+    expect(
+      replaceChunkJsPlaceholder(
+        `${entry}${placeholder}`,
+        '',
+        'main',
+        placeholder,
+      ),
+    ).toBe(entry);
+    expect(
+      replaceChunkJsPlaceholder(
+        `${placeholder}${placeholder}`,
+        '',
+        undefined,
+        placeholder,
+      ),
+    ).toBe(placeholder);
+  });
+});

package/tests/routerPrefetchPolicy.test.ts

@@ -0,0 +1,102 @@
+import { createRouterPrefetchPolicy } from '../src/routerPrefetchPolicy';
+
+const settle = async () => {
+  for (let turn = 0; turn < 10; turn += 1) await Promise.resolve();
+};
+
+afterEach(() => rstest.useRealTimers());
+
+test('implements render defaults and cancels delayed intent before dispatch', async () => {
+  rstest.useFakeTimers();
+  const policy = createRouterPrefetchPolicy();
+  const notify = rstest.fn();
+  const render = policy.observe({ element: null, notify });
+  expect(notify).toHaveBeenLastCalledWith({ code: true, data: true });
+  render.dispose();
+  const intent = policy.observe({
+    element: null,
+    prefetch: 'none',
+    preload: 'intent',
+    notify,
+  });
+  intent.onIntent();
+  intent.onCancel();
+  await rstest.advanceTimersByTimeAsync(100);
+  expect(notify).toHaveBeenLastCalledWith({ code: false, data: false });
+  intent.onIntent();
+  await rstest.advanceTimersByTimeAsync(100);
+  expect(notify).toHaveBeenLastCalledWith({ code: true, data: false });
+  intent.dispose();
+});
+
+test('limits concurrent loads, removes cancelled queued keys, and retries rejected loads', async () => {
+  const policy = createRouterPrefetchPolicy();
+  const context = {};
+  const loader = {};
+  const started: number[] = [];
+  const releases: (() => void)[] = [];
+  const schedule = (id: number) =>
+    policy.schedule({
+      runtimeContext: context,
+      chunkLoader: loader,
+      publicPath: '/',
+      key: String(id),
+      run: () => {
+        started.push(id);
+        return new Promise<void>(resolve => releases.push(resolve));
+      },
+    });
+  const cancellations = Array.from({ length: 6 }, (_, id) => schedule(id));
+  await settle();
+  expect(started).toEqual([0, 1, 2, 3]);
+  cancellations[4]();
+  releases[0]();
+  await settle();
+  expect(started).toEqual([0, 1, 2, 3, 5]);
+  schedule(4);
+  releases[1]();
+  await settle();
+  expect(started).toEqual([0, 1, 2, 3, 5, 4]);
+  for (const release of releases) release();
+  await settle();
+  const fail = rstest.fn(() => Promise.reject(new Error('retry')));
+  const options = {
+    runtimeContext: context,
+    chunkLoader: loader,
+    publicPath: '/',
+    key: 'failed',
+    run: fail,
+  };
+  policy.schedule(options);
+  await settle();
+  policy.schedule(options);
+  await settle();
+  expect(fail).toHaveBeenCalledTimes(2);
+});
+
+test('deduplicates only within matching context, loader, public path and live TTL', async () => {
+  let now = 0;
+  rstest.spyOn(performance, 'now').mockImplementation(() => now);
+  const policy = createRouterPrefetchPolicy();
+  const run = rstest.fn(() => Promise.resolve());
+  const options = {
+    runtimeContext: {},
+    chunkLoader: {},
+    publicPath: '/',
+    key: 'route',
+    run,
+  };
+  policy.schedule(options);
+  policy.schedule(options);
+  await settle();
+  expect(run).toHaveBeenCalledTimes(1);
+  policy.schedule({ ...options, runtimeContext: {} });
+  policy.schedule({ ...options, chunkLoader: {} });
+  policy.schedule({ ...options, publicPath: '/other/' });
+  await settle();
+  expect(run).toHaveBeenCalledTimes(4);
+  now = 30_001;
+  policy.schedule(options);
+  await settle();
+  expect(run).toHaveBeenCalledTimes(5);
+});