@salve-software/react-native-nitro-jsdom 1.0.0

package/cpp/quickjs/DOMBindingsInternal.cpp

@@ -0,0 +1,157 @@
+#include "DOMBindingsInternal.hpp"
+#include "QuickJSRuntime.hpp"
+#include "../lexbor/LexborDocument.hpp"
+#include <lexbor/html/html.h>
+#include <lexbor/dom/dom.h>
+#include <cctype>
+#include <sstream>
+
+namespace margelo::nitro::nitrojsdom {
+
+JSClassID js_element_class_id = 0;
+JSClassID js_node_class_id    = 0;
+
+namespace {
+JSClassDef js_element_class = { "Element", .finalizer = nullptr };
+} // namespace
+
+JSValue make_element(JSContext* ctx, void* ptr) {
+  if (!ptr) return JS_NULL;
+
+  RuntimeContext* rctx = get_ctx(ctx);
+  if (rctx) {
+    auto it = rctx->node_wrapper_cache.find(ptr);
+    if (it != rctx->node_wrapper_cache.end()) {
+      JSValue* cached = static_cast<JSValue*>(it->second);
+      return JS_DupValue(ctx, *cached);
+    }
+  }
+
+  lxb_dom_node_t* node = static_cast<lxb_dom_node_t*>(ptr);
+  JSValue obj;
+  if (node->type == LXB_DOM_NODE_TYPE_ELEMENT) {
+    obj = JS_NewObjectClass(ctx, js_element_class_id);
+  } else {
+    obj = JS_NewObjectClass(ctx, js_node_class_id);
+  }
+  JS_SetOpaque(obj, ptr);
+
+  if (rctx) {
+    rctx->node_wrapper_cache[ptr] = new JSValue(JS_DupValue(ctx, obj));
+  }
+
+  return obj;
+}
+
+void invalidate_node_cache(JSContext* ctx, RuntimeContext* rctx, void* node) {
+  if (!rctx || !node) return;
+  auto it = rctx->node_wrapper_cache.find(node);
+  if (it != rctx->node_wrapper_cache.end()) {
+    JSValue* v = static_cast<JSValue*>(it->second);
+    JS_SetOpaque(*v, nullptr);
+    JS_FreeValue(ctx, *v);
+    delete v;
+    rctx->node_wrapper_cache.erase(it);
+  }
+}
+
+void invalidate_node_cache_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& nodes) {
+  for (void* n : nodes) invalidate_node_cache(ctx, rctx, n);
+}
+
+void clear_node_cache(JSContext* ctx, RuntimeContext* rctx) {
+  if (!rctx) return;
+  for (auto& kv : rctx->node_wrapper_cache) {
+    JSValue* v = static_cast<JSValue*>(kv.second);
+    JS_SetOpaque(*v, nullptr);
+    JS_FreeValue(ctx, *v);
+    delete v;
+  }
+  rctx->node_wrapper_cache.clear();
+}
+
+JSValue make_element_array(JSContext* ctx, const std::vector<void*>& elements) {
+  JSValue arr = JS_NewArray(ctx);
+  for (size_t i = 0; i < elements.size(); i++)
+    JS_SetPropertyUint32(ctx, arr, (uint32_t)i, make_element(ctx, elements[i]));
+  return arr;
+}
+
+lxb_dom_element_t* unwrap_element(JSContext* ctx, JSValue val) {
+  return static_cast<lxb_dom_element_t*>(JS_GetOpaque(val, js_element_class_id));
+}
+
+lxb_dom_node_t* unwrap_node(JSContext* ctx, JSValue val) {
+  void* p = JS_GetOpaque(val, js_element_class_id);
+  if (p) return static_cast<lxb_dom_node_t*>(p);
+  p = JS_GetOpaque(val, js_node_class_id);
+  return static_cast<lxb_dom_node_t*>(p);
+}
+
+std::string serialize_node(lxb_dom_node_t* node) {
+  std::string result;
+  lxb_html_serialize_tree_cb(node,
+    [](const lxb_char_t* data, size_t len, void* ctx) -> lxb_status_t {
+      static_cast<std::string*>(ctx)->append(reinterpret_cast<const char*>(data), len);
+      return LXB_STATUS_OK;
+    }, &result);
+  return result;
+}
+
+RuntimeContext* get_ctx(JSContext* ctx) {
+  return static_cast<RuntimeContext*>(JS_GetContextOpaque(ctx));
+}
+
+LexborDocument* get_doc(JSContext* ctx) {
+  auto* rctx = get_ctx(ctx);
+  return rctx ? rctx->document : nullptr;
+}
+
+void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter) {
+  JSAtom atom = JS_NewAtom(ctx, name);
+  JSValue get_fn = JS_NewCFunction2(ctx, (JSCFunction*)getter, name, 0, JS_CFUNC_getter, 0);
+  JSValue set_fn = setter
+      ? JS_NewCFunction2(ctx, (JSCFunction*)setter, name, 1, JS_CFUNC_setter, 0)
+      : JS_UNDEFINED;
+  JS_DefinePropertyGetSet(ctx, obj, atom, get_fn, set_fn, JS_PROP_CONFIGURABLE);
+  JS_FreeAtom(ctx, atom);
+}
+
+bool get_bool_prop(JSContext* ctx, JSValue obj, const char* name) {
+  JSValue v = JS_GetPropertyStr(ctx, obj, name);
+  bool b = JS_ToBool(ctx, v) > 0;
+  JS_FreeValue(ctx, v);
+  return b;
+}
+
+std::string classNames_to_selector(const std::string& names) {
+  std::string sel;
+  std::istringstream iss(names);
+  std::string cls;
+  while (iss >> cls) { sel += '.'; sel += cls; }
+  return sel;
+}
+
+// data-foo-bar -> fooBar ; background-color -> backgroundColor
+std::string attr_suffix_to_camel(const std::string& suffix) {
+  std::string out;
+  bool upper_next = false;
+  for (char c : suffix) {
+    if (c == '-') { upper_next = true; continue; }
+    out += upper_next ? (char)std::toupper((unsigned char)c) : c;
+    upper_next = false;
+  }
+  return out;
+}
+
+// fooBar -> foo-bar ; backgroundColor -> background-color
+std::string camel_to_attr_suffix(const std::string& camel) {
+  std::string out;
+  for (char c : camel) {
+    if (std::isupper((unsigned char)c)) { out += '-'; out += (char)std::tolower((unsigned char)c); }
+    else out += c;
+  }
+  return out;
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/DOMBindingsInternal.hpp

@@ -0,0 +1,83 @@
+#pragma once
+
+// Internal header shared across the QuickJS binding translation units
+// (ElementBindings.cpp, DocumentBindings.cpp, EventBindings.cpp, TimerBindings.cpp,
+// WindowBindings.cpp, FetchBindings.cpp, MutationObservers.cpp, ...).
+//
+// DOMBindings::install() (DOMBindings.cpp) is the only orchestrator: it calls each
+// of the *Bindings::install(ctx) entry points in order. Everything below is the
+// small set of helpers those entry points need from one another.
+
+#include "quickjs.h"
+#include <string>
+#include <vector>
+
+// Forward-declared at global scope (not inside our namespace) so this matches
+// the real lxb_dom_element_t/lxb_dom_node_t typedefs from lexbor's own headers
+// bit-for-bit when both are included in the same translation unit.
+struct lxb_dom_element;
+struct lxb_dom_node;
+typedef struct lxb_dom_element lxb_dom_element_t;
+typedef struct lxb_dom_node lxb_dom_node_t;
+
+namespace margelo::nitro::nitrojsdom {
+
+struct RuntimeContext;
+class LexborDocument;
+
+// ── Element / Node class IDs + wrapping ──────────────────────────────────────
+// js_element_class_id wraps lxb_dom_element_t* — real element nodes only.
+// js_node_class_id    wraps lxb_dom_node_t*    — text, comment, document, etc.
+//
+// make_element() dispatches on the node type: Element nodes get the element
+// class (which exposes getAttribute, classList, etc.); all other nodes get the
+// node class (Node traversal only). This prevents non-element nodes from
+// reaching lxb_dom_element_* calls.
+//
+// unwrap_element() returns non-null only for element-class objects.
+// unwrap_node()    returns non-null for either class (shared Node methods).
+
+extern JSClassID js_element_class_id;
+extern JSClassID js_node_class_id;
+
+JSValue make_element(JSContext* ctx, void* node_or_el);
+JSValue make_element_array(JSContext* ctx, const std::vector<void*>& elements);
+lxb_dom_element_t* unwrap_element(JSContext* ctx, JSValue val);
+lxb_dom_node_t*    unwrap_node(JSContext* ctx, JSValue val);
+std::string serialize_node(lxb_dom_node_t* node);
+
+// ── RuntimeContext access ─────────────────────────────────────────────────────
+
+RuntimeContext* get_ctx(JSContext* ctx);
+LexborDocument* get_doc(JSContext* ctx);
+
+// ── Node wrapper cache ────────────────────────────────────────────────────────
+
+void invalidate_node_cache(JSContext* ctx, RuntimeContext* rctx, void* node);
+void invalidate_node_cache_batch(JSContext* ctx, RuntimeContext* rctx, const std::vector<void*>& nodes);
+void clear_node_cache(JSContext* ctx, RuntimeContext* rctx);
+
+// ── Accessor property helper ──────────────────────────────────────────────────
+
+using GetterFn = JSValue (*)(JSContext*, JSValue);
+using SetterFn = JSValue (*)(JSContext*, JSValue, JSValue);
+
+void define_prop(JSContext* ctx, JSValue obj, const char* name, GetterFn getter, SetterFn setter = nullptr);
+
+// ── Misc shared helpers ───────────────────────────────────────────────────────
+
+// Reads a boolean-ish property off any JS object (used by Event dispatch to read
+// bubbles/cancelable/defaultPrevented/internal propagation flags).
+bool get_bool_prop(JSContext* ctx, JSValue obj, const char* name);
+
+// Builds a CSS selector matching elements with every class in `names` (a
+// space-separated list), e.g. "foo bar" -> ".foo.bar". Shared by
+// Element::getElementsByClassName and document.getElementsByClassName.
+std::string classNames_to_selector(const std::string& names);
+
+// camelCase <-> kebab-case conversion shared by DatasetBindings (data-foo-bar
+// <-> fooBar) and StyleBindings (background-color <-> backgroundColor).
+std::string attr_suffix_to_camel(const std::string& suffix);
+std::string camel_to_attr_suffix(const std::string& camel);
+
+} // namespace margelo::nitro::nitrojsdom