@salve-software/react-native-nitro-jsdom 1.1.0 → 2.1.0

package/cpp/quickjs/bindings/CSSOMBindings.cpp

@@ -201,6 +201,56 @@ const char* kCSSOMBootstrapScript = R"JS(
   globalThis.CSSStyleRule = CSSStyleRule;
   globalThis.CSSStyleSheet = CSSStyleSheet;
 
+  function cssEscape(value) {
+    var string = String(value);
+    var length = string.length;
+    var index = -1;
+    var result = '';
+    var firstCodeUnit = string.charCodeAt(0);
+
+    if (length === 1 && firstCodeUnit === 0x002D) {
+      return '\\' + string;
+    }
+
+    while (++index < length) {
+      var codeUnit = string.charCodeAt(index);
+      if (codeUnit === 0x0000) {
+        result += '\uFFFD';
+        continue;
+      }
+      if (
+        (codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit === 0x007F ||
+        (index === 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+        (index === 1 && codeUnit >= 0x0030 && codeUnit <= 0x0039 && firstCodeUnit === 0x002D)
+      ) {
+        result += '\\' + codeUnit.toString(16) + ' ';
+        continue;
+      }
+      if (
+        codeUnit >= 0x0080 || codeUnit === 0x002D || codeUnit === 0x005F ||
+        (codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+        (codeUnit >= 0x0041 && codeUnit <= 0x005A) ||
+        (codeUnit >= 0x0061 && codeUnit <= 0x007A)
+      ) {
+        result += string.charAt(index);
+        continue;
+      }
+      result += '\\' + string.charAt(index);
+    }
+    return result;
+  }
+
+  globalThis.CSS = {
+    escape: cssEscape,
+    supports: function(propertyOrCondition, value) {
+      if (arguments.length >= 2) {
+        return typeof propertyOrCondition === 'string' && propertyOrCondition.length > 0 &&
+          value !== undefined && String(value).length > 0;
+      }
+      return typeof propertyOrCondition === 'string' && propertyOrCondition.trim().length > 0;
+    },
+  };
+
   Object.defineProperty(Element.prototype, 'sheet', {
     get: function() {
       if (this.tagName !== 'STYLE') return null;
@@ -227,6 +277,52 @@ const char* kCSSOMBootstrapScript = R"JS(
     },
     configurable: true,
   });
+
+  // ── getComputedStyle ──────────────────────────────────────────────────
+  // No layout/cascade engine backs this sandbox — there is no stylesheet
+  // specificity resolution or inheritance, only the element's own inline
+  // `style` attribute. `display` falls back to a small user-agent-stylesheet
+  // approximation (block/inline/inline-block/none by tag name, or 'none' for
+  // a `hidden` attribute) since "is this element visible" is the one
+  // getComputedStyle check real-world embedded scripts actually make;
+  // `visibility`/`opacity` fall back to their initial values. Every other
+  // unset property returns '', not a computed initial value.
+  var kBlockTags = { ADDRESS: 1, ARTICLE: 1, ASIDE: 1, BLOCKQUOTE: 1, DETAILS: 1, DIALOG: 1, DD: 1, DIV: 1,
+    DL: 1, DT: 1, FIELDSET: 1, FIGCAPTION: 1, FIGURE: 1, FOOTER: 1, FORM: 1, H1: 1, H2: 1, H3: 1, H4: 1,
+    H5: 1, H6: 1, HEADER: 1, HGROUP: 1, HR: 1, LI: 1, MAIN: 1, NAV: 1, OL: 1, P: 1, PRE: 1, SECTION: 1,
+    TABLE: 1, UL: 1, HTML: 1, BODY: 1 };
+  var kNoneTags = { SCRIPT: 1, STYLE: 1, HEAD: 1, TITLE: 1, META: 1, LINK: 1, TEMPLATE: 1 };
+  var kInlineBlockTags = { IMG: 1, BUTTON: 1, INPUT: 1, SELECT: 1, TEXTAREA: 1 };
+
+  function defaultDisplay(tagName) {
+    if (kNoneTags[tagName]) return 'none';
+    if (kInlineBlockTags[tagName]) return 'inline-block';
+    if (kBlockTags[tagName]) return 'block';
+    return 'inline';
+  }
+
+  function resolveProperty(el, kebabName) {
+    var v = el.style.getPropertyValue(kebabName);
+    if (v) return v;
+    if (kebabName === 'display') return el.hasAttribute('hidden') ? 'none' : defaultDisplay(el.tagName);
+    if (kebabName === 'visibility') return 'visible';
+    if (kebabName === 'opacity') return '1';
+    return '';
+  }
+
+  globalThis.getComputedStyle = function(el) {
+    if (!el || typeof el.tagName !== 'string') {
+      throw new TypeError("Failed to execute 'getComputedStyle': parameter 1 is not of type 'Element'.");
+    }
+    return new Proxy({}, {
+      get: function(_target, prop) {
+        if (prop === 'getPropertyValue') return function(name) { return resolveProperty(el, String(name)); };
+        if (prop === 'getPropertyPriority') return function() { return ''; };
+        if (typeof prop !== 'string') return undefined;
+        return resolveProperty(el, camelToKebab(prop));
+      },
+    });
+  };
 })();
 )JS";
 

package/cpp/quickjs/bindings/CSSOMBindings.hpp

@@ -5,7 +5,9 @@
 namespace margelo::nitro::nitrojsdom {
 
 // Registers a minimal CSSOM: globalThis.CSSRule/CSSStyleRule/CSSStyleSheet,
-// Element.prototype.sheet (tag-checked for "style"), and document.styleSheets.
+// Element.prototype.sheet (tag-checked for "style"), document.styleSheets,
+// and globalThis.getComputedStyle (inline-style + tag-default-display only,
+// no real cascade — see the bootstrap script for the exact fallback rules).
 //
 // Rules are split by a hand-rolled top-level brace scanner rather than
 // Lexbor's CSS rule/declaration AST (lxb_css_rule_t) — mirrors how

package/cpp/quickjs/bindings/CustomElementsBindings.cpp

@@ -27,7 +27,7 @@ const char* kCustomElementsBootstrapScript = R"JS(
     var n = node;
     while (n) {
       if (n === docEl) return true;
-      n = ('host' in n) ? n.host : n.parentNode;
+      n = (n instanceof ShadowRoot) ? n.host : n.parentNode;
     }
     return false;
   }

package/cpp/quickjs/bindings/DOMParserBindings.cpp

@@ -0,0 +1,299 @@
+#include "DOMParserBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
+#include "../../lexbor/LexborDocument.hpp"
+#include <cstring>
+#include <string>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassID js_parsed_document_class_id = 0;
+JSClassDef js_parsed_document_class = { "Document", .finalizer = nullptr };
+
+LexborDocument* unwrap_parsed_doc(JSContext* ctx, JSValue val) {
+  return static_cast<LexborDocument*>(JS_GetOpaque(val, js_parsed_document_class_id));
+}
+
+JSValue make_parsed_document(JSContext* ctx, LexborDocument* doc) {
+  register_document(ctx, doc);
+  JSValue obj = JS_NewObjectClass(ctx, js_parsed_document_class_id);
+  JS_SetOpaque(obj, doc);
+  register_document_wrapper(ctx, doc, obj);
+  return obj;
+}
+
+// ── Document-scoped query/creation methods (mirror DocumentBindings.cpp's
+// js_doc_* functions, but resolve `this`'s own LexborDocument instead of
+// always reading the sandbox's primary get_doc(ctx)) ────────────────────────
+
+JSValue js_pdoc_getElementById(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* id = JS_ToCString(ctx, argv[0]);
+  if (!id) return JS_NULL;
+  void* el = doc->getElementById(id);
+  JS_FreeCString(ctx, id);
+  return make_element(ctx, el);
+}
+
+JSValue js_pdoc_querySelector(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* sel = JS_ToCString(ctx, argv[0]);
+  if (!sel) return JS_NULL;
+  void* el = doc->querySelector_el(sel);
+  JS_FreeCString(ctx, sel);
+  return make_element(ctx, el);
+}
+
+JSValue js_pdoc_querySelectorAll(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NewArray(ctx);
+  const char* sel = JS_ToCString(ctx, argv[0]);
+  if (!sel) return JS_NewArray(ctx);
+  auto results = doc->querySelectorAll_el(sel);
+  JS_FreeCString(ctx, sel);
+  return make_element_array(ctx, results);
+}
+
+// Static snapshot, not a live HTMLCollection — see header comment.
+JSValue js_pdoc_getElementsByClassName(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NewArray(ctx);
+  const char* names = JS_ToCString(ctx, argv[0]);
+  if (!names) return JS_NewArray(ctx);
+  auto results = doc->querySelectorAll_el(classNames_to_selector(names));
+  JS_FreeCString(ctx, names);
+  return make_element_array(ctx, results);
+}
+
+// Static snapshot, not a live HTMLCollection — see header comment.
+JSValue js_pdoc_getElementsByTagName(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NewArray(ctx);
+  const char* tag = JS_ToCString(ctx, argv[0]);
+  if (!tag) return JS_NewArray(ctx);
+  auto results = doc->querySelectorAll_el(tag);
+  JS_FreeCString(ctx, tag);
+  return make_element_array(ctx, results);
+}
+
+JSValue js_pdoc_createElement(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* tag = JS_ToCString(ctx, argv[0]);
+  if (!tag) return JS_NULL;
+  void* el = doc->createElement(tag);
+  JS_FreeCString(ctx, tag);
+  return make_element(ctx, el);
+}
+
+JSValue js_pdoc_createTextNode(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* text = JS_ToCString(ctx, argv[0]);
+  if (!text) return JS_NULL;
+  void* node = doc->createTextNode(text);
+  JS_FreeCString(ctx, text);
+  return make_element(ctx, node);
+}
+
+JSValue js_pdoc_createComment(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc || argc < 1) return JS_NULL;
+  const char* text = JS_ToCString(ctx, argv[0]);
+  if (!text) return JS_NULL;
+  void* node = doc->createComment(text);
+  JS_FreeCString(ctx, text);
+  return make_element(ctx, node);
+}
+
+JSValue js_pdoc_createDocumentFragment(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc) return JS_NULL;
+  return make_element(ctx, doc->createDocumentFragment());
+}
+
+JSValue js_pdoc_get_body(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  return doc ? make_element(ctx, doc->body()) : JS_NULL;
+}
+
+JSValue js_pdoc_get_head(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  return doc ? make_element(ctx, doc->head()) : JS_NULL;
+}
+
+JSValue js_pdoc_get_documentElement(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  return doc ? make_element(ctx, doc->documentElement()) : JS_NULL;
+}
+
+// Unlike document.doctype (DocumentBindings.cpp), this isn't cached: a
+// secondary document is far less likely to have `.doctype` read repeatedly,
+// so a fresh plain object per access keeps this file simpler.
+JSValue js_pdoc_get_doctype(JSContext* ctx, JSValue this_val) {
+  auto* doc = unwrap_parsed_doc(ctx, this_val);
+  if (!doc) return JS_NULL;
+  void* dt = doc->doctype();
+  if (!dt) return JS_NULL;
+  return build_doctype_object(ctx, doc, dt);
+}
+
+// ── DOMParser.parseFromString() / document.implementation.createHTMLDocument() ─
+
+JSValue js_native_parse_from_string(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 2) return JS_ThrowTypeError(ctx, "parseFromString requires 2 arguments");
+  const char* html = JS_ToCString(ctx, argv[0]);
+  if (!html) return JS_EXCEPTION;
+  const char* type = JS_ToCString(ctx, argv[1]);
+  if (!type) { JS_FreeCString(ctx, html); return JS_EXCEPTION; }
+
+  static const char* kSupportedTypes[] = {
+    "text/html", "text/xml", "application/xml", "application/xhtml+xml", "image/svg+xml",
+  };
+  bool supported = false;
+  for (const char* t : kSupportedTypes) {
+    if (std::strcmp(type, t) == 0) { supported = true; break; }
+  }
+  if (!supported) {
+    std::string msg = "Invalid DOMParser type: " + std::string(type);
+    JS_FreeCString(ctx, html);
+    JS_FreeCString(ctx, type);
+    return JS_ThrowTypeError(ctx, "%s", msg.c_str());
+  }
+  // Every supported type is parsed with the HTML parser regardless of MIME
+  // type — this sandbox has no separate XML parser wired up. Good enough for
+  // the common case (parsing HTML/XHTML/SVG markup); genuine XML-specific
+  // syntax (e.g. CDATA sections, processing instructions) is not modeled.
+  JS_FreeCString(ctx, type);
+
+  auto* doc = new LexborDocument();
+  doc->parse(html);
+  JS_FreeCString(ctx, html);
+
+  auto* rctx = get_ctx(ctx);
+  JSValue result = make_parsed_document(ctx, doc);
+  if (rctx) rctx->extra_documents.emplace_back(doc);
+  return result;
+}
+
+JSValue js_native_create_html_document(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  std::string title;
+  if (argc >= 1 && !JS_IsUndefined(argv[0])) {
+    const char* t = JS_ToCString(ctx, argv[0]);
+    if (t) { title = t; JS_FreeCString(ctx, t); }
+  }
+  std::string escaped;
+  escaped.reserve(title.size());
+  for (char c : title) {
+    if (c == '<') escaped += "&lt;";
+    else if (c == '>') escaped += "&gt;";
+    else if (c == '&') escaped += "&amp;";
+    else escaped += c;
+  }
+
+  auto* doc = new LexborDocument();
+  doc->parse("<!doctype html><html><head><title>" + escaped + "</title></head><body></body></html>");
+
+  auto* rctx = get_ctx(ctx);
+  JSValue result = make_parsed_document(ctx, doc);
+  if (rctx) rctx->extra_documents.emplace_back(doc);
+  return result;
+}
+
+const char* kDOMParserBootstrapScript = R"JS(
+(function() {
+  function DOMParser() {}
+  DOMParser.prototype.parseFromString = function(str, type) {
+    return __nativeParseFromString(String(str), String(type));
+  };
+  globalThis.DOMParser = DOMParser;
+
+  document.implementation = {
+    createHTMLDocument: function(title) {
+      return __nativeCreateHTMLDocument(title === undefined ? undefined : String(title));
+    },
+  };
+
+  function definePDocTitle(proto) {
+    Object.defineProperty(proto, 'title', {
+      configurable: true,
+      get: function() {
+        var head = this.head;
+        if (!head) return '';
+        var titleEl = head.querySelector('title');
+        return titleEl ? titleEl.textContent : '';
+      },
+      set: function(value) {
+        var head = this.head;
+        if (!head) return;
+        var titleEl = head.querySelector('title');
+        if (!titleEl) {
+          titleEl = this.createElement('title');
+          head.appendChild(titleEl);
+        }
+        titleEl.textContent = String(value);
+      },
+    });
+  }
+  definePDocTitle(globalThis.__parsedDocumentProto);
+  delete globalThis.__parsedDocumentProto;
+})();
+)JS";
+
+} // namespace
+
+void DOMParserBindings::install(JSContext* ctx) {
+  JS_NewClassID(&js_parsed_document_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_parsed_document_class_id, &js_parsed_document_class);
+
+  JSValue proto = JS_NewObject(ctx);
+  JS_SetPropertyStr(ctx, proto, "getElementById", JS_NewCFunction(ctx, js_pdoc_getElementById, "getElementById", 1));
+  JS_SetPropertyStr(ctx, proto, "querySelector", JS_NewCFunction(ctx, js_pdoc_querySelector, "querySelector", 1));
+  JS_SetPropertyStr(ctx, proto, "querySelectorAll", JS_NewCFunction(ctx, js_pdoc_querySelectorAll, "querySelectorAll", 1));
+  JS_SetPropertyStr(ctx, proto, "getElementsByClassName", JS_NewCFunction(ctx, js_pdoc_getElementsByClassName, "getElementsByClassName", 1));
+  JS_SetPropertyStr(ctx, proto, "getElementsByTagName", JS_NewCFunction(ctx, js_pdoc_getElementsByTagName, "getElementsByTagName", 1));
+  JS_SetPropertyStr(ctx, proto, "createElement", JS_NewCFunction(ctx, js_pdoc_createElement, "createElement", 1));
+  JS_SetPropertyStr(ctx, proto, "createTextNode", JS_NewCFunction(ctx, js_pdoc_createTextNode, "createTextNode", 1));
+  JS_SetPropertyStr(ctx, proto, "createComment", JS_NewCFunction(ctx, js_pdoc_createComment, "createComment", 1));
+  JS_SetPropertyStr(ctx, proto, "createDocumentFragment", JS_NewCFunction(ctx, js_pdoc_createDocumentFragment, "createDocumentFragment", 0));
+
+  define_prop(ctx, proto, "body", js_pdoc_get_body, nullptr);
+  define_prop(ctx, proto, "head", js_pdoc_get_head, nullptr);
+  define_prop(ctx, proto, "documentElement", js_pdoc_get_documentElement, nullptr);
+  define_prop(ctx, proto, "doctype", js_pdoc_get_doctype, nullptr);
+
+  JS_SetPropertyStr(ctx, proto, "nodeType", JS_NewInt32(ctx, 9 /* DOCUMENT_NODE */));
+  JS_SetPropertyStr(ctx, proto, "nodeName", JS_NewString(ctx, "#document"));
+  JS_SetPropertyStr(ctx, proto, "ownerDocument", JS_NULL);
+  define_node_type_constants(ctx, proto);
+
+  JSValue global = JS_GetGlobalObject(ctx);
+
+  // Chain onto Document.prototype (set up by DocumentBindings.cpp) purely so
+  // `parsedDoc instanceof Document` holds, matching real jsdom/browsers.
+  JSValue document_ctor = JS_GetPropertyStr(ctx, global, "Document");
+  JSValue document_proto_val = JS_GetPropertyStr(ctx, document_ctor, "prototype");
+  JS_SetPrototype(ctx, proto, document_proto_val);
+  JS_FreeValue(ctx, document_proto_val);
+  JS_FreeValue(ctx, document_ctor);
+
+  JS_SetClassProto(ctx, js_parsed_document_class_id, JS_DupValue(ctx, proto));
+
+  JS_SetPropertyStr(ctx, global, "__parsedDocumentProto", proto);
+  JS_SetPropertyStr(ctx, global, "__nativeParseFromString", JS_NewCFunction(ctx, js_native_parse_from_string, "__nativeParseFromString", 2));
+  JS_SetPropertyStr(ctx, global, "__nativeCreateHTMLDocument", JS_NewCFunction(ctx, js_native_create_html_document, "__nativeCreateHTMLDocument", 1));
+  JS_FreeValue(ctx, global);
+
+  JSValue result = JS_Eval(ctx, kDOMParserBootstrapScript, strlen(kDOMParserBootstrapScript),
+                            "<domparser-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, result);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DOMParserBindings.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+// Registers globalThis.DOMParser (`.parseFromString()`) and
+// document.implementation.createHTMLDocument(), each of which produces a
+// genuinely separate, inert Document backed by its own LexborDocument
+// instance (see doc_for_node()/register_document() in DOMBindingsInternal —
+// that's what makes mutating a second document safe rather than corrupting
+// the primary document's memory arena).
+//
+// Scope, matching real-world DOMParser usage (parsing a fetched/embedded
+// HTML string and reading it back, occasionally assembling a few new nodes):
+//   - Full read/query support: querySelector(All), getElementById,
+//     getElementsBy{ClassName,TagName} (as static snapshots, not live
+//     HTMLCollections — see below), all generic Node traversal/attribute
+//     methods (those are shared with the primary document's Element/Node
+//     prototypes and don't need document-specific wiring).
+//   - createElement/createTextNode/createComment/createDocumentFragment,
+//     appendChild/removeChild/insertBefore/replaceChild, and the
+//     textContent/innerHTML setters/insertAdjacentHTML/matches()/closest()
+//     inherited from Element.prototype — all resolve the correct owning
+//     document dynamically, so building up a secondary document is fully
+//     safe, not just read-only.
+//   - title get/set (mirrors document.title's head/<title> shim).
+// Not supported on secondary documents (their bindings are hardwired to the
+// primary document — see ShadowRootBindings/CustomElementsBindings/
+// TemplateBindings/LiveCollectionBindings): Shadow DOM (attachShadow),
+// Custom Elements, <template>.content, MutationObserver, live
+// HTMLCollections (.forms/.images/.scripts/.links, and
+// getElementsBy{ClassName,TagName} return static arrays here instead).
+// Scripts inside parsed HTML never execute (per spec, these documents are
+// inert) — no script pipeline is wired to them.
+//
+// Must run after ElementBindings (shares its Element/Node classes/protos)
+// and DocumentBindings (adds .implementation onto globalThis.document).
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+class DOMParserBindings {
+public:
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom