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

package/cpp/quickjs/bindings/EventBindings.cpp

@@ -71,6 +71,89 @@ JSValue js_CustomEvent_constructor(JSContext* ctx, JSValue, int argc, JSValue* a
   return obj;
 }
 
+// Reads a numeric/string init-dict field, falling back to `def` if the field
+// is absent or the dict itself wasn't passed — shared by KeyboardEvent and
+// MouseEvent, whose constructors otherwise differ only in which fields they copy.
+double get_num_init_field(JSContext* ctx, JSValue init, const char* name, double def) {
+  if (!JS_IsObject(init)) return def;
+  JSValue v = JS_GetPropertyStr(ctx, init, name);
+  if (JS_IsException(v)) { JS_FreeValue(ctx, JS_GetException(ctx)); return def; }
+  if (JS_IsUndefined(v)) { JS_FreeValue(ctx, v); return def; }
+  double d = def;
+  JS_ToFloat64(ctx, &d, v);
+  JS_FreeValue(ctx, v);
+  return d;
+}
+
+// get_bool_prop() (DOMBindingsInternal.hpp) assumes a real object receiver;
+// init dicts are optional, so this guards the JS_IsObject check first.
+bool get_bool_init_field(JSContext* ctx, JSValue init, const char* name) {
+  if (!JS_IsObject(init)) return false;
+  return get_bool_prop(ctx, init, name);
+}
+
+std::string get_str_init_field(JSContext* ctx, JSValue init, const char* name, const char* def) {
+  if (!JS_IsObject(init)) return def;
+  JSValue v = JS_GetPropertyStr(ctx, init, name);
+  if (JS_IsException(v)) { JS_FreeValue(ctx, JS_GetException(ctx)); return def; }
+  if (JS_IsUndefined(v)) { JS_FreeValue(ctx, v); return def; }
+  const char* s = JS_ToCString(ctx, v);
+  std::string result = s ? s : def;
+  if (s) JS_FreeCString(ctx, s);
+  JS_FreeValue(ctx, v);
+  return result;
+}
+
+JSValue js_KeyboardEvent_constructor(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  JSValue obj = JS_NewObjectClass(ctx, js_event_class_id);
+  const char* type_str = (argc >= 1) ? JS_ToCString(ctx, argv[0]) : nullptr;
+  JS_SetPropertyStr(ctx, obj, "type", JS_NewString(ctx, type_str ? type_str : ""));
+  if (type_str) JS_FreeCString(ctx, type_str);
+
+  JSValue init = (argc >= 2) ? argv[1] : JS_UNDEFINED;
+  JS_SetPropertyStr(ctx, obj, "bubbles",    JS_NewBool(ctx, get_bool_init_field(ctx, init, "bubbles")));
+  JS_SetPropertyStr(ctx, obj, "cancelable", JS_NewBool(ctx, get_bool_init_field(ctx, init, "cancelable")));
+  JS_SetPropertyStr(ctx, obj, "defaultPrevented", JS_NewBool(ctx, false));
+
+  std::string key = get_str_init_field(ctx, init, "key", "");
+  std::string code = get_str_init_field(ctx, init, "code", "");
+  JS_SetPropertyStr(ctx, obj, "key",      JS_NewStringLen(ctx, key.c_str(), key.size()));
+  JS_SetPropertyStr(ctx, obj, "code",     JS_NewStringLen(ctx, code.c_str(), code.size()));
+  JS_SetPropertyStr(ctx, obj, "location", JS_NewInt32(ctx, (int32_t)get_num_init_field(ctx, init, "location", 0)));
+  JS_SetPropertyStr(ctx, obj, "repeat",   JS_NewBool(ctx, get_bool_init_field(ctx, init, "repeat")));
+  JS_SetPropertyStr(ctx, obj, "ctrlKey",  JS_NewBool(ctx, get_bool_init_field(ctx, init, "ctrlKey")));
+  JS_SetPropertyStr(ctx, obj, "shiftKey", JS_NewBool(ctx, get_bool_init_field(ctx, init, "shiftKey")));
+  JS_SetPropertyStr(ctx, obj, "altKey",   JS_NewBool(ctx, get_bool_init_field(ctx, init, "altKey")));
+  JS_SetPropertyStr(ctx, obj, "metaKey",  JS_NewBool(ctx, get_bool_init_field(ctx, init, "metaKey")));
+  return obj;
+}
+
+JSValue js_MouseEvent_constructor(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  JSValue obj = JS_NewObjectClass(ctx, js_event_class_id);
+  const char* type_str = (argc >= 1) ? JS_ToCString(ctx, argv[0]) : nullptr;
+  JS_SetPropertyStr(ctx, obj, "type", JS_NewString(ctx, type_str ? type_str : ""));
+  if (type_str) JS_FreeCString(ctx, type_str);
+
+  JSValue init = (argc >= 2) ? argv[1] : JS_UNDEFINED;
+  JS_SetPropertyStr(ctx, obj, "bubbles",    JS_NewBool(ctx, get_bool_init_field(ctx, init, "bubbles")));
+  JS_SetPropertyStr(ctx, obj, "cancelable", JS_NewBool(ctx, get_bool_init_field(ctx, init, "cancelable")));
+  JS_SetPropertyStr(ctx, obj, "defaultPrevented", JS_NewBool(ctx, false));
+
+  JS_SetPropertyStr(ctx, obj, "clientX", JS_NewFloat64(ctx, get_num_init_field(ctx, init, "clientX", 0)));
+  JS_SetPropertyStr(ctx, obj, "clientY", JS_NewFloat64(ctx, get_num_init_field(ctx, init, "clientY", 0)));
+  JS_SetPropertyStr(ctx, obj, "screenX", JS_NewFloat64(ctx, get_num_init_field(ctx, init, "screenX", 0)));
+  JS_SetPropertyStr(ctx, obj, "screenY", JS_NewFloat64(ctx, get_num_init_field(ctx, init, "screenY", 0)));
+  JS_SetPropertyStr(ctx, obj, "pageX",   JS_NewFloat64(ctx, get_num_init_field(ctx, init, "pageX", 0)));
+  JS_SetPropertyStr(ctx, obj, "pageY",   JS_NewFloat64(ctx, get_num_init_field(ctx, init, "pageY", 0)));
+  JS_SetPropertyStr(ctx, obj, "button",  JS_NewInt32(ctx, (int32_t)get_num_init_field(ctx, init, "button", 0)));
+  JS_SetPropertyStr(ctx, obj, "buttons", JS_NewInt32(ctx, (int32_t)get_num_init_field(ctx, init, "buttons", 0)));
+  JS_SetPropertyStr(ctx, obj, "ctrlKey",  JS_NewBool(ctx, get_bool_init_field(ctx, init, "ctrlKey")));
+  JS_SetPropertyStr(ctx, obj, "shiftKey", JS_NewBool(ctx, get_bool_init_field(ctx, init, "shiftKey")));
+  JS_SetPropertyStr(ctx, obj, "altKey",   JS_NewBool(ctx, get_bool_init_field(ctx, init, "altKey")));
+  JS_SetPropertyStr(ctx, obj, "metaKey",  JS_NewBool(ctx, get_bool_init_field(ctx, init, "metaKey")));
+  return obj;
+}
+
 // ── Event prototype methods ───────────────────────────────────────────────────
 
 JSValue js_event_preventDefault(JSContext* ctx, JSValue this_val, int, JSValue*) {
@@ -300,6 +383,39 @@ JSValue js_doc_addEventListener(JSContext* ctx, JSValue, int argc, JSValue* argv
   return JS_UNDEFINED;
 }
 
+JSValue js_doc_removeEventListener(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  auto* rctx = get_ctx(ctx);
+  if (!rctx || argc < 2 || !JS_IsFunction(ctx, argv[1])) return JS_UNDEFINED;
+  if (!rctx->document) return JS_UNDEFINED;
+
+  const char* type_str = JS_ToCString(ctx, argv[0]);
+  if (!type_str) return JS_UNDEFINED;
+  std::string event_type(type_str);
+  JS_FreeCString(ctx, type_str);
+
+  void* doc_node = lxb_dom_interface_node(
+      lxb_dom_interface_document(
+          static_cast<lxb_html_document_t*>(rctx->document->documentHtmlPtr())));
+
+  for (auto it = rctx->listeners.begin(); it != rctx->listeners.end(); ) {
+    if (it->node == doc_node && it->event_type == event_type) {
+      JSValue* stored_cb = static_cast<JSValue*>(it->callback);
+      if (JS_VALUE_GET_TAG(*stored_cb) == JS_VALUE_GET_TAG(argv[1]) &&
+          JS_VALUE_GET_PTR(*stored_cb) == JS_VALUE_GET_PTR(argv[1])) {
+        JS_FreeValue(ctx, *stored_cb);
+        delete stored_cb;
+        rctx->listeners.erase(it);
+        break; // remove first matching listener only (DOM spec)
+      } else {
+        ++it;
+      }
+    } else {
+      ++it;
+    }
+  }
+  return JS_UNDEFINED;
+}
+
 JSValue js_doc_dispatchEvent(JSContext* ctx, JSValue, int argc, JSValue* argv) {
   auto* rctx = get_ctx(ctx);
   if (!rctx || argc < 1) return JS_TRUE;
@@ -330,6 +446,10 @@ void EventBindings::install(JSContext* ctx) {
       JS_NewCFunction2(ctx, js_Event_constructor, "Event", 1, JS_CFUNC_constructor, 0));
   JS_SetPropertyStr(ctx, global, "CustomEvent",
       JS_NewCFunction2(ctx, js_CustomEvent_constructor, "CustomEvent", 2, JS_CFUNC_constructor, 0));
+  JS_SetPropertyStr(ctx, global, "KeyboardEvent",
+      JS_NewCFunction2(ctx, js_KeyboardEvent_constructor, "KeyboardEvent", 2, JS_CFUNC_constructor, 0));
+  JS_SetPropertyStr(ctx, global, "MouseEvent",
+      JS_NewCFunction2(ctx, js_MouseEvent_constructor, "MouseEvent", 2, JS_CFUNC_constructor, 0));
 
   // ── addEventListener/removeEventListener/dispatchEvent on Node + Element ──
   // Added to the Node proto so text/comment nodes can also receive events.
@@ -339,13 +459,27 @@ void EventBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, node_proto, "dispatchEvent",       JS_NewCFunction(ctx, js_el_dispatchEvent,       "dispatchEvent",       1));
   JS_FreeValue(ctx, node_proto);
 
-  // ── addEventListener/dispatchEvent on document ─────────────────────────────
+  // ── addEventListener/removeEventListener/dispatchEvent on document ────────
   // DocumentBindings::install() must have already run so globalThis.document exists.
   JSValue doc = JS_GetPropertyStr(ctx, global, "document");
-  JS_SetPropertyStr(ctx, doc, "addEventListener", JS_NewCFunction(ctx, js_doc_addEventListener, "addEventListener", 2));
-  JS_SetPropertyStr(ctx, doc, "dispatchEvent",    JS_NewCFunction(ctx, js_doc_dispatchEvent,    "dispatchEvent",    1));
+  JS_SetPropertyStr(ctx, doc, "addEventListener",    JS_NewCFunction(ctx, js_doc_addEventListener,    "addEventListener",    2));
+  JS_SetPropertyStr(ctx, doc, "removeEventListener", JS_NewCFunction(ctx, js_doc_removeEventListener, "removeEventListener", 2));
+  JS_SetPropertyStr(ctx, doc, "dispatchEvent",       JS_NewCFunction(ctx, js_doc_dispatchEvent,       "dispatchEvent",       1));
   JS_FreeValue(ctx, doc);
 
+  // ── addEventListener/removeEventListener/dispatchEvent on window ──────────
+  // window === globalThis (see QuickJSRuntime::initialize()) and has no native
+  // node of its own to key listeners by, so js_doc_addEventListener/
+  // js_doc_removeEventListener/js_doc_dispatchEvent (which never read `this`
+  // — they always resolve the target through rctx->document) are reused
+  // verbatim. This means window.addEventListener(...) and
+  // document.addEventListener(...) share one listener list/target in this
+  // sandbox — a deliberate simplification, not a real separate Window
+  // EventTarget.
+  JS_SetPropertyStr(ctx, global, "addEventListener",    JS_NewCFunction(ctx, js_doc_addEventListener,    "addEventListener",    2));
+  JS_SetPropertyStr(ctx, global, "removeEventListener", JS_NewCFunction(ctx, js_doc_removeEventListener, "removeEventListener", 2));
+  JS_SetPropertyStr(ctx, global, "dispatchEvent",       JS_NewCFunction(ctx, js_doc_dispatchEvent,       "dispatchEvent",       1));
+
   JS_FreeValue(ctx, global);
 }
 

