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

package/tests/headRuntime.test.tsx

@@ -0,0 +1,369 @@
+import React from 'react';
+import { renderToString } from 'react-dom/server';
+import { createHeadRuntime } from '../src/headRuntime';
+import { ensureHelmetContext, getHelmetContext } from '../src/helmetContext';
+import * as rendererHead from '../src/rendererHead';
+
+const { Head: Helmet, wrapServerRoot } = createHeadRuntime();
+const getHelmetData = (context: object) => getHelmetContext(context)?.helmet;
+
+const createServerContext = () => ({ isBrowser: false }) as any;
+
+const renderWithContext = (context: any, node: React.ReactNode) => {
+  rendererHead.beginHeadRender(context);
+  try {
+    const html = renderToString(
+      wrapServerRoot(node, {
+        runtimeContext: context,
+        helmetContext: ensureHelmetContext(context),
+      }),
+    );
+    return rendererHead.completeHeadRender(context, html);
+  } catch (error) {
+    rendererHead.abortHeadRender(context);
+    throw error;
+  }
+};
+
+describe('server Helmet collection', () => {
+  it('keeps independently registered adapters scoped to their own providers', () => {
+    const outer = createHeadRuntime();
+    const inner = createHeadRuntime();
+    const outerContext = {};
+    const innerContext = {};
+
+    renderToString(
+      outer.wrapServerRoot(
+        inner.wrapServerRoot(
+          <>
+            <outer.Head>
+              <title>outer application</title>
+            </outer.Head>
+            <inner.Head>
+              <title>inner application</title>
+            </inner.Head>
+          </>,
+          {
+            runtimeContext: innerContext,
+            helmetContext: ensureHelmetContext(innerContext),
+          },
+        ),
+        {
+          runtimeContext: outerContext,
+          helmetContext: ensureHelmetContext(outerContext),
+        },
+      ),
+    );
+
+    expect(getHelmetData(outerContext)?.title.toString()).toBe(
+      '<title data-rh="true">outer application</title>',
+    );
+    expect(getHelmetData(innerContext)?.title.toString()).toBe(
+      '<title data-rh="true">inner application</title>',
+    );
+  });
+
+  it('excludes Helmet records from a discarded Suspense primary branch', () => {
+    const context = createServerContext();
+    const never = new Promise<never>(() => {});
+
+    const SuspendForever = (): null => {
+      throw never;
+    };
+
+    const html = renderWithContext(
+      context,
+      <>
+        <Helmet>
+          <meta name="outside" content="committed" />
+        </Helmet>
+        <React.Suspense
+          fallback={
+            <>
+              <Helmet>
+                <meta name="fallback" content="committed" />
+              </Helmet>
+              <span>fallback rendered</span>
+            </>
+          }
+        >
+          <Helmet>
+            <meta name="abandoned-unique" content="ghost" />
+          </Helmet>
+          <SuspendForever />
+        </React.Suspense>
+      </>,
+    );
+
+    expect(html).toContain('fallback rendered');
+    const meta = getHelmetData(context)!.meta.toString();
+    expect(meta).toContain('name="outside"');
+    expect(meta).toContain('name="fallback"');
+    expect(meta).not.toContain('name="abandoned-unique"');
+  });
+
+  it('collects title/meta during SSR and renders nothing inline', () => {
+    const context = createServerContext();
+    const html = renderWithContext(
+      context,
+      <main>
+        <Helmet>
+          <title>Server Title</title>
+          <meta name="description" content="hello" />
+        </Helmet>
+        body
+      </main>,
+    );
+
+    expect(html).not.toContain('Server Title');
+    const helmet = getHelmetData(context)!;
+    expect(helmet.title.toString()).toBe(
+      '<title data-rh="true">Server Title</title>',
+    );
+    expect(helmet.meta.toString()).toBe(
+      '<meta data-rh="true" name="description" content="hello">',
+    );
+  });
+
+  it('dedupes meta by primary attribute across nested Helmets, inner wins', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <>
+        <Helmet>
+          <meta name="description" content="outer" />
+          <meta name="keywords" content="modernjs" />
+        </Helmet>
+        <section>
+          <Helmet>
+            <meta name="description" content="inner" />
+          </Helmet>
+        </section>
+      </>,
+    );
+
+    const meta = getHelmetData(context)!.meta.toString();
+    expect(meta).toContain('content="inner"');
+    expect(meta).not.toContain('content="outer"');
+    expect(meta).toContain('content="modernjs"');
+    // outer instance tags come first, like react-helmet-async
+    expect(meta.indexOf('keywords')).toBeLessThan(meta.indexOf('description'));
+  });
+
+  it('keeps duplicate metas within a single Helmet instance', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <Helmet>
+        <meta name="author" content="a" />
+        <meta name="author" content="b" />
+      </Helmet>,
+    );
+
+    const meta = getHelmetData(context)!.meta.toString();
+    expect(meta).toContain('content="a"');
+    expect(meta).toContain('content="b"');
+  });
+
+  it('normalizes charSet when deduping and drops meta without primary attribute', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <>
+        <Helmet>
+          <meta charSet="utf-8" />
+          <meta content="orphan" />
+        </Helmet>
+        <Helmet meta={[{ charSet: 'utf-8' } as any]} />
+      </>,
+    );
+
+    const meta = getHelmetData(context)!.meta.toString();
+    expect(meta.match(/charset/g)).toHaveLength(1);
+    expect(meta).not.toContain('orphan');
+  });
+
+  it('applies the innermost title and the innermost titleTemplate', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <>
+        <Helmet titleTemplate="%s | Site">
+          <title>Outer</title>
+        </Helmet>
+        <Helmet>
+          <title>Inner</title>
+        </Helmet>
+      </>,
+    );
+
+    expect(getHelmetData(context)!.title.toString()).toBe(
+      '<title data-rh="true">Inner | Site</title>',
+    );
+  });
+
+  it('falls back to defaultTitle without applying the template', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <Helmet defaultTitle="Default" titleTemplate="%s | Site" />,
+    );
+
+    expect(getHelmetData(context)!.title.toString()).toBe(
+      '<title data-rh="true">Default</title>',
+    );
+  });
+
+  it('maps <html>/<body> children to html/body attributes', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <Helmet>
+        <html lang="en" />
+        <body className="dark" />
+      </Helmet>,
+    );
+
+    const helmet = getHelmetData(context)!;
+    expect(helmet.htmlAttributes.toString()).toBe('lang="en"');
+    expect(helmet.bodyAttributes.toString()).toBe('class="dark"');
+  });
+
+  it('keeps one canonical link but all distinct stylesheets', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <>
+        <Helmet>
+          <link rel="canonical" href="https://outer.example/" />
+          <link rel="stylesheet" href="/a.css" />
+          <link rel="stylesheet" href="/b.css" />
+        </Helmet>
+        <Helmet>
+          <link rel="canonical" href="https://inner.example/" />
+        </Helmet>
+      </>,
+    );
+
+    const link = getHelmetData(context)!.link.toString();
+    expect(link).toContain('https://inner.example/');
+    expect(link).not.toContain('https://outer.example/');
+    expect(link).toContain('/a.css');
+    expect(link).toContain('/b.css');
+  });
+
+  it('does not serialize script innerHTML as an attribute', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <Helmet>
+        <script type="application/ld+json">{'{"@context":"a"}'}</script>
+      </Helmet>,
+    );
+
+    const script = getHelmetData(context)!.script.toString();
+    expect(script).toBe(
+      '<script data-rh="true" type="application/ld+json">{"@context":"a"}</script>',
+    );
+  });
+
+  it('publishes prioritized SEO tags separately with component parity', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <Helmet prioritizeSeoTags htmlAttributes={{ class: 'app' } as any}>
+        <title>Priority Page</title>
+        <meta name="description" content="priority description" />
+        <meta name="keywords" content="ordinary keywords" />
+        <link rel="canonical" href="https://example.com/page" />
+        <link rel="stylesheet" href="/page.css" />
+        <script type="application/ld+json">{'{"name":"page"}'}</script>
+        <script src="/ordinary.js" />
+      </Helmet>,
+    );
+
+    const helmet = getHelmetData(context)!;
+    expect(helmet.priority.toString()).toContain('priority description');
+    expect(helmet.priority.toString()).toContain('https://example.com/page');
+    expect(helmet.priority.toString()).toContain('application/ld+json');
+    expect(helmet.meta.toString()).toContain('ordinary keywords');
+    expect(helmet.meta.toString()).not.toContain('priority description');
+    expect(helmet.link.toString()).toContain('/page.css');
+    expect(helmet.link.toString()).not.toContain('https://example.com/page');
+    expect(helmet.script.toString()).toContain('/ordinary.js');
+    expect(helmet.script.toString()).not.toContain('application/ld+json');
+
+    const priority = helmet.priority.toComponent();
+    expect(priority.map(element => element.type)).toEqual([
+      'meta',
+      'link',
+      'script',
+    ]);
+    expect(priority[0].props).toMatchObject({
+      'data-rh': true,
+      content: 'priority description',
+      name: 'description',
+    });
+    expect(priority[2].props).toMatchObject({
+      'data-rh': true,
+      dangerouslySetInnerHTML: { __html: '{"name":"page"}' },
+      type: 'application/ld+json',
+    });
+    expect(helmet.meta.toComponent()[0].props).toMatchObject({
+      content: 'ordinary keywords',
+      name: 'keywords',
+    });
+    expect(helmet.title.toComponent()[0].props.children).toBe('Priority Page');
+    expect(helmet.htmlAttributes.toComponent()).toEqual({ className: 'app' });
+  });
+
+  it('is idempotent when React replays the tree (streaming SSR retry)', () => {
+    const context = createServerContext();
+    const app = (
+      <>
+        <Helmet titleTemplate="%s | Site">
+          <title>Page</title>
+          <meta name="description" content="stable" />
+          <html lang="en" />
+        </Helmet>
+        <Helmet>
+          <meta property="og:title" content="Page" />
+        </Helmet>
+      </>
+    );
+
+    renderWithContext(context, app);
+    const first = getHelmetData(context)!;
+    const firstSnapshot = {
+      title: first.title.toString(),
+      meta: first.meta.toString(),
+      htmlAttributes: first.htmlAttributes.toString(),
+    };
+
+    // Simulate a replayed render against the same per-request context.
+    renderWithContext(context, app);
+    const second = getHelmetData(context)!;
+
+    expect(second.title.toString()).toBe(firstSnapshot.title);
+    expect(second.meta.toString()).toBe(firstSnapshot.meta);
+    expect(second.htmlAttributes.toString()).toBe(firstSnapshot.htmlAttributes);
+    expect(second.meta.toString().match(/description/g)).toHaveLength(1);
+  });
+
+  it('keeps the innermost base tag only', () => {
+    const context = createServerContext();
+    renderWithContext(
+      context,
+      <>
+        <Helmet base={{ href: 'https://outer.example/' } as any} />
+        <Helmet>
+          <base href="https://inner.example/" />
+        </Helmet>
+      </>,
+    );
+
+    const base = getHelmetData(context)!.base.toString();
+    expect(base).toContain('https://inner.example/');
+    expect(base).not.toContain('https://outer.example/');
+  });
+});

