tungsten 0.2.25 → 0.3.1

package/dist/components/RawHtml.js

@@ -0,0 +1,30 @@
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { TungstenSimpleComponent } from "../Components.js";
+import { parseHtml } from "../rawHtml/parseHtml.js";
+import { safeHtmlAllowList } from "../rawHtml/safeHtmlAllowList.js";
+/**
+ * Renders a string of HTML as real content.
+ *
+ * The markup is parsed into an ordinary Tungsten tree, so it renders, hydrates
+ * and reconciles like any other content — unlike `dangerouslySetInnerHTML`,
+ * which hands the browser a region Tungsten cannot see into.
+ *
+ * Note that the parsed elements are not part of any component's scoped CSS, so
+ * component styles reach them only through `:i()` / `:ignore()`.
+ */
+export class RawHtml extends TungstenSimpleComponent {
+  constructor(...args) {
+    super(...args);
+    _defineProperty(this, "content", ({
+      html,
+      sanitize,
+      allowList,
+      safe
+    }) => parseHtml(html, {
+      sanitize,
+      allowList: allowList ?? (safe === true ? safeHtmlAllowList : undefined)
+    }));
+  }
+}

package/dist/components/RawHtml.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=RawHtml.sxyt.d.ts.map

package/dist/components/RawHtml.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RawHtml.sxyt.d.ts","sourceRoot":"","sources":["../../src/components/RawHtml.sxyt.ts"],"names":[],"mappings":""}

package/dist/components/RawHtml.sxyt.js

@@ -0,0 +1,104 @@
+import { expect } from 'chai';
+import { Window } from 'happy-dom';
+import { describe } from 'sxy-test-runner';
+import { RawHtml } from "./RawHtml.js";
+import { createTestApp } from "../testing/index.js";
+// Mounts RawHtml and returns the markup it actually put in the page. The parser
+// itself is covered in rawHtml/parseHtml.sxyt.ts; what is under test here is
+// that the component hands its props to the parser correctly.
+const mount = async props => {
+  const window = new Window();
+  const testApp = await createTestApp(RawHtml, {
+    // eslint-disable-next-line no-type-assertion/no-type-assertion
+    document: window.document,
+    props
+  });
+  try {
+    return {
+      html: testApp.container.innerHTML,
+      text: testApp.container.textContent,
+      elements: testApp.container.querySelectorAll('*').length
+    };
+  } finally {
+    await testApp.unmount();
+  }
+};
+const render = async props => (await mount(props)).html;
+describe('RawHtml', ({
+  it
+}) => {
+  it('renders parsed markup as real elements', async () => {
+    const html = await render({
+      html: '<p>Bonuses for <strong>this month</strong>.</p>'
+    });
+    expect(html).to.contain('<p>');
+    expect(html).to.contain('<strong>this month</strong>');
+  });
+  it('renders nothing for empty markup', async () => {
+    // a component always leaves its delimiter comments behind, so the check
+    // is that it contributed no content, not that the container is empty
+    const {
+      text,
+      elements
+    } = await mount({
+      html: ''
+    });
+    expect(text).to.equal('');
+    expect(elements).to.equal(0);
+  });
+  it('drops scripts by default', async () => {
+    const html = await render({
+      html: '<p>a</p><script>alert(1)</script>'
+    });
+    expect(html).to.contain('<p>a</p>');
+    expect(html).to.not.contain('script');
+    expect(html).to.not.contain('alert');
+  });
+  it('keeps scripts when sanitizing is turned off', async () => {
+    expect(await render({
+      html: '<div><script>x()</script></div>',
+      sanitize: false
+    })).to.contain('<script>x()</script>');
+  });
+  // `safe` is the shortcut for Tungsten's built-in allow list
+  it('applies the built-in allow list when safe is set', async () => {
+    const html = await render({
+      html: '<p style="position:fixed">a</p><iframe src="//evil"></iframe>',
+      safe: true
+    });
+    expect(html).to.contain('a');
+    expect(html).to.not.contain('iframe');
+    // the safe list excludes style, which can disguise a page without script
+    expect(html).to.not.contain('position:fixed');
+  });
+  it('does not apply an allow list unless asked', async () => {
+    const html = await render({
+      html: '<p style="position:fixed">a</p>'
+    });
+    expect(html).to.contain('position:fixed');
+  });
+  it('lets an explicit allowList win over safe', async () => {
+    const onlyEmphasis = {
+      tags: ['em'],
+      attributes: []
+    };
+    // <strong> is on the safe list but not on this one, so if allowList is
+    // being applied it is unwrapped; if safe won, it would survive
+    const html = await render({
+      html: '<em>keep</em><strong>unwrap</strong>',
+      safe: true,
+      allowList: onlyEmphasis
+    });
+    expect(html).to.contain('<em>keep</em>');
+    expect(html).to.not.contain('<strong>');
+    expect(html).to.contain('unwrap');
+  });
+  it('renders whatever it is given without throwing', async () => {
+    const malformed = ['<p>unclosed', '</p>stray', '<p class="unterminated>x', '<<>>', '<!-- open'];
+    for (const html of malformed) {
+      expect(await render({
+        html
+      })).to.be.a('string');
+    }
+  });
+});

