@miaskiewicz/turbo-dom 0.5.8 → 0.7.0

package/src/runtime/html-serialize.mjs

@@ -1,8 +1,9 @@
 // HTML serialization for innerHTML / outerHTML (WHATWG-ish fragment serializer).
 
+// HTML "serializes as void" (Chrome 156 includes the legacy basefont / bgsound / frame / keygen).
 const VOID = new Set([
-  'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link',
-  'meta', 'param', 'source', 'track', 'wbr',
+  'area', 'base', 'basefont', 'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input',
+  'keygen', 'link', 'meta', 'param', 'source', 'track', 'wbr',
 ]);
 
 // Elements whose content is raw text (not escaped).
@@ -11,14 +12,20 @@ const RAW_TEXT = new Set(['style', 'script', 'xmp', 'iframe', 'noembed', 'nofram
 function escapeText(s) {
   return s.replace(/&/g, '&amp;').replace(/ /g, '&nbsp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
+// attribute values also escape < and > (Chrome 156)
 function escapeAttr(s) {
-  return s.replace(/&/g, '&amp;').replace(/ /g, '&nbsp;').replace(/"/g, '&quot;');
+  return s.replace(/&/g, '&amp;').replace(/ /g, '&nbsp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 
 function serializeNode(node, out) {
   switch (node.nodeType) {
     case 1: { // element
-      const tag = node.localName;
+      // HTML / SVG / MathML elements serialize their local name, other namespaces the
+      // qualified name; a createElementNS prefix is kept on all of them (Chrome 156:
+      // <h:br>, <svg:g>). Only HTML elements can be void or <template>, keyed on the local name.
+      const ns = node.__ns, html = ns === '', local = node.localName;
+      const tag = node.__prefix !== undefined ? `${node.__prefix}:${local}`
+        : html || ns === 'svg' || ns === 'math' ? local : node.tagName;
       out.push('<' + tag);
       // __attrs is lazy: buffer-backed elements leave it undefined (store __attrIdx).
       // Build from the SoA on first touch, matching every other __attrs read site.
@@ -28,8 +35,8 @@ function serializeNode(node, out) {
         out.push(` ${name}="${escapeAttr(a.value)}"`);
       }
       out.push('>');
-      if (VOID.has(tag)) break;
-      if (tag === 'template' && node.content) {
+      if (html && VOID.has(local)) break;
+      if (html && local === 'template' && node.content) {
         serializeChildren(node.content, out);
       } else {
         serializeChildren(node, out);
@@ -38,7 +45,8 @@ function serializeNode(node, out) {
       break;
     }
     case 3: { // text
-      const parentTag = node.parentNode && node.parentNode.localName;
+      // raw text keys on the parent's prefix-free local name (Chrome 156: <h:script> escapes)
+      const parent = node.parentNode, parentTag = parent && parent.__prefix === undefined && parent.localName;
       out.push(RAW_TEXT.has(parentTag) ? node.data : escapeText(node.data));
       break;
     }

package/src/runtime/index.d.ts

@@ -0,0 +1,100 @@
+// Types for `@miaskiewicz/turbo-dom/runtime` (src/runtime/index.mjs).
+//
+// The runtime classes implement the DOM's shape but are not the lib.dom classes, so
+// they are typed loosely here (members are `any`); the entry points are typed exactly.
+
+/** A parser binding (native napi, wasm, or an injected one). */
+export interface ParserBinding {
+  parse(html: string): unknown;
+  parseBuffer(html: string): unknown;
+  parseFragment(html: string, context?: string): unknown;
+  [key: string]: unknown;
+}
+
+export type ParserMode = 'wasm' | 'native' | 'auto';
+
+export type CustomElementState = 'undefined' | 'failed' | 'uncustomized' | 'precustomized' | 'custom';
+
+export interface EnvironmentOptions {
+  /** Parser selection, applied process-wide before the first parse. */
+  parser?: ParserMode;
+  /** The document URL (default `http://localhost/`). */
+  url?: string;
+}
+
+export interface Environment {
+  /** The lazy window (globals are created on first access). */
+  window: any;
+  document: Document;
+  /** The global names the tests have touched since the last reset. */
+  touched: Set<string>;
+  /** Every global name the window can provide. */
+  globalKeys: string[];
+  /** Re-point the document at a fresh (or new) parse and drop per-test state. */
+  reset(html?: string): void;
+}
+
+export declare function createEnvironment(html?: string, options?: EnvironmentOptions): Environment;
+
+/** Inject a ready parser binding; `null` clears it. */
+export declare function setParser(binding: ParserBinding | null): void;
+/** Force a parser mode; `null` consults the environment again. */
+export declare function setParserMode(mode: ParserMode | null): void;
+export declare function getParser(): ParserBinding;
+
+/** Install a virtual clock (milliseconds); anything but a function restores the real one. */
+export declare function setClock(fn: (() => number) | null): void;
+
+export declare function customElementState(el: unknown): CustomElementState;
+/** Record an element's custom element state; returns whether it changed. */
+export declare function setCustomElementState(el: unknown, state: CustomElementState): boolean;
+
+/** Parse an HTML string into a new Document. */
+export declare function parseDocument(html: string): Document;
+
+export declare const ELEMENT_NODE: 1;
+export declare const TEXT_NODE: 3;
+export declare const COMMENT_NODE: 8;
+export declare const DOCUMENT_NODE: 9;
+export declare const DOCUMENT_TYPE_NODE: 10;
+export declare const DOCUMENT_FRAGMENT_NODE: 11;
+
+export declare class Event {
+  constructor(type: string, init?: { bubbles?: boolean; cancelable?: boolean; composed?: boolean });
+  readonly type: string;
+  [key: string]: any;
+}
+export declare class CustomEvent<T = any> extends Event {
+  constructor(type: string, init?: { bubbles?: boolean; cancelable?: boolean; composed?: boolean; detail?: T });
+  readonly detail: T;
+}
+
+export declare class Node {
+  readonly nodeType: number;
+  readonly nodeName: string;
+  [key: string]: any;
+}
+export declare class Text extends Node {}
+export declare class Comment extends Node {}
+export declare class DocumentType extends Node {}
+export declare class Element extends Node {}
+export declare class SVGElement extends Element {}
+export declare class MathMLElement extends Element {}
+export declare class DocumentFragment extends Node {}
+export declare class ShadowRoot extends DocumentFragment {}
+export declare class Document extends Node {
+  constructor();
+}
+
+export declare class DOMParser {
+  parseFromString(str: string, type?: string): Document;
+}
+export declare class XMLSerializer {
+  serializeToString(node: Node): string;
+}
+export declare class MutationObserver {
+  constructor(callback: (records: any[], observer: MutationObserver) => void);
+  observe(target: Node, options?: Record<string, unknown>): void;
+  disconnect(): void;
+  takeRecords(): any[];
+}

package/src/runtime/index.mjs

@@ -14,6 +14,11 @@ import { getParser, setParserMode } from './parser.mjs';
 export { Document } from './dom.mjs';
 export * from './dom.mjs';
 
+// Custom element state seam (public API): the state behind `:defined` (custom-elements.mjs),
+// for embedders that upgrade elements themselves — the JS twin of the Rust engine's
+// Tree::custom_element_state / set_custom_element_state.
+export { customElementState, setCustomElementState } from './custom-elements.mjs';
+
 // Parser-selection seam (public API): inject a ready binding for a node-free host,
 // or force 'wasm' | 'native' | 'auto'. See parser.mjs.
 export { setParser, setParserMode, getParser } from './parser.mjs';

package/src/runtime/parser.mjs

@@ -45,8 +45,7 @@ export function setParserMode(mode) {
 
 function resolveMode() {
   if (_mode) return _mode;
-  const g = typeof globalThis !== 'undefined' ? globalThis : {};
-  if (g.__TURBO_DOM_PARSER_MODE__) return g.__TURBO_DOM_PARSER_MODE__;
+  if (globalThis.__TURBO_DOM_PARSER_MODE__) return globalThis.__TURBO_DOM_PARSER_MODE__;
   if (typeof process !== 'undefined' && process.env && process.env.TURBO_DOM_PARSER) return process.env.TURBO_DOM_PARSER;
   return 'auto';
 }
@@ -56,8 +55,7 @@ function resolveMode() {
 // freely without caching it themselves.
 export function getParser() {
   if (_parser) return _parser;
-  const g = typeof globalThis !== 'undefined' ? globalThis : {};
-  if (g.__TURBO_DOM_PARSER__) return (_parser = g.__TURBO_DOM_PARSER__);
+  if (globalThis.__TURBO_DOM_PARSER__) return (_parser = globalThis.__TURBO_DOM_PARSER__);
   const mode = resolveMode();
   if (mode === 'wasm') return (_parser = loadWasm());
   if (mode === 'native') return (_parser = loadNative());