package/tests/nativeSafeFailureCompatibility.test.ts

@@ -0,0 +1,117 @@
+import {
+  createSafeFailureHttpResult,
+  createSafeJsonFailureResponse,
+} from '../src/safeFailure';
+
+describe('native safe failure contract compatibility', () => {
+  it('should create safe JSON failure envelopes without leaking raw messages', async () => {
+    const result = createSafeFailureHttpResult(
+      new Error('database password leaked in stack'),
+    );
+
+    expect(result).toEqual({
+      status: 500,
+      body: {
+        success: false,
+        error: {
+          code: 'INTERNAL_SERVER_ERROR',
+          message: 'Internal Server Error',
+          status: 500,
+        },
+      },
+      headers: {
+        'content-type': 'application/json; charset=utf-8',
+      },
+    });
+
+    const response = createSafeJsonFailureResponse(
+      new Error('database password leaked in stack'),
+    );
+    expect(response.status).toBe(500);
+    expect(response.headers.get('content-type')).toContain('application/json');
+    await expect(response.json()).resolves.toEqual(result.body);
+  });
+
+  it('should preserve service unavailable status and Retry-After metadata', () => {
+    const error = Object.assign(new Error('maintenance window details'), {
+      status: 503,
+      retryAfterSeconds: 120,
+    });
+
+    expect(createSafeFailureHttpResult(error)).toEqual({
+      status: 503,
+      body: {
+        success: false,
+        error: {
+          code: 'SERVICE_UNAVAILABLE',
+          message: 'Service Unavailable',
+          status: 503,
+        },
+      },
+      headers: {
+        'content-type': 'application/json; charset=utf-8',
+        'Retry-After': '120',
+      },
+    });
+  });
+
+  it.each([
+    ['delay-seconds text', '120', '120'],
+    [
+      'the largest safely serializable delay',
+      Number.MAX_SAFE_INTEGER,
+      String(Number.MAX_SAFE_INTEGER),
+    ],
+    [
+      'an HTTP-date string',
+      'Sun, 30 Aug 2026 20:00:00 GMT',
+      'Sun, 30 Aug 2026 20:00:00 GMT',
+    ],
+    [
+      'a Date instance',
+      new Date(Date.UTC(2026, 7, 30, 20, 0, 0)),
+      'Sun, 30 Aug 2026 20:00:00 GMT',
+    ],
+  ])('should preserve %s in Retry-After', (_, retryAfter, expected) => {
+    const result = createSafeFailureHttpResult({
+      status: 503,
+      retryAfter,
+    });
+
+    expect(result.headers['Retry-After']).toBe(expected);
+  });
+
+  it.each([
+    ['a header-injection payload', '120\r\nX-Injected: true'],
+    ['a non-numeric delay', 'after maintenance'],
+    ['a delay too large for integer serialization', 1e21],
+    ['an invalid HTTP date', 'Wed, 99 Jun 2026 25:61:61 GMT'],
+    ['an invalid Date object', new Date(Number.NaN)],
+  ])('should ignore %s in Retry-After without throwing', (_, retryAfter) => {
+    const error = Object.assign(new Error('maintenance window details'), {
+      status: 503,
+      retryAfter,
+    });
+
+    expect(createSafeFailureHttpResult(error)).toEqual({
+      status: 503,
+      body: {
+        success: false,
+        error: {
+          code: 'SERVICE_UNAVAILABLE',
+          message: 'Service Unavailable',
+          status: 503,
+        },
+      },
+      headers: {
+        'content-type': 'application/json; charset=utf-8',
+      },
+    });
+    expect(() => createSafeJsonFailureResponse(error)).not.toThrow();
+  });
+
+  it('should clamp invalid thrown status values to 500', () => {
+    expect(createSafeFailureHttpResult({ status: 200 }).status).toBe(500);
+    expect(createSafeFailureHttpResult({ statusCode: 799 }).status).toBe(500);
+  });
+});

