npm - @miaskiewicz/turbo-dom - Versions diffs - 0.1.2 - Mend

@miaskiewicz/turbo-dom 0.1.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (27) hide show

package/Cargo.lock +588 -0
package/Cargo.toml +34 -0
package/LICENSE +21 -0
package/README.md +151 -0
package/build.rs +4 -0
package/index.d.ts +62 -0
package/index.js +318 -0
package/package.json +121 -0
package/src/core.rs +492 -0
package/src/environment/install.mjs +34 -0
package/src/environment/jest.cjs +40 -0
package/src/environment/vitest.mjs +31 -0
package/src/lib.rs +161 -0
package/src/runtime/buffer.mjs +35 -0
package/src/runtime/collections.mjs +50 -0
package/src/runtime/dom.mjs +863 -0
package/src/runtime/events.mjs +213 -0
package/src/runtime/html-serialize.mjs +72 -0
package/src/runtime/index.mjs +46 -0
package/src/runtime/selectors.mjs +239 -0
package/src/runtime/stubs.mjs +148 -0
package/src/runtime/window.mjs +168 -0
package/turbo-dom-parser.darwin-arm64.node +0 -0
package/turbo-dom-parser.linux-arm64-gnu.node +0 -0
package/turbo-dom-parser.linux-x64-gnu.node +0 -0
package/turbo-dom-parser.linux-x64-musl.node +0 -0
package/turbo-dom-parser.win32-x64-msvc.node +0 -0

package/README.md ADDED Viewed