package/dist/dev/liveReloadHub.d.ts

@@ -0,0 +1,6 @@
+export type ReloadEventKind = 'js' | 'css';
+type ReloadListener = (kind: ReloadEventKind) => void;
+export declare function onReloadEvent(listener: ReloadListener): () => void;
+export declare function emitReloadEvent(kind: ReloadEventKind): void;
+export {};
+//# sourceMappingURL=liveReloadHub.d.ts.map

package/dist/dev/liveReloadHub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveReloadHub.d.ts","sourceRoot":"","sources":["../../src/dev/liveReloadHub.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,eAAe,GAAG,IAAI,GAAG,KAAK,CAAA;AAE1C,KAAK,cAAc,GAAG,CAAC,IAAI,EAAE,eAAe,KAAK,IAAI,CAAA;AAIrD,wBAAgB,aAAa,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,IAAI,CAGlE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAE3D"}

package/dist/dev/liveReloadHub.js

@@ -0,0 +1,12 @@
+// A process-wide pub/sub so the JS and CSS watchers (compileJavascript, compileStyles),
+// which run and are started before the dev server exists, can notify DevServer's
+// SSE clients whenever a rebuild completes and the browser should refresh. Dev mode only.
+// This is a plain auto-reload signal, not module-level hot patching.
+const listeners = new Set();
+export function onReloadEvent(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+export function emitReloadEvent(kind) {
+  for (const listener of listeners) listener(kind);
+}

package/dist/hydrate/hydrate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/hydrate/hydrate.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AA0BxD,OAAO,EAAE,yBAAyB,EAAoD,MAAM,mBAAmB,CAAA;AAmC/G,wBAAsB,OAAO,CACzB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,yBAAyB,GAAG,IAAI,EAC/C,cAAc,EAAE,cAAc,iBAyDjC"}
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/hydrate/hydrate.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AA0BxD,OAAO,EAAE,yBAAyB,EAAoD,MAAM,mBAAmB,CAAA;AAoC/G,wBAAsB,OAAO,CACzB,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,yBAAyB,GAAG,IAAI,EAC/C,cAAc,EAAE,cAAc,iBAyDjC"}

package/dist/hydrate/hydrate.js

@@ -28,9 +28,10 @@ import { initStores } from 'tungsten/Servers/initStores.js';
 import { MatchedRoute } from "../routing/MatchedRoute.js";
 import { isDev } from "../isDev.js";
 import { warn } from "../appOutput.js";
+import { reconcileHydratedAttributes } from "./reconcileHydratedAttributes.js";
 import { jsx as _jsx } from "tungsten/jsxRuntime.js";
 function debug(...texts) {
-  //console.log(...texts)
+  console.log(...texts);
   //console.log(getStackTrace().split('\n')[2])
 }
 function makeDefaultHydrateMeta() {
@@ -546,11 +547,17 @@ async function hydrateNodeComponent(node, parentElement, domPointer, instance, m
 // export type HTMLBindableElement = HTMLButtonElement | HTMLDataElement | HTMLInputElement | HTMLLIElement
 // | HTMLMeterElement | HTMLOptionElement | HTMLParamElement | HTMLProgressElement | HTMLSelectElement | HTMLTextAreaElement
 function hydrateAttributes(node, domNode) {
-  // !!! We should check whether attributes match here
-  // Show errors in dev mode
-  // Auto fix in prod?
   // handle bind attributes and merge together event handlers
   processAttributes(node);
+  // Bring the server's attributes into line with what this render produced.
+  // Runs in production as well as development: leaving a known-wrong value in
+  // place is not better in production, it is only quieter. Only genuine
+  // differences are written, so a page that matches costs reads and no
+  // writes. The report is dev-only, because a mismatch is a bug in the
+  // application's rendering rather than something a user can act on.
+  if (ContentNodeElementIsHtml(node)) {
+    reconcileHydratedAttributes(node, domNode, isDev ? mismatch => warn(`hydration mismatch on <${node[$type]}>:` + ` ${mismatch.name} rendered as ${JSON.stringify(mismatch.expected)}` + ` but the server sent ${JSON.stringify(mismatch.actual)}.` + ` The rendered value has been applied.`) : undefined);
+  }
   debug('--\nhydrateAttributes', domNode);
   for (const key in node[$props]) {
     if (StringIsHtmlEvent(key)) {

package/dist/hydrate/reconcileHydratedAttributes.d.ts

@@ -0,0 +1,24 @@
+import type { ContentNodeHtml } from '../ContentNode.js';
+export type AttributeMismatch = {
+    name: string;
+    /** The value the client rendered, or null when it renders no such attribute. */
+    expected: string | null;
+    /** The value the server's markup carried, or null when it carried none. */
+    actual: string | null;
+};
+/**
+ * Brings a server-rendered element's attributes into line with what the client
+ * has just rendered, and reports every difference.
+ *
+ * Hydration attaches to markup the server produced. Any attribute whose value
+ * the client works out differently — a stored preference, a media query, a time
+ * zone — would otherwise keep the server's value for the life of the page,
+ * because nothing else revisits it until an unrelated update happens to
+ * reconcile that element.
+ *
+ * Only genuine differences are written. The comparison runs the props through
+ * `processProps()`, the same function that produced the markup being compared
+ * against, so a matching element costs one attribute read each and no writes.
+ */
+export declare function reconcileHydratedAttributes(node: ContentNodeHtml, domNode: HTMLElement, onMismatch?: (mismatch: AttributeMismatch) => void): void;
+//# sourceMappingURL=reconcileHydratedAttributes.d.ts.map

package/dist/hydrate/reconcileHydratedAttributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcileHydratedAttributes.d.ts","sourceRoot":"","sources":["../../src/hydrate/reconcileHydratedAttributes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAIxD,MAAM,MAAM,iBAAiB,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,gFAAgF;IAChF,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,2EAA2E;IAC3E,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACxB,CAAA;AA6BD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,2BAA2B,CACvC,IAAI,EAAE,eAAe,EACrB,OAAO,EAAE,WAAW,EACpB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,iBAAiB,KAAK,IAAI,GACnD,IAAI,CAkCN"}

package/dist/hydrate/reconcileHydratedAttributes.js

@@ -0,0 +1,73 @@
+import { $props } from "../contentNodeSymbols.js";
+import { processProps } from "../render/processProps.js";
+/**
+ * The attribute value a render produces for a prop, or null for "no attribute".
+ *
+ * These are the rules both renderers already use — `renderingNodeToHtml()` on
+ * the server and `addAttributes()` on the client — so that a value which
+ * round-trips unchanged compares equal here.
+ */
+function attributeValue(value) {
+  if (typeof value === 'boolean') return value ? '' : null;
+  if (value === undefined || value === null) return null;
+  return String(value);
+}
+function removeAttribute(domNode, name) {
+  // checked is both an attribute and live state, and the attribute alone only
+  // sets the default. Clear both, or the box stays ticked.
+  // eslint-disable-next-line no-type-assertion/no-type-assertion
+  if (name === 'checked') domNode.checked = false;
+  domNode.removeAttribute(name);
+}
+function setAttribute(domNode, name, value) {
+  domNode.setAttribute(name, value);
+  // eslint-disable-next-line no-type-assertion/no-type-assertion
+  if (name === 'checked') domNode.checked = true;
+}
+/**
+ * Brings a server-rendered element's attributes into line with what the client
+ * has just rendered, and reports every difference.
+ *
+ * Hydration attaches to markup the server produced. Any attribute whose value
+ * the client works out differently — a stored preference, a media query, a time
+ * zone — would otherwise keep the server's value for the life of the page,
+ * because nothing else revisits it until an unrelated update happens to
+ * reconcile that element.
+ *
+ * Only genuine differences are written. The comparison runs the props through
+ * `processProps()`, the same function that produced the markup being compared
+ * against, so a matching element costs one attribute read each and no writes.
+ */
+export function reconcileHydratedAttributes(node, domNode, onMismatch) {
+  // A copy: processProps() rewrites what it is given, and these props stay in
+  // the content tree for the next update to diff against.
+  const expected = processProps({
+    ...node[$props]
+  });
+  const handled = new Set();
+  for (const name in expected) {
+    handled.add(name.toLowerCase());
+    const value = attributeValue(expected[name]);
+    const actual = domNode.getAttribute(name);
+    if (value === actual) continue;
+    if (value === null) removeAttribute(domNode, name);else setAttribute(domNode, name, value);
+    onMismatch?.({
+      name,
+      expected: value,
+      actual
+    });
+  }
+  // Anything the markup carries that this render does not produce. The list
+  // is live, so the names are taken before any of them are removed.
+  const present = [...domNode.attributes].map(attribute => attribute.name);
+  for (const name of present) {
+    if (handled.has(name.toLowerCase())) continue;
+    const actual = domNode.getAttribute(name);
+    removeAttribute(domNode, name);
+    onMismatch?.({
+      name,
+      expected: null,
+      actual
+    });
+  }
+}

package/dist/hydrate/reconcileHydratedAttributes.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reconcileHydratedAttributes.sxyt.d.ts.map

package/dist/hydrate/reconcileHydratedAttributes.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcileHydratedAttributes.sxyt.d.ts","sourceRoot":"","sources":["../../src/hydrate/reconcileHydratedAttributes.sxyt.ts"],"names":[],"mappings":""}

package/dist/hydrate/reconcileHydratedAttributes.sxyt.js

@@ -0,0 +1,173 @@
+import { describe } from 'sxy-test-runner';
+import { expect } from 'chai';
+import { Window } from 'happy-dom';
+import { reconcileHydratedAttributes } from "./reconcileHydratedAttributes.js";
+import { $props, $type } from "../contentNodeSymbols.js";
+const window = new Window();
+const node = (type, props) => ({
+  [$type]: type,
+  [$props]: props
+});
+/** Builds an element from markup the server could have produced. */
+const element = html => {
+  const host = window.document.createElement('div');
+  host.innerHTML = html;
+  // eslint-disable-next-line no-type-assertion/no-type-assertion
+  return host.firstElementChild;
+};
+const attributesOf = domNode => Object.fromEntries([...domNode.attributes].map(attribute => [attribute.name, attribute.value]));
+/** Reconciles and returns what changed. */
+const reconcile = (type, props, html) => {
+  const domNode = element(html);
+  const mismatches = [];
+  reconcileHydratedAttributes(node(type, props), domNode, mismatch => mismatches.push(mismatch));
+  return {
+    domNode,
+    mismatches,
+    attributes: attributesOf(domNode)
+  };
+};
+describe('reconcileHydratedAttributes()', ({
+  it
+}) => {
+  it('patches an attribute whose rendered value differs from the markup', () => {
+    const {
+      attributes,
+      mismatches
+    } = reconcile('div', {
+      style: {
+        backgroundColor: '#123456'
+      }
+    }, '<div style="background-color: #bae3ff;"></div>');
+    expect(attributes.style).to.equal('background-color: #123456;');
+    expect(mismatches.map(mismatch => mismatch.name)).to.deep.equal(['style']);
+  });
+  it('leaves a matching attribute untouched and reports nothing', () => {
+    const {
+      attributes,
+      mismatches
+    } = reconcile('input', {
+      name: 'ref',
+      title: 'Reference'
+    }, '<input name="ref" title="Reference">');
+    expect(attributes).to.deep.equal({
+      name: 'ref',
+      title: 'Reference'
+    });
+    expect(mismatches).to.deep.equal([]);
+  });
+  it('adds an attribute the markup is missing', () => {
+    const {
+      attributes
+    } = reconcile('a', {
+      href: '/x',
+      title: 't'
+    }, '<a href="/x"></a>');
+    expect(attributes).to.deep.equal({
+      href: '/x',
+      title: 't'
+    });
+  });
+  it('removes an attribute the render no longer produces', () => {
+    const {
+      attributes,
+      mismatches
+    } = reconcile('a', {
+      href: '/x'
+    }, '<a href="/x" title="gone"></a>');
+    expect(attributes).to.deep.equal({
+      href: '/x'
+    });
+    expect(mismatches.map(mismatch => mismatch.name)).to.deep.equal(['title']);
+  });
+  it('treats a true boolean as a present, empty attribute', () => {
+    expect(reconcile('button', {
+      disabled: true
+    }, '<button></button>').attributes).to.deep.equal({
+      disabled: ''
+    });
+  });
+  it('removes an attribute whose rendered value is false, null or undefined', () => {
+    expect(reconcile('button', {
+      disabled: false
+    }, '<button disabled></button>').attributes).to.deep.equal({});
+    expect(reconcile('a', {
+      href: null
+    }, '<a href="/x"></a>').attributes).to.deep.equal({});
+    expect(reconcile('a', {
+      href: undefined
+    }, '<a href="/x"></a>').attributes).to.deep.equal({});
+  });
+  // The comparison has to apply the same transformation the server used, or
+  // every element looks mismatched and the whole document gets rewritten.
+  it('applies the server prop transform, so className compares against class', () => {
+    const {
+      attributes,
+      mismatches
+    } = reconcile('div', {
+      className: 'frame Qtc_frame'
+    }, '<div class="frame Qtc_frame"></div>');
+    expect(attributes).to.deep.equal({
+      class: 'frame Qtc_frame'
+    });
+    expect(mismatches).to.deep.equal([]);
+  });
+  it('ignores event handlers rather than writing them as attributes', () => {
+    const {
+      attributes,
+      mismatches
+    } = reconcile('input', {
+      name: 'a',
+      onInput: () => undefined,
+      onClick: () => undefined
+    }, '<input name="a">');
+    expect(attributes).to.deep.equal({
+      name: 'a'
+    });
+    expect(mismatches).to.deep.equal([]);
+  });
+  it('ignores props that are instructions to Tungsten', () => {
+    const {
+      attributes,
+      mismatches
+    } = reconcile('div', {
+      __opaque: true,
+      dangerouslySetInnerHTML: {
+        __html: '<b>x</b>'
+      },
+      id: 'd'
+    }, '<div id="d"></div>');
+    expect(attributes).to.deep.equal({
+      id: 'd'
+    });
+    expect(mismatches).to.deep.equal([]);
+  });
+  it('reports what changed, for a dev-mode warning', () => {
+    const {
+      mismatches
+    } = reconcile('a', {
+      href: '/new'
+    }, '<a href="/old" title="stale"></a>');
+    expect(mismatches).to.deep.include({
+      name: 'href',
+      expected: '/new',
+      actual: '/old'
+    });
+    expect(mismatches).to.deep.include({
+      name: 'title',
+      expected: null,
+      actual: 'stale'
+    });
+  });
+  it('clears the checked property when removing a checked attribute', () => {
+    const domNode = element('<input type="checkbox" checked>');
+    // eslint-disable-next-line no-type-assertion/no-type-assertion
+    const checkbox = domNode;
+    expect(checkbox.checked).to.equal(true);
+    reconcileHydratedAttributes(node('input', {
+      type: 'checkbox'
+    }), domNode);
+    expect(checkbox.checked).to.equal(false);
+    expect(domNode.hasAttribute('checked')).to.equal(false);
+  });
+});

package/dist/indexInner.d.ts

@@ -16,7 +16,11 @@ export * from './components/bindable/BindableTextarea.jsx';
 export * from './components/GoToComponent.jsx';
 export * from './components/Lazy.js';
 export * from './components/Link.jsx';
+export * from './components/RawHtml.jsx';
 export * from './components/RouteRedirectComponent.jsx';
+export { parseHtml, type ParseHtmlOptions } from './rawHtml/parseHtml.js';
+export { safeHtmlAllowList } from './rawHtml/safeHtmlAllowList.js';
+export type { HtmlAllowList } from './rawHtml/HtmlAllowList.js';
 export * from './components/WebRedirectComponent.jsx';
 export * from './nbsp.js';
 export * from './browserStorage.js';

package/dist/indexInner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"indexInner.d.ts","sourceRoot":"","sources":["../src/indexInner.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"indexInner.d.ts","sourceRoot":"","sources":["../src/indexInner.ts"],"names":[],"mappings":"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"}

package/dist/indexInner.js

@@ -21,7 +21,10 @@ export * from "./components/bindable/BindableTextarea.js";
 export * from "./components/GoToComponent.js";
 export * from "./components/Lazy.js";
 export * from "./components/Link.js";
+export * from "./components/RawHtml.js";
 export * from "./components/RouteRedirectComponent.js";
+export { parseHtml } from "./rawHtml/parseHtml.js";
+export { safeHtmlAllowList } from "./rawHtml/safeHtmlAllowList.js";
 export * from "./components/WebRedirectComponent.js";
 export * from "./nbsp.js";
 export * from "./browserStorage.js";

package/dist/innerHtmlFromProps.d.ts

@@ -0,0 +1,16 @@
+import type { NodeProps } from './ContentNode.js';
+/**
+ * Reads React's `dangerouslySetInnerHTML` prop, returning the raw markup, or
+ * `null` when the element does not use it.
+ *
+ * The markup is the element's entire inner content: the server writes it into
+ * its HTML verbatim, the client assigns it to `innerHTML`, and the nodes the
+ * parser produces from it are never reconciled. Tungsten holds one opaque
+ * string where the DOM holds a whole subtree, so reconciling them would
+ * corrupt the document.
+ *
+ * `hasChildren` is supplied by the caller because the content and rendering
+ * trees test their children differently.
+ */
+export declare function innerHtmlFromProps(type: string, props: NodeProps, hasChildren: boolean): string | null;
+//# sourceMappingURL=innerHtmlFromProps.d.ts.map

package/dist/innerHtmlFromProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"innerHtmlFromProps.d.ts","sourceRoot":"","sources":["../src/innerHtmlFromProps.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAGjD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAC9B,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,GACrD,MAAM,GAAG,IAAI,CA8Bf"}

package/dist/innerHtmlFromProps.js

@@ -0,0 +1,31 @@
+import { throwError } from "./throwError.js";
+/**
+ * Reads React's `dangerouslySetInnerHTML` prop, returning the raw markup, or
+ * `null` when the element does not use it.
+ *
+ * The markup is the element's entire inner content: the server writes it into
+ * its HTML verbatim, the client assigns it to `innerHTML`, and the nodes the
+ * parser produces from it are never reconciled. Tungsten holds one opaque
+ * string where the DOM holds a whole subtree, so reconciling them would
+ * corrupt the document.
+ *
+ * `hasChildren` is supplied by the caller because the content and rendering
+ * trees test their children differently.
+ */
+export function innerHtmlFromProps(type, props, hasChildren) {
+  const prop = props.dangerouslySetInnerHTML;
+  if (prop === undefined || prop === null) return null;
+  if (typeof prop !== 'object' || !('__html' in prop)) {
+    throwError('innerHtmlFromProps', `<${type}> dangerouslySetInnerHTML must be an object of the form { __html: '...' }.`);
+  }
+  const html = prop.__html;
+  if (html === undefined || html === null) {
+    throwError('innerHtmlFromProps', `<${type}> dangerouslySetInnerHTML.__html is ${String(html)}.`);
+  }
+  if (hasChildren) {
+    throwError('innerHtmlFromProps', `<${type}> has both dangerouslySetInnerHTML and children.` + ` An element's content must come from one or the other.`);
+  }
+  // TrustedHTML stringifies to its markup, so this accepts both forms the
+  // JSX typings allow.
+  return String(html);
+}

package/dist/innerHtmlFromProps.sxyt.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=innerHtmlFromProps.sxyt.d.ts.map

package/dist/innerHtmlFromProps.sxyt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"innerHtmlFromProps.sxyt.d.ts","sourceRoot":"","sources":["../src/innerHtmlFromProps.sxyt.ts"],"names":[],"mappings":""}