@miaskiewicz/turbo-dom 0.1.2

package/src/lib.rs

@@ -0,0 +1,161 @@
+//! turbo-dom parser — Layer 1.
+//! One Rust core (`core`), two interchangeable front-ends selected by feature:
+//!   * `napi-bind`  → native Node addon (default, fast path)
+//!   * `wasm-bind`  → wasm32 fallback (StackBlitz / WebContainers / locked-down CI)
+//! Both expose the same logical API: parse(html) -> tree, parseFragment(html) -> tree.
+
+pub mod core;
+
+// ---------------------------------------------------------------------------
+// napi-rs front-end (native addon)
+// ---------------------------------------------------------------------------
+#[cfg(feature = "napi-bind")]
+mod napi_front {
+    use crate::core;
+    use napi_derive::napi;
+
+    /// Marshaled node returned to JS. Mirrors `core::Node` as a napi object so the
+    /// whole tree crosses the boundary in one return value (full-marshaling mode).
+    #[napi(object)]
+    pub struct JsNode {
+        pub node_type: u8,
+        pub name: String,
+        pub value: String,
+        pub namespace: String,
+        pub public_id: String,
+        pub system_id: String,
+        pub attrs: Vec<JsAttr>,
+        pub children: Vec<JsNode>,
+    }
+
+    #[napi(object)]
+    pub struct JsAttr {
+        pub name: String,
+        pub value: String,
+        pub prefix: String,
+    }
+
+    impl From<core::Node> for JsNode {
+        fn from(n: core::Node) -> Self {
+            JsNode {
+                node_type: n.node_type,
+                name: n.name,
+                value: n.value,
+                namespace: n.namespace,
+                public_id: n.public_id,
+                system_id: n.system_id,
+                attrs: n
+                    .attrs
+                    .into_iter()
+                    .map(|a| JsAttr { name: a.name, value: a.value, prefix: a.prefix })
+                    .collect(),
+                children: n.children.into_iter().map(JsNode::from).collect(),
+            }
+        }
+    }
+
+    /// Parse a full HTML document. Boundary crossed exactly once.
+    #[napi]
+    pub fn parse(html: String) -> JsNode {
+        core::parse_html_document(&html).into()
+    }
+
+    /// Parse-only: returns node count, builds no JS tree. For isolating raw parse
+    /// cost from tree-build + boundary marshaling in benchmarks.
+    #[napi(js_name = "parseRaw")]
+    pub fn parse_raw(html: String) -> u32 {
+        core::parse_html_document_count(&html)
+    }
+
+    use napi::bindgen_prelude::{Int32Array, Uint16Array, Uint32Array, Uint8Array};
+
+    /// SoA flat buffer: structure as typed arrays, crossed once. JS inflates node
+    /// objects lazily from this — no eager full-tree allocation. The fast path.
+    #[napi(object)]
+    pub struct JsSoa {
+        pub node_type: Uint8Array,
+        pub ns: Uint8Array,
+        pub tag_id: Uint32Array,
+        pub parent: Int32Array,
+        pub first_child: Int32Array,
+        pub next_sib: Int32Array,
+        pub text_id: Int32Array,
+        pub pub_id: Int32Array,
+        pub sys_id: Int32Array,
+        pub attr_start: Int32Array,
+        pub attr_count: Uint16Array,
+        pub attr_name_id: Uint32Array,
+        pub attr_value: Vec<String>,
+        pub attr_prefix_id: Uint32Array,
+        pub tag_names: Vec<String>,
+        pub attr_names: Vec<String>,
+        pub attr_prefixes: Vec<String>,
+        pub strings: Vec<String>,
+    }
+
+    impl From<core::Soa> for JsSoa {
+        fn from(s: core::Soa) -> Self {
+            JsSoa {
+                node_type: Uint8Array::new(s.node_type),
+                ns: Uint8Array::new(s.ns),
+                tag_id: Uint32Array::new(s.tag_id),
+                parent: Int32Array::new(s.parent),
+                first_child: Int32Array::new(s.first_child),
+                next_sib: Int32Array::new(s.next_sib),
+                text_id: Int32Array::new(s.text_id),
+                pub_id: Int32Array::new(s.pub_id),
+                sys_id: Int32Array::new(s.sys_id),
+                attr_start: Int32Array::new(s.attr_start),
+                attr_count: Uint16Array::new(s.attr_count),
+                attr_name_id: Uint32Array::new(s.attr_name_id),
+                attr_value: s.attr_value,
+                attr_prefix_id: Uint32Array::new(s.attr_prefix_id),
+                tag_names: s.tag_names,
+                attr_names: s.attr_names,
+                attr_prefixes: s.attr_prefixes,
+                strings: s.strings,
+            }
+        }
+    }
+
+    /// Parse a document into the SoA flat buffer (the fast runtime path).
+    #[napi(js_name = "parseBuffer")]
+    pub fn parse_buffer(html: String) -> JsSoa {
+        core::parse_html_soa(&html).into()
+    }
+
+    /// Parse an HTML fragment (innerHTML-style). `context` is the context element:
+    /// e.g. "body" (default), "td", or namespaced "svg path" / "math ms".
+    #[napi(js_name = "parseFragment")]
+    pub fn parse_fragment(html: String, context: Option<String>) -> JsNode {
+        core::parse_html_fragment_context(&html, context.as_deref().unwrap_or("")).into()
+    }
+}
+
+// ---------------------------------------------------------------------------
+// wasm-bindgen front-end (fallback)
+// ---------------------------------------------------------------------------
+#[cfg(feature = "wasm-bind")]
+mod wasm_front {
+    use crate::core;
+    use wasm_bindgen::prelude::*;
+
+    /// Same contract as the native addon, marshaled via serde → JS object.
+    #[wasm_bindgen]
+    pub fn parse(html: &str) -> Result<JsValue, JsValue> {
+        let tree = core::parse_html_document(html);
+        serde_wasm_bindgen::to_value(&tree).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "parseFragment")]
+    pub fn parse_fragment(html: &str, context: Option<String>) -> Result<JsValue, JsValue> {
+        let tree = core::parse_html_fragment_context(html, context.as_deref().unwrap_or(""));
+        serde_wasm_bindgen::to_value(&tree).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+
+    #[wasm_bindgen(js_name = "parseBuffer")]
+    pub fn parse_buffer(html: &str) -> Result<JsValue, JsValue> {
+        let soa = core::parse_html_soa(html);
+        serde_wasm_bindgen::to_value(&soa).map_err(|e| JsValue::from_str(&e.to_string()))
+    }
+}