@@ -0,0 +1,151 @@
+# turbo-dom
+A faster, more spec-correct DOM for test runners — a drop-in-style alternative to
+**jsdom** and **happy-dom** for **vitest** and **jest**.
+The HTML parser is native ([html5ever](https://github.com/servo/html5ever), Servo's
+WHATWG tree constructor, via Rust/N-API with a WASM fallback). The DOM itself stays in
+JavaScript but is **lazy** — nodes inflate from a compact typed-array buffer only when a
+test touches them, and `window` globals materialize only on first use.
+```bash
+npm install -D @miaskiewicz/turbo-dom
+```
+- ✅ **More compatible than happy-dom** — 99.72% on html5lib-tests vs happy-dom's 37%.
+  Runs React Testing Library, `user-event`, downshift, Radix UI, and Headless UI unmodified.
+- ⚡ **Faster than jsdom** — ~19× lower per-file setup, 11–39× faster HTML parsing.
+- 🎯 **Honest, not lying** — no fake layout numbers; `getBoundingClientRect()` is zeros and
+  `getComputedStyle` reflects only what you set. Geometry tests belong in a real browser.
+## Quick start
+### vitest
+```ts
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+export default defineConfig({
+  test: {
+    environment: '@miaskiewicz/turbo-dom/environment/vitest',
+  },
+});
+```
+### jest
+```js
+// jest.config.js
+module.exports = {
+  testEnvironment: '@miaskiewicz/turbo-dom/jest',
+};
+```
+Now `document`, `window`, and friends are global in your tests — write them exactly like
+you would against jsdom/happy-dom:
+```js
+import { render, screen } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+test('counter increments', async () => {
+  render(<Counter />);
+  await userEvent.click(screen.getByRole('button'));
+  expect(screen.getByText('count: 1')).toBeInTheDocument();
+});
+```
+### Without a test runner
+```js
+import { createEnvironment } from '@miaskiewicz/turbo-dom/runtime';
+const env = createEnvironment('<!doctype html><body><div id="app"></div></body>');
+env.document.querySelector('#app');     // nodes inflate lazily from the parse buffer
+env.window.localStorage;                // globals materialize on first touch
+env.reset();                            // fast per-file reset (reuses the parse buffer)
+```
+### Just the parser
+```js
+const { parse, parseBuffer, parseFragment } = require('@miaskiewicz/turbo-dom');
+parse('<div id=a><span>hi</span></div>');         // nested tree
+parseBuffer('<div id=a>...</div>');                // compact SoA typed-array buffer
+parseFragment('<rect/>', 'svg path');              // fragment in a context element
+```
+## Compatibility
+| | turbo-dom | happy-dom | jsdom |
+|---|---|---|---|
+| html5lib-tests conformance | **99.72%** | 37.35% | 97.03% |
+| @testing-library/dom + user-event | ✅ | ✅ | ✅ |
+| React + Radix / Headless UI / downshift | ✅ | partial | ✅ |
+| Real layout / `getComputedStyle` cascade | ❌ (honest stub) | partial | partial |
+turbo-dom inherits Servo's tree constructor, so the "messy input" cases hand-rolled parsers
+get wrong — adoption-agency reparenting (`<a><p></a></p>`), table foster-parenting, optional
+end tags, `<template>` content, SVG/MathML — all match the spec. The 5 remaining
+conformance misses are bleeding-edge `<select>`-family proposals upstream `html5ever` hasn't
+adopted yet.
+## Performance
+Measured on darwin-arm64, Node 24 (`npm run bench:all`):
+| benchmark | turbo-dom | happy-dom | jsdom |
+|---|---:|---:|---:|
+| per-file setup + 1 query (ops/s) | **6,808** | 526 | 266 |
+| full suite, 200 files (ms/file) | **0.13** | 1.45 | 3.36 |
+| parse 56 KB SSR (ops/s) | **502** | 46 | 23 |
+| parse 20 KB real page (ops/s) | **3,912** | 230 | 100 |
+Why it's fast: parsing is native; the JS DOM doesn't allocate node objects for parts of the
+tree a test never reads; and `window` doesn't build the ~12 globals (storage, observers,
+matchMedia…) a render-only test never touches.
+## How it works
+```
+test code (RTL, user-event)
+   └─ lazy window (Proxy, self-replacing globals)        ← JS
+   └─ lazy copy-on-write node tree (memoized identity)   ← JS
+   └─ immutable Structure-of-Arrays parse buffer          ← shared
+        └─ Rust: html5ever → flat typed-array buffer       ← native (N-API / WASM)
+```
+The parser runs in Rust (compute-bound, one boundary crossing per parse). The DOM stays in
+JS (chatty, fine-grained) but pays only for what a test touches. Full design notes:
+[turbo-dom-spec.md](./turbo-dom-spec.md).
+## Limitations (by design)
+- **No layout.** `getBoundingClientRect()` returns zeros; `getClientRects()` is empty.
+- **`getComputedStyle` is inline-only** — it reflects the `style` attribute and explicitly
+  set properties, never an invented cascade. Style/geometry assertions belong in a real
+  browser (Playwright/WebDriver).
+- Canvas, `<select>` rendering, and similar visual APIs are honest no-op stubs.
+## Development
+Requires Node ≥ 18 and a Rust toolchain (`rustup`, stable).
+```bash
+npm install
+npm run build          # native addon (.node)
+npm test               # JS suite (unit, conformance, differential, gauntlets)
+npm run test:rust      # Rust core tests
+npm run conformance    # html5lib-tests report
+npm run bench:all      # benchmarks
+npm run build:wasm     # wasm32 fallback
+```
+Contributions welcome — issues and PRs at
+[github.com/miaskiewicz/turbo-dom](https://github.com/miaskiewicz/turbo-dom).
+## License
+[MIT](./LICENSE).

package/build.rs ADDED Viewed

@@ -0,0 +1,4 @@
+fn main() {
+    #[cfg(feature = "napi-bind")]
+    napi_build::setup();
+}

package/index.d.ts ADDED Viewed

@@ -0,0 +1,62 @@
+/* tslint:disable */
+/* eslint-disable */
+/* auto-generated by NAPI-RS */
+/**
+ * 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).
+ */
+export interface JsNode {
+  nodeType: number
+  name: string
+  value: string
+  namespace: string
+  publicId: string
+  systemId: string
+  attrs: Array<JsAttr>
+  children: Array<JsNode>
+}
+export interface JsAttr {
+  name: string
+  value: string
+  prefix: string
+}
+/** Parse a full HTML document. Boundary crossed exactly once. */
+export declare function parse(html: string): JsNode
+/**
+ * Parse-only: returns node count, builds no JS tree. For isolating raw parse
+ * cost from tree-build + boundary marshaling in benchmarks.
+ */
+export declare function parseRaw(html: string): number
+/**
+ * SoA flat buffer: structure as typed arrays, crossed once. JS inflates node
+ * objects lazily from this — no eager full-tree allocation. The fast path.
+ */
+export interface JsSoa {
+  nodeType: Uint8Array
+  ns: Uint8Array
+  tagId: Uint32Array
+  parent: Int32Array
+  firstChild: Int32Array
+  nextSib: Int32Array
+  textId: Int32Array
+  pubId: Int32Array
+  sysId: Int32Array
+  attrStart: Int32Array
+  attrCount: Uint16Array
+  attrNameId: Uint32Array
+  attrValue: Array<string>
+  attrPrefixId: Uint32Array
+  tagNames: Array<string>
+  attrNames: Array<string>
+  attrPrefixes: Array<string>
+  strings: Array<string>
+}
+/** Parse a document into the SoA flat buffer (the fast runtime path). */
+export declare function parseBuffer(html: string): JsSoa
+/**
+ * Parse an HTML fragment (innerHTML-style). `context` is the context element:
+ * e.g. "body" (default), "td", or namespaced "svg path" / "math ms".
+ */
+export declare function parseFragment(html: string, context?: string | undefined | null): JsNode

package/index.js ADDED Viewed

@@ -0,0 +1,318 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+/* auto-generated by NAPI-RS */
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+const { platform, arch } = process
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'turbo-dom-parser.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.android-arm64.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'turbo-dom-parser.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'turbo-dom-parser.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'turbo-dom-parser.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'turbo-dom-parser.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'turbo-dom-parser.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./turbo-dom-parser.darwin-universal.node')
+      } else {
+        nativeBinding = require('@miaskiewicz/turbo-dom-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'turbo-dom-parser.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.darwin-x64.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'turbo-dom-parser.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'turbo-dom-parser.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./turbo-dom-parser.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@miaskiewicz/turbo-dom-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'turbo-dom-parser.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./turbo-dom-parser.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@miaskiewicz/turbo-dom-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'turbo-dom-parser.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./turbo-dom-parser.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@miaskiewicz/turbo-dom-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+const { parse, parseRaw, parseBuffer, parseFragment } = nativeBinding
+module.exports.parse = parse
+module.exports.parseRaw = parseRaw
+module.exports.parseBuffer = parseBuffer
+module.exports.parseFragment = parseFragment

package/package.json ADDED Viewed

@@ -0,0 +1,121 @@
+{
+  "name": "@miaskiewicz/turbo-dom",
+  "version": "0.1.2",
+  "description": "Faster, more spec-correct DOM for test runners — native html5ever (Rust/WASM) parser + lazy copy-on-write DOM. A drop-in-style alternative to jsdom/happy-dom for vitest & jest.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.js"
+    },
+    "./runtime": {
+      "types": "./src/runtime/index.d.ts",
+      "import": "./src/runtime/index.mjs"
+    },
+    "./environment/vitest": {
+      "import": "./src/environment/vitest.mjs"
+    },
+    "./jest": {
+      "require": "./src/environment/jest.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "*.node",
+    "src/**/*.mjs",
+    "src/**/*.cjs",
+    "src/**/*.d.ts",
+    "src/*.rs",
+    "build.rs",
+    "Cargo.toml",
+    "Cargo.lock",
+    "LICENSE",
+    "README.md"
+  ],
+  "napi": {
+    "name": "turbo-dom-parser",
+    "triples": {
+      "defaults": true,
+      "additional": [
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
+        "aarch64-unknown-linux-gnu",
+        "aarch64-apple-darwin",
+        "x86_64-pc-windows-msvc"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "build:wasm": "cargo build --release --no-default-features --features wasm-bind --target wasm32-unknown-unknown",
+    "build:wasm:pkg": "wasm-pack build --target nodejs --out-dir pkg --no-default-features --features wasm-bind",
+    "test": "node --test 'test/*.mjs'",
+    "test:rust": "cargo test --lib",
+    "test:all": "npm run build && npm run test:rust && npm test",
+    "conformance": "node harness/conformance.mjs",
+    "conformance:delta": "node harness/delta.mjs",
+    "bench": "node bench/parse.mjs",
+    "bench:construct": "node bench/construct.mjs",
+    "bench:suite": "node bench/suite.mjs",
+    "bench:wasm": "node bench/wasm.mjs",
+    "bench:all": "node bench/parse.mjs && node bench/construct.mjs && node bench/suite.mjs && node bench/wasm.mjs",
+    "prepublishOnly": "napi build --platform --release"
+  },
+  "keywords": [
+    "dom",
+    "html",
+    "html5ever",
+    "parser",
+    "jsdom",
+    "happy-dom",
+    "vitest",
+    "jest",
+    "test-environment",
+    "testing",
+    "napi",
+    "wasm"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/miaskiewicz/turbo-dom.git"
+  },
+  "homepage": "https://github.com/miaskiewicz/turbo-dom#readme",
+  "bugs": {
+    "url": "https://github.com/miaskiewicz/turbo-dom/issues"
+  },
+  "author": "miaskiewicz",
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "jest-environment-node": ">=29",
+    "vitest": ">=1"
+  },
+  "peerDependenciesMeta": {
+    "jest-environment-node": {
+      "optional": true
+    },
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@headlessui/react": "^2.2.10",
+    "@napi-rs/cli": "^2.18.4",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@testing-library/user-event": "^14.6.1",
+    "downshift": "^9.3.6",
+    "happy-dom": "^20.10.1",
+    "jsdom": "^29.1.1",
+    "parse5": "^8.0.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  }
+}