package/cpp/quickjs/bindings/FetchBindings.cpp

@@ -141,8 +141,12 @@ const char* kFetchBootstrapScript = R"JS(
   globalThis.fetch = function(input, init) {
     return new Promise(function(resolve, reject) {
       try {
-        var url = typeof input === 'string' ? input : (input && input.url);
         init = init || {};
+        if (init.signal && init.signal.aborted) {
+          reject(init.signal.reason !== undefined ? init.signal.reason : new Error('The operation was aborted'));
+          return;
+        }
+        var url = typeof input === 'string' ? input : (input && input.url);
         var method = (init.method || 'GET').toUpperCase();
         var headers = normalizeHeaders(init.headers);
         var headersJson = JSON.stringify(headers);

package/cpp/quickjs/bindings/FormBindings.cpp

@@ -0,0 +1,142 @@
+#include "FormBindings.hpp"
+#include <cstring>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+const char* kFormBootstrapScript = R"JS(
+(function() {
+  function FormData(form) {
+    this._entries = [];
+    if (form) {
+      var els = form.querySelectorAll('input, textarea, select');
+      for (var i = 0; i < els.length; i++) {
+        var el = els[i];
+        var name = el.getAttribute('name');
+        if (!name) continue;
+        var type = (el.getAttribute('type') || '').toLowerCase();
+        if ((type === 'checkbox' || type === 'radio') && !el.checked) continue;
+        this._entries.push([name, el.value]);
+      }
+    }
+  }
+
+  FormData.prototype.append = function(name, value) {
+    this._entries.push([String(name), String(value)]);
+  };
+  FormData.prototype.set = function(name, value) {
+    name = String(name);
+    value = String(value);
+    var replaced = false;
+    var next = [];
+    for (var i = 0; i < this._entries.length; i++) {
+      var entry = this._entries[i];
+      if (entry[0] !== name) { next.push(entry); continue; }
+      if (!replaced) { next.push([name, value]); replaced = true; }
+    }
+    if (!replaced) next.push([name, value]);
+    this._entries = next;
+  };
+  FormData.prototype.get = function(name) {
+    name = String(name);
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === name) return this._entries[i][1];
+    }
+    return null;
+  };
+  FormData.prototype.getAll = function(name) {
+    name = String(name);
+    var result = [];
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === name) result.push(this._entries[i][1]);
+    }
+    return result;
+  };
+  FormData.prototype.has = function(name) {
+    name = String(name);
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] === name) return true;
+    }
+    return false;
+  };
+  FormData.prototype.delete = function(name) {
+    name = String(name);
+    var next = [];
+    for (var i = 0; i < this._entries.length; i++) {
+      if (this._entries[i][0] !== name) next.push(this._entries[i]);
+    }
+    this._entries = next;
+  };
+  FormData.prototype.forEach = function(callback, thisArg) {
+    for (var i = 0; i < this._entries.length; i++) {
+      callback.call(thisArg, this._entries[i][1], this._entries[i][0], this);
+    }
+  };
+  FormData.prototype.entries = function() {
+    var entries = this._entries;
+    var i = 0;
+    var iter = {
+      next: function() {
+        if (i >= entries.length) return { done: true, value: undefined };
+        return { done: false, value: entries[i++].slice() };
+      },
+    };
+    iter[Symbol.iterator] = function() { return iter; };
+    return iter;
+  };
+  FormData.prototype.keys = function() {
+    var it = this.entries();
+    var keysIter = {
+      next: function() {
+        var r = it.next();
+        return r.done ? r : { done: false, value: r.value[0] };
+      },
+    };
+    keysIter[Symbol.iterator] = function() { return keysIter; };
+    return keysIter;
+  };
+  FormData.prototype.values = function() {
+    var it = this.entries();
+    var valuesIter = {
+      next: function() {
+        var r = it.next();
+        return r.done ? r : { done: false, value: r.value[1] };
+      },
+    };
+    valuesIter[Symbol.iterator] = function() { return valuesIter; };
+    return valuesIter;
+  };
+  FormData.prototype[Symbol.iterator] = function() { return this.entries(); };
+
+  globalThis.FormData = FormData;
+
+  // ── form.requestSubmit() / form.submit() ──────────────────────────────────
+  function isFormElement(el) {
+    return !!el && el.tagName === 'FORM';
+  }
+  Element.prototype.requestSubmit = function(submitter) {
+    if (!isFormElement(this)) return;
+    var evt = new Event('submit', { bubbles: true, cancelable: true });
+    evt.submitter = submitter || null;
+    this.dispatchEvent(evt);
+  };
+  Element.prototype.submit = function() {
+    // Per spec, submit() bypasses the "submit" event and constraint validation.
+    // There is no real navigation in this sandbox, so this is intentionally inert.
+  };
+})();
+)JS";
+
+} // namespace
+
+void FormBindings::install(JSContext* ctx) {
+  JSValue result = JS_Eval(ctx, kFormBootstrapScript, strlen(kFormBootstrapScript),
+                            "<form-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/FormBindings.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// Registers globalThis.FormData and Element.prototype.requestSubmit/submit
+// (tag-checked for "form" internally, mirroring ElementBindings' value/checked
+// pattern). Pure JS on top of the already-exposed querySelectorAll/Event
+// primitives — no native code needed. Must run after ElementBindings (for
+// globalThis.Element) and EventBindings (for globalThis.Event).
+struct FormBindings {
+  static void install(JSContext* ctx);
+};
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/LiveCollectionBindings.cpp

@@ -0,0 +1,183 @@
+#include "LiveCollectionBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../../lexbor/LexborDocument.hpp"
+#include <lexbor/dom/dom.h>
+#include <cctype>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassID js_live_collection_class_id = 0;
+
+enum class LiveKind { CHILDREN, CHILD_NODES, SELECTOR };
+
+struct LiveCollectionData {
+  void* owner;
+  LiveKind kind;
+  std::string selector;
+};
+
+LiveCollectionData* unwrap_live(JSContext*, JSValue val) {
+  return static_cast<LiveCollectionData*>(JS_GetOpaque(val, js_live_collection_class_id));
+}
+
+std::vector<void*> compute_results(JSContext* ctx, LiveCollectionData* data) {
+  switch (data->kind) {
+    case LiveKind::CHILDREN: {
+      std::vector<void*> out;
+      auto* node = static_cast<lxb_dom_node_t*>(data->owner);
+      for (auto* c = node->first_child; c; c = c->next)
+        if (c->type == LXB_DOM_NODE_TYPE_ELEMENT) out.push_back(c);
+      return out;
+    }
+    case LiveKind::CHILD_NODES: {
+      std::vector<void*> out;
+      auto* node = static_cast<lxb_dom_node_t*>(data->owner);
+      for (auto* c = node->first_child; c; c = c->next) out.push_back(c);
+      return out;
+    }
+    case LiveKind::SELECTOR:
+      if (data->owner) return get_doc(ctx)->querySelectorAllFromEl(data->owner, data->selector);
+      return get_doc(ctx)->querySelectorAll_el(data->selector);
+  }
+  return {};
+}
+
+bool prop_is_index(const std::string& key, size_t& out_idx) {
+  if (key.empty()) return false;
+  for (char c : key) if (!std::isdigit(static_cast<unsigned char>(c))) return false;
+  out_idx = static_cast<size_t>(std::strtoul(key.c_str(), nullptr, 10));
+  return true;
+}
+
+int js_livecoll_get_own_property(JSContext* ctx, JSPropertyDescriptor* desc, JSValue obj, JSAtom prop) {
+  auto* data = unwrap_live(ctx, obj);
+  if (!data) return 0;
+
+  JSValue key_val = JS_AtomToString(ctx, prop);
+  const char* key_c = JS_ToCString(ctx, key_val);
+  std::string key = key_c ? key_c : "";
+  if (key_c) JS_FreeCString(ctx, key_c);
+  JS_FreeValue(ctx, key_val);
+
+  if (key == "length") {
+    if (desc) {
+      desc->flags = JS_PROP_ENUMERABLE;
+      desc->value = JS_NewInt32(ctx, static_cast<int32_t>(compute_results(ctx, data).size()));
+      desc->getter = JS_UNDEFINED;
+      desc->setter = JS_UNDEFINED;
+    }
+    return 1;
+  }
+
+  size_t idx;
+  if (prop_is_index(key, idx)) {
+    auto results = compute_results(ctx, data);
+    if (idx < results.size()) {
+      if (desc) {
+        desc->flags = JS_PROP_ENUMERABLE;
+        desc->value = make_element(ctx, results[idx]);
+        desc->getter = JS_UNDEFINED;
+        desc->setter = JS_UNDEFINED;
+      }
+      return 1;
+    }
+  }
+
+  return 0;
+}
+
+int js_livecoll_get_own_property_names(JSContext* ctx, JSPropertyEnum** ptab, uint32_t* plen, JSValue obj) {
+  *ptab = nullptr;
+  *plen = 0;
+  auto* data = unwrap_live(ctx, obj);
+  if (!data) return 0;
+
+  auto results = compute_results(ctx, data);
+  auto* tab = static_cast<JSPropertyEnum*>(js_malloc(ctx, sizeof(JSPropertyEnum) * (results.size() + 1)));
+  if (!tab) return -1;
+
+  for (size_t i = 0; i < results.size(); i++) {
+    tab[i].is_enumerable = 1;
+    tab[i].atom = JS_NewAtom(ctx, std::to_string(i).c_str());
+  }
+  tab[results.size()].is_enumerable = 0;
+  tab[results.size()].atom = JS_NewAtom(ctx, "length");
+
+  *ptab = tab;
+  *plen = static_cast<uint32_t>(results.size() + 1);
+  return 0;
+}
+
+JSClassExoticMethods js_livecoll_exotic = {
+  .get_own_property       = js_livecoll_get_own_property,
+  .get_own_property_names = js_livecoll_get_own_property_names,
+};
+
+void js_livecoll_finalizer(JSRuntime*, JSValue val) {
+  auto* data = static_cast<LiveCollectionData*>(JS_GetOpaque(val, js_live_collection_class_id));
+  delete data;
+}
+
+JSClassDef js_livecoll_class = { "LiveCollection", .finalizer = js_livecoll_finalizer, .exotic = &js_livecoll_exotic };
+
+const char* kIteratorBootstrapScript = R"JS(
+(function() {
+  var proto = globalThis.__LiveCollectionProto;
+  proto[Symbol.iterator] = function() {
+    var i = 0;
+    var self = this;
+    return {
+      next: function() {
+        return i < self.length ? { value: self[i++], done: false } : { value: undefined, done: true };
+      }
+    };
+  };
+  delete globalThis.__LiveCollectionProto;
+})();
+)JS";
+
+JSValue make(JSContext* ctx, void* owner, LiveKind kind, const std::string& selector) {
+  auto* data = new LiveCollectionData{ owner, kind, selector };
+  JSValue obj = JS_NewObjectClass(ctx, js_live_collection_class_id);
+  JS_SetOpaque(obj, data);
+  return obj;
+}
+
+} // namespace
+
+void LiveCollectionBindings::install(JSContext* ctx) {
+  if (js_live_collection_class_id == 0) JS_NewClassID(&js_live_collection_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_live_collection_class_id, &js_livecoll_class);
+
+  JSValue proto = JS_NewObject(ctx);
+  JS_SetClassProto(ctx, js_live_collection_class_id, JS_DupValue(ctx, proto));
+
+  JSValue global = JS_GetGlobalObject(ctx);
+  JS_SetPropertyStr(ctx, global, "__LiveCollectionProto", proto);
+  JS_FreeValue(ctx, global);
+
+  JSValue result = JS_Eval(ctx, kIteratorBootstrapScript, strlen(kIteratorBootstrapScript),
+                            "<live-collection-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(result)) JS_FreeValue(ctx, JS_GetException(ctx));
+  JS_FreeValue(ctx, result);
+}
+
+JSValue LiveCollectionBindings::makeChildren(JSContext* ctx, void* element) {
+  return make(ctx, element, LiveKind::CHILDREN, "");
+}
+
+JSValue LiveCollectionBindings::makeChildNodes(JSContext* ctx, void* node) {
+  return make(ctx, node, LiveKind::CHILD_NODES, "");
+}
+
+JSValue LiveCollectionBindings::makeBySelector(JSContext* ctx, void* owner_or_null, const std::string& selector) {
+  return make(ctx, owner_or_null, LiveKind::SELECTOR, selector);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/LiveCollectionBindings.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "quickjs.h"
+#include <string>
+
+namespace margelo::nitro::nitrojsdom {
+
+class LiveCollectionBindings {
+public:
+  static void install(JSContext* ctx);
+  static JSValue makeChildren(JSContext* ctx, void* element);
+  static JSValue makeChildNodes(JSContext* ctx, void* node);
+  static JSValue makeBySelector(JSContext* ctx, void* owner_or_null, const std::string& selector);
+};
+
+} // namespace margelo::nitro::nitrojsdom