package/src/runtime/buffer.mjs

@@ -0,0 +1,35 @@
+// SoA buffer accessor. Reads tree structure straight from the typed arrays the
+// native parser produced — no node objects allocated until something asks.
+
+const NS_SHORT = ['', 'svg', 'math'];
+
+export class Buffer {
+  constructor(soa) {
+    this.soa = soa;
+    this.length = soa.nodeType.length;
+  }
+  nodeType(i) { return this.soa.nodeType[i]; }
+  ns(i) { return NS_SHORT[this.soa.ns[i]] || ''; }
+  tagName(i) { return this.soa.tagNames[this.soa.tagId[i]]; }
+  parent(i) { return this.soa.parent[i]; }
+  firstChild(i) { return this.soa.firstChild[i]; }
+  nextSib(i) { return this.soa.nextSib[i]; }
+  text(i) { const t = this.soa.textId[i]; return t < 0 ? '' : this.soa.strings[t]; }
+  publicId(i) { const t = this.soa.pubId[i]; return t < 0 ? '' : this.soa.strings[t]; }
+  systemId(i) { const t = this.soa.sysId[i]; return t < 0 ? '' : this.soa.strings[t]; }
+  attrs(i) {
+    const start = this.soa.attrStart[i];
+    if (start < 0) return [];
+    const count = this.soa.attrCount[i];
+    const out = new Array(count);
+    const { attrNameId, attrNames, attrValue, attrPrefixId, attrPrefixes } = this.soa;
+    for (let k = 0; k < count; k++) {
+      out[k] = {
+        name: attrNames[attrNameId[start + k]],
+        value: attrValue[start + k],
+        prefix: attrPrefixes[attrPrefixId[start + k]] || '',
+      };
+    }
+    return out;
+  }
+}

package/src/runtime/collections.mjs

@@ -0,0 +1,50 @@
+// Live collections. Each reads its backing array on every access, so they
+// reflect mutations immediately — the exact place happy-dom bleeds liveness bugs.
+
+function makeLive(getArray, extra = {}) {
+  const target = function () {};
+  return new Proxy(target, {
+    get(_t, key) {
+      const arr = getArray();
+      if (key === 'length') return arr.length;
+      if (key === 'item') return (i) => arr[i] ?? null;
+      if (key === 'forEach') return (cb, thisArg) => arr.forEach(cb, thisArg);
+      if (key === 'entries') return () => arr.entries();
+      if (key === 'keys') return () => arr.keys();
+      if (key === 'values') return () => arr[Symbol.iterator]();
+      if (key === Symbol.iterator) return () => arr[Symbol.iterator]();
+      if (key === 'toString') return () => '[object NodeList]';
+      if (key in extra) return extra[key](arr);
+      if (typeof key === 'string' && /^\d+$/.test(key)) return arr[Number(key)] ?? undefined;
+      return undefined;
+    },
+    has(_t, key) {
+      const arr = getArray();
+      if (typeof key === 'string' && /^\d+$/.test(key)) return Number(key) < arr.length;
+      return key === 'length' || key === 'item' || key === 'forEach' || key in extra;
+    },
+    ownKeys() {
+      const arr = getArray();
+      return [...arr.keys()].map(String).concat('length');
+    },
+    getOwnPropertyDescriptor(_t, key) {
+      const arr = getArray();
+      if (key === 'length') return { configurable: true, enumerable: false, value: arr.length };
+      if (typeof key === 'string' && /^\d+$/.test(key) && Number(key) < arr.length) {
+        return { configurable: true, enumerable: true, value: arr[Number(key)] };
+      }
+      return undefined;
+    },
+  });
+}
+
+export function liveNodeList(getArray) {
+  return makeLive(getArray);
+}
+
+export function liveHTMLCollection(getArray) {
+  return makeLive(getArray, {
+    namedItem: (arr) => (name) =>
+      arr.find((el) => el.getAttribute('id') === name || el.getAttribute('name') === name) ?? null,
+  });
+}