package/tests/prefetchPolicy.test.ts

@@ -0,0 +1,51 @@
+import {
+  normalizePreloadBehavior,
+  resolvePreloadFromPrefetch,
+} from '../src/prefetchPolicy';
+
+const behaviors = ['intent', 'render', 'viewport', 'none'] as const;
+
+describe('router prefetch precedence', () => {
+  describe.each(behaviors)('React Router prefetch=%s', prefetch => {
+    it('inherits prefetch when preload is omitted', () => {
+      expect(normalizePreloadBehavior(undefined, prefetch)).toBe(prefetch);
+    });
+
+    it.each([
+      ...behaviors,
+      false,
+    ] as const)('honors explicit preload=%s using none for disabled', preload => {
+      expect(normalizePreloadBehavior(preload, prefetch)).toBe(
+        preload === false ? 'none' : preload,
+      );
+    });
+  });
+
+  describe.each([undefined, ...behaviors])('TanStack prefetch=%s', prefetch => {
+    it('inherits supported prefetch with viewport as the default', () => {
+      expect(resolvePreloadFromPrefetch(prefetch, undefined)).toBe(
+        prefetch === 'none' ? false : (prefetch ?? 'viewport'),
+      );
+    });
+
+    it.each([
+      ...behaviors,
+      false,
+      null,
+      'custom',
+      0,
+    ])('passes explicit preload=%s through unchanged', preload => {
+      expect(resolvePreloadFromPrefetch(prefetch, preload)).toBe(preload);
+    });
+  });
+
+  it('preserves the routers different defaults', () => {
+    expect(normalizePreloadBehavior(undefined, 'render')).toBe('render');
+    expect(resolvePreloadFromPrefetch(undefined, undefined)).toBe('viewport');
+  });
+
+  it('preserves object identity for TanStack preload pass-through', () => {
+    const preload = {};
+    expect(resolvePreloadFromPrefetch('none', preload)).toBe(preload);
+  });
+});

package/tests/rendererHead.test.ts

@@ -6,13 +6,8 @@ import {
   completeHeadRender,
   createHeadChunkProcessor,
   createWebHeadMarkerStripper,
-  publishHeadRender,
 } from '../src';
-import {
-  createNodeHeadMarkerStripper,
-  createOnceErrorReporter,
-  pipeNodeHeadStream,
-} from '../src/node';
+import { createNodeHeadMarkerStripper, pipeNodeHeadStream } from '../src/node';
 
 const marker = (props: Record<string, string>) =>
   `<template data-modern-helmet="${props['data-modern-helmet']}"></template>`;
@@ -87,41 +82,6 @@ describe('renderer head transactions', () => {
     }
   });
 
-  it('freezes the published shell and ignores late records', () => {
-    const context = {};
-    let published: string[] = [];
-    beginHeadRender(context);
-    const shell = collectHeadRecord(
-      context,
-      () => 'shell',
-      records => {
-        published = records;
-      },
-    )!;
-    const late = collectHeadRecord(
-      context,
-      () => 'late',
-      records => {
-        published = records;
-      },
-    )!;
-    const processor = createHeadChunkProcessor(context);
-    expect(processor.push(marker(shell))).toBe('');
-    publishHeadRender(context);
-
-    expect(
-      collectHeadRecord(
-        context,
-        () => 'late',
-        records => {
-          published = records;
-        },
-      ),
-    ).toBeNull();
-    expect(processor.finish(marker(late))).toBe('');
-    expect(published).toEqual(['shell']);
-  });
-
   it('clears the previous snapshot while rendering and restores it on abort', () => {
     const context = {};
     let published: string[] = [];
@@ -265,35 +225,4 @@ describe('renderer head transactions', () => {
     await expect(output).rejects.toThrow('source failed');
     expect(onError).toHaveBeenCalledTimes(1);
   });
-
-  it('rejects the destination and reports a stripper error exactly once', async () => {
-    const source = new PassThrough();
-    const destination = new PassThrough();
-    const output = new Response(
-      Readable.toWeb(destination) as ReadableStream<Uint8Array>,
-    ).text();
-    const onError = rstest.fn();
-    pipeNodeHeadStream({
-      source,
-      destination,
-      context: Object.freeze({}),
-      onError,
-    });
-
-    source.end('trigger frozen-context failure');
-
-    await expect(output).rejects.toThrow('object is not extensible');
-    expect(onError).toHaveBeenCalledTimes(1);
-  });
-
-  it('reports a shared render and stream failure only once', () => {
-    const onError = rstest.fn();
-    const reportError = createOnceErrorReporter(onError);
-    const failure = new Error('shared failure');
-
-    reportError(failure);
-    reportError(failure);
-
-    expect(onError).toHaveBeenCalledExactlyOnceWith(failure);
-  });
 });