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

package/cpp/quickjs/bindings/DocumentBindings.cpp

@@ -1,8 +1,11 @@
 #include "DocumentBindings.hpp"
 #include "LiveCollectionBindings.hpp"
+#include "DOMExceptionBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
 #include "../../lexbor/LexborDocument.hpp"
+#include <lexbor/html/html.h>
+#include <lexbor/dom/dom.h>
 #include <cstring>
 #include <string>
 
@@ -103,6 +106,92 @@ JSValue js_doc_createTextNode(JSContext* ctx, JSValue, int argc, JSValue* argv)
   return make_element(ctx, node);
 }
 
+// Implements the WHATWG "validate and extract a namespace and qualified name"
+// algorithm (https://dom.spec.whatwg.org/#validate-and-extract): splits
+// qualifiedName into prefix/localName and checks the namespace/prefix
+// consistency rules, throwing the spec-mandated DOMException on failure.
+// Full XML Name-production character validation (which characters are legal
+// in a Name) is not implemented — only structural checks (empty name, colon
+// placement, xml/xmlns reservations) — deliberately narrower than real
+// jsdom, since that character-class check is a much larger, separate lift.
+JSValue validate_and_extract_qname(JSContext* ctx, const std::string& ns,
+                                    const std::string& qualifiedName, bool ns_is_null,
+                                    std::string& out_prefix, std::string& out_local) {
+  if (qualifiedName.empty()) {
+    return throw_dom_exception(ctx, "InvalidCharacterError",
+        "The qualified name provided is empty.");
+  }
+
+  auto colon = qualifiedName.find(':');
+  auto last_colon = qualifiedName.rfind(':');
+  if (colon != last_colon) {
+    return throw_dom_exception(ctx, "InvalidCharacterError",
+        "The qualified name provided has more than one ':'.");
+  }
+
+  std::string prefix;
+  std::string local = qualifiedName;
+  if (colon != std::string::npos) {
+    prefix = qualifiedName.substr(0, colon);
+    local = qualifiedName.substr(colon + 1);
+    if (prefix.empty() || local.empty()) {
+      return throw_dom_exception(ctx, "InvalidCharacterError",
+          "The qualified name provided is malformed.");
+    }
+  }
+
+  if (!prefix.empty() && ns_is_null) {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "A namespace is required for a prefixed qualified name.");
+  }
+  if (prefix == "xml" && ns != "http://www.w3.org/XML/1998/namespace") {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "The 'xml' prefix requires the XML namespace.");
+  }
+  bool is_xmlns = (qualifiedName == "xmlns" || prefix == "xmlns");
+  if (is_xmlns && ns != "http://www.w3.org/2000/xmlns/") {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "The 'xmlns' prefix/qualified name requires the XMLNS namespace.");
+  }
+  if (!is_xmlns && ns == "http://www.w3.org/2000/xmlns/") {
+    return throw_dom_exception(ctx, "NamespaceError",
+        "The XMLNS namespace requires the 'xmlns' prefix or qualified name.");
+  }
+
+  out_prefix = prefix;
+  out_local = local;
+  return JS_UNDEFINED;
+}
+
+JSValue js_doc_createElementNS(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 2) {
+    return JS_ThrowTypeError(ctx,
+        "Failed to execute 'createElementNS' on 'Document': 2 arguments required.");
+  }
+  // Per WebIDL, a nullable DOMString? argument only maps to the null
+  // namespace when explicitly `null` — `undefined` stringifies to "undefined"
+  // like any other DOMString argument, it is not treated as null.
+  bool ns_is_null = JS_IsNull(argv[0]);
+  std::string ns;
+  if (!ns_is_null) {
+    const char* ns_c = JS_ToCString(ctx, argv[0]);
+    if (!ns_c) return JS_EXCEPTION;
+    ns = ns_c;
+    JS_FreeCString(ctx, ns_c);
+  }
+  const char* qname = JS_ToCString(ctx, argv[1]);
+  if (!qname) return JS_EXCEPTION;
+  std::string qualifiedName = qname;
+  JS_FreeCString(ctx, qname);
+
+  std::string prefix, local;
+  JSValue validation_error = validate_and_extract_qname(ctx, ns, qualifiedName, ns_is_null, prefix, local);
+  if (JS_IsException(validation_error)) return validation_error;
+
+  void* el = get_doc(ctx)->createElementNS(ns, qualifiedName);
+  return make_element(ctx, el);
+}
+
 JSValue js_doc_createComment(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   if (argc < 1) return JS_NULL;
   const char* text = JS_ToCString(ctx, argv[0]);
@@ -116,6 +205,28 @@ JSValue js_doc_createDocumentFragment(JSContext* ctx, JSValue, int, JSValue*) {
   return make_element(ctx, get_doc(ctx)->createDocumentFragment());
 }
 
+JSValue js_doc_importNode(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  if (argc < 1) {
+    return JS_ThrowTypeError(ctx,
+        "Failed to execute 'importNode' on 'Document': 1 argument required, but only 0 present.");
+  }
+  auto* node = unwrap_node(ctx, argv[0]);
+  if (!node) {
+    return JS_ThrowTypeError(ctx,
+        "Failed to execute 'importNode' on 'Document': parameter 1 is not of type 'Node'.");
+  }
+  if (node->type == LXB_DOM_NODE_TYPE_DOCUMENT) {
+    return throw_dom_exception(ctx, "NotSupportedError",
+        "Failed to execute 'importNode' on 'Document': The node provided is a document, which may not be imported.");
+  }
+  bool deep = argc >= 2 && JS_ToBool(ctx, argv[1]) > 0;
+
+  lxb_dom_document_t* target_doc = lxb_dom_interface_document(
+      static_cast<lxb_html_document_t*>(get_doc(ctx)->documentHtmlPtr()));
+  lxb_dom_node_t* imported = lxb_dom_document_import_node(target_doc, node, deep);
+  return make_element(ctx, imported);
+}
+
 JSValue js_doc_get_body(JSContext* ctx, JSValue) {
   return make_element(ctx, get_doc(ctx)->body());
 }
@@ -147,20 +258,51 @@ JSValue js_doc_get_doctype(JSContext* ctx, JSValue) {
     return JS_DupValue(ctx, *static_cast<JSValue*>(rctx->doctype_wrapper));
   }
 
-  JSValue obj = JS_NewObject(ctx);
-  std::string name = get_doc(ctx)->doctypeName(dt);
-  JS_SetPropertyStr(ctx, obj, "name",      JS_NewStringLen(ctx, name.data(), name.size()));
-  std::string publicId = get_doc(ctx)->doctypePublicId(dt);
-  JS_SetPropertyStr(ctx, obj, "publicId",  JS_NewStringLen(ctx, publicId.data(), publicId.size()));
-  std::string systemId = get_doc(ctx)->doctypeSystemId(dt);
-  JS_SetPropertyStr(ctx, obj, "systemId",  JS_NewStringLen(ctx, systemId.data(), systemId.size()));
-  JS_SetPropertyStr(ctx, obj, "nodeType",  JS_NewInt32(ctx, 10));
-  JS_SetPropertyStr(ctx, obj, "nodeName",  JS_NewStringLen(ctx, name.data(), name.size()));
-
+  JSValue obj = build_doctype_object(ctx, get_doc(ctx), dt);
   if (rctx) rctx->doctype_wrapper = new JSValue(JS_DupValue(ctx, obj));
   return obj;
 }
 
+JSValue js_doc_get_activeElement(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  if (rctx && rctx->active_element) return make_element(ctx, rctx->active_element);
+  return make_element(ctx, get_doc(ctx)->body());
+}
+
+JSValue js_doc_get_currentScript(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  if (rctx && rctx->current_script) return make_element(ctx, rctx->current_script);
+  return JS_NULL;
+}
+
+JSValue js_doc_get_readyState(JSContext* ctx, JSValue) {
+  auto* rctx = get_ctx(ctx);
+  const std::string& state = rctx ? rctx->ready_state : "loading";
+  return JS_NewStringLen(ctx, state.data(), state.size());
+}
+
+// A doctype-less document renders in quirks mode in every real browser (and
+// jsdom mirrors that), so this is a real, if approximate, signal rather than
+// a hardcoded stub — no actual quirks-mode CSS behavior differs here since
+// there's no layout engine to diverge.
+JSValue js_doc_get_compatMode(JSContext* ctx, JSValue) {
+  bool has_doctype = get_doc(ctx)->doctype() != nullptr;
+  const char* mode = has_doctype ? "CSS1Compat" : "BackCompat";
+  return JS_NewString(ctx, mode);
+}
+
+// document uses its own object/prototype (not node_proto), so it doesn't
+// inherit the Node-level baseURI getter — mirrors js_el_get_baseURI in
+// ElementBindings.cpp (always location.href; no <base> element support).
+JSValue js_doc_get_baseURI(JSContext* ctx, JSValue) {
+  JSValue global = JS_GetGlobalObject(ctx);
+  JSValue location = JS_GetPropertyStr(ctx, global, "location");
+  JS_FreeValue(ctx, global);
+  JSValue href = JS_GetPropertyStr(ctx, location, "href");
+  JS_FreeValue(ctx, location);
+  return href;
+}
+
 const char* kDocumentTitleBootstrapScript = R"JS(
 (function() {
   Object.defineProperty(document, 'title', {
@@ -199,9 +341,11 @@ void DocumentBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, doc, "getElementsByTagName",   JS_NewCFunction(ctx, js_doc_getElementsByTagName,   "getElementsByTagName",   1));
   JS_SetPropertyStr(ctx, doc, "getElementsByName",      JS_NewCFunction(ctx, js_doc_getElementsByName,      "getElementsByName",      1));
   JS_SetPropertyStr(ctx, doc, "createElement",          JS_NewCFunction(ctx, js_doc_createElement,          "createElement",          1));
+  JS_SetPropertyStr(ctx, doc, "createElementNS",        JS_NewCFunction(ctx, js_doc_createElementNS,        "createElementNS",        2));
   JS_SetPropertyStr(ctx, doc, "createTextNode",         JS_NewCFunction(ctx, js_doc_createTextNode,         "createTextNode",         1));
   JS_SetPropertyStr(ctx, doc, "createComment",          JS_NewCFunction(ctx, js_doc_createComment,          "createComment",          1));
   JS_SetPropertyStr(ctx, doc, "createDocumentFragment", JS_NewCFunction(ctx, js_doc_createDocumentFragment, "createDocumentFragment", 0));
+  JS_SetPropertyStr(ctx, doc, "importNode",             JS_NewCFunction(ctx, js_doc_importNode,             "importNode",             2));
 
   define_prop(ctx, doc, "body",            js_doc_get_body,            nullptr);
   define_prop(ctx, doc, "head",            js_doc_get_head,            nullptr);
@@ -211,14 +355,33 @@ void DocumentBindings::install(JSContext* ctx) {
   define_prop(ctx, doc, "images",          js_doc_get_images,          nullptr);
   define_prop(ctx, doc, "scripts",         js_doc_get_scripts,         nullptr);
   define_prop(ctx, doc, "links",           js_doc_get_links,           nullptr);
+  define_prop(ctx, doc, "activeElement",   js_doc_get_activeElement,   nullptr);
+  define_prop(ctx, doc, "currentScript",   js_doc_get_currentScript,   nullptr);
+  define_prop(ctx, doc, "readyState",      js_doc_get_readyState,      nullptr);
+  define_prop(ctx, doc, "compatMode",      js_doc_get_compatMode,      nullptr);
+  define_prop(ctx, doc, "baseURI",         js_doc_get_baseURI,         nullptr);
+
+  JS_SetPropertyStr(ctx, doc, "characterSet", JS_NewString(ctx, "UTF-8"));
+  JS_SetPropertyStr(ctx, doc, "contentType",  JS_NewString(ctx, "text/html"));
 
   RuntimeContext* rctx = get_ctx(ctx);
   bool hidden = !(rctx && rctx->pretend_to_be_visual);
   JS_SetPropertyStr(ctx, doc, "hidden", JS_NewBool(ctx, hidden));
+  JS_SetPropertyStr(ctx, doc, "visibilityState", JS_NewString(ctx, hidden ? "hidden" : "visible"));
+  JS_SetPropertyStr(ctx, doc, "nodeType", JS_NewInt32(ctx, 9 /* DOCUMENT_NODE */));
+  JS_SetPropertyStr(ctx, doc, "nodeName", JS_NewString(ctx, "#document"));
+  JS_SetPropertyStr(ctx, doc, "ownerDocument", JS_NULL);
+  // document uses its own object/prototype (not node_proto), so it doesn't
+  // inherit js_el_get_namespaceURI — set explicitly rather than leaving this
+  // undefined, matching real jsdom (a Document node has no namespace).
+  JS_SetPropertyStr(ctx, doc, "namespaceURI", JS_NULL);
 
   JSValue document_proto = JS_NewObject(ctx);
   JS_SetPrototype(ctx, doc, document_proto);
-  JS_FreeValue(ctx, define_global_constructor(ctx, "Document", document_proto));
+  define_node_type_constants(ctx, document_proto);
+  JSValue document_ctor = define_global_constructor(ctx, "Document", document_proto);
+  define_node_type_constants(ctx, document_ctor);
+  JS_FreeValue(ctx, document_ctor);
   JS_FreeValue(ctx, document_proto);
 
   JS_SetPropertyStr(ctx, global, "document", doc);