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

package/cpp/quickjs/Storage.cpp

@@ -0,0 +1,130 @@
+#include "Storage.hpp"
+#include "quickjs.h"
+
+namespace margelo::nitro::nitrojsdom {
+
+// ── Storage ───────────────────────────────────────────────────────────────────
+
+std::optional<std::string> Storage::getItem(const std::string& key) const {
+  auto it = _data.find(key);
+  if (it == _data.end()) return std::nullopt;
+  return it->second;
+}
+
+void Storage::setItem(const std::string& key, const std::string& value) {
+  auto it = _data.find(key);
+  if (it == _data.end()) {
+    _order.push_back(key);
+  }
+  _data[key] = value;
+}
+
+void Storage::removeItem(const std::string& key) {
+  auto it = _data.find(key);
+  if (it == _data.end()) return;
+  _data.erase(it);
+  for (auto orderIt = _order.begin(); orderIt != _order.end(); ++orderIt) {
+    if (*orderIt == key) {
+      _order.erase(orderIt);
+      break;
+    }
+  }
+}
+
+void Storage::clear() {
+  _data.clear();
+  _order.clear();
+}
+
+std::optional<std::string> Storage::key(size_t index) const {
+  if (index >= _order.size()) return std::nullopt;
+  return _order[index];
+}
+
+// ── JS bindings ───────────────────────────────────────────────────────────────
+
+static JSClassID js_storage_class_id = 0;
+static JSClassDef js_storage_class = { "Storage", .finalizer = nullptr };
+
+static Storage* unwrap_storage(JSValue this_val) {
+  return static_cast<Storage*>(JS_GetOpaque(this_val, js_storage_class_id));
+}
+
+static std::string js_to_std_string(JSContext* ctx, JSValue v) {
+  JSValue str_val = JS_ToString(ctx, v);
+  std::string out;
+  const char* s = JS_ToCString(ctx, str_val);
+  if (s) { out = s; JS_FreeCString(ctx, s); }
+  JS_FreeValue(ctx, str_val);
+  return out;
+}
+
+static JSValue js_storage_getItem(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  Storage* storage = unwrap_storage(this_val);
+  if (!storage || argc < 1) return JS_NULL;
+  auto value = storage->getItem(js_to_std_string(ctx, argv[0]));
+  if (!value.has_value()) return JS_NULL;
+  return JS_NewStringLen(ctx, value->c_str(), value->size());
+}
+
+static JSValue js_storage_setItem(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  Storage* storage = unwrap_storage(this_val);
+  if (!storage || argc < 2) return JS_UNDEFINED;
+  storage->setItem(js_to_std_string(ctx, argv[0]), js_to_std_string(ctx, argv[1]));
+  return JS_UNDEFINED;
+}
+
+static JSValue js_storage_removeItem(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  Storage* storage = unwrap_storage(this_val);
+  if (!storage || argc < 1) return JS_UNDEFINED;
+  storage->removeItem(js_to_std_string(ctx, argv[0]));
+  return JS_UNDEFINED;
+}
+
+static JSValue js_storage_clear(JSContext* ctx, JSValue this_val, int, JSValue*) {
+  Storage* storage = unwrap_storage(this_val);
+  if (storage) storage->clear();
+  return JS_UNDEFINED;
+}
+
+static JSValue js_storage_key(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  Storage* storage = unwrap_storage(this_val);
+  if (!storage || argc < 1) return JS_NULL;
+  int32_t index = 0;
+  if (JS_ToInt32(ctx, &index, argv[0]) < 0 || index < 0) return JS_NULL;
+  auto k = storage->key(static_cast<size_t>(index));
+  if (!k.has_value()) return JS_NULL;
+  return JS_NewStringLen(ctx, k->c_str(), k->size());
+}
+
+static JSValue js_storage_get_length(JSContext* ctx, JSValue this_val) {
+  Storage* storage = unwrap_storage(this_val);
+  return JS_NewInt32(ctx, storage ? static_cast<int32_t>(storage->length()) : 0);
+}
+
+void installStorage(JSContext* ctx, const char* globalName, Storage* storage) {
+  if (js_storage_class_id == 0) {
+    JS_NewClassID(&js_storage_class_id);
+  }
+  JS_NewClass(JS_GetRuntime(ctx), js_storage_class_id, &js_storage_class);
+
+  JSValue obj = JS_NewObjectClass(ctx, js_storage_class_id);
+  JS_SetOpaque(obj, storage);
+
+  JS_SetPropertyStr(ctx, obj, "getItem", JS_NewCFunction(ctx, js_storage_getItem, "getItem", 1));
+  JS_SetPropertyStr(ctx, obj, "setItem", JS_NewCFunction(ctx, js_storage_setItem, "setItem", 2));
+  JS_SetPropertyStr(ctx, obj, "removeItem", JS_NewCFunction(ctx, js_storage_removeItem, "removeItem", 1));
+  JS_SetPropertyStr(ctx, obj, "clear", JS_NewCFunction(ctx, js_storage_clear, "clear", 0));
+  JS_SetPropertyStr(ctx, obj, "key", JS_NewCFunction(ctx, js_storage_key, "key", 1));
+
+  JSAtom atom = JS_NewAtom(ctx, "length");
+  JSValue getter = JS_NewCFunction2(ctx, (JSCFunction*)js_storage_get_length, "length", 0, JS_CFUNC_getter, 0);
+  JS_DefinePropertyGetSet(ctx, obj, atom, getter, JS_UNDEFINED, JS_PROP_CONFIGURABLE);
+  JS_FreeAtom(ctx, atom);
+
+  JSValue global = JS_GetGlobalObject(ctx);
+  JS_SetPropertyStr(ctx, global, globalName, obj);
+  JS_FreeValue(ctx, global);
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/Storage.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <optional>
+#include <cstddef>
+
+// Forward-declare the opaque JSContext/JSValue types to avoid including quickjs.h here
+typedef struct JSContext JSContext;
+
+namespace margelo::nitro::nitrojsdom {
+
+// ── Storage ───────────────────────────────────────────────────────────────────
+//
+// In-memory backing store for `localStorage` / `sessionStorage`. Preserves
+// insertion order (per the Web Storage spec's `key(index)` iteration order);
+// re-setting an existing key updates its value in place without moving it.
+// Purely in-memory — not persisted across JSDOM instances or app restarts.
+
+class Storage {
+public:
+  std::optional<std::string> getItem(const std::string& key) const;
+  void setItem(const std::string& key, const std::string& value);
+  void removeItem(const std::string& key);
+  void clear();
+  std::optional<std::string> key(size_t index) const;
+  size_t length() const { return _order.size(); }
+
+private:
+  std::vector<std::string> _order;
+  std::unordered_map<std::string, std::string> _data;
+};
+
+// Registers `getItem`/`setItem`/`removeItem`/`clear`/`key`/`length` on a new JS
+// object bound to `globalName` on the given context, backed by `storage`.
+// `storage` must outlive the QuickJS context (owned by RuntimeContext).
+void installStorage(JSContext* ctx, const char* globalName, Storage* storage);
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/ClassListBindings.cpp

@@ -0,0 +1,241 @@
+#include "ClassListBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include "../QuickJSRuntime.hpp"
+#include "../MutationObservers.hpp"
+#include <lexbor/dom/dom.h>
+#include <algorithm>
+#include <optional>
+#include <sstream>
+#include <vector>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassID js_classList_class_id = 0;
+JSClassDef js_classList_class = { "DOMTokenList", .finalizer = nullptr };
+
+lxb_dom_element_t* unwrap_classList(JSContext* ctx, JSValue val) {
+  return static_cast<lxb_dom_element_t*>(JS_GetOpaque(val, js_classList_class_id));
+}
+
+std::vector<std::string> split_classes(const std::string& str) {
+  std::vector<std::string> result;
+  std::istringstream iss(str);
+  std::string token;
+  while (iss >> token) result.push_back(token);
+  return result;
+}
+
+std::string join_classes(const std::vector<std::string>& v) {
+  std::string r;
+  for (size_t i = 0; i < v.size(); i++) { if (i) r += ' '; r += v[i]; }
+  return r;
+}
+
+// Validates a DOMTokenList token: throws on empty or whitespace-containing token.
+bool validate_token(JSContext* ctx, const char* token) {
+  if (!token || token[0] == '\0') {
+    JS_ThrowTypeError(ctx, "The token provided must not be empty.");
+    return false;
+  }
+  for (const char* p = token; *p; p++) {
+    unsigned char c = (unsigned char)*p;
+    if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\f') {
+      JS_ThrowTypeError(ctx, "The token provided contains HTML space characters, which are not valid in tokens.");
+      return false;
+    }
+  }
+  return true;
+}
+
+JSValue js_classList_add(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_classList(ctx, this_val);
+  if (!el) return JS_UNDEFINED;
+
+  auto* rctx = get_ctx(ctx);
+  bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+  std::optional<std::string> old_val;
+  if (has_obs && rctx->mutation_observers->hasAttributeOldValueObserver())
+    old_val = get_class_attr(el);
+
+  // Validate all tokens before mutating (spec: validate each, then add all)
+  std::vector<std::string> tokens;
+  for (int i = 0; i < argc; i++) {
+    const char* cls = JS_ToCString(ctx, argv[i]);
+    if (!cls) return JS_EXCEPTION;
+    if (!validate_token(ctx, cls)) { JS_FreeCString(ctx, cls); return JS_EXCEPTION; }
+    tokens.emplace_back(cls);
+    JS_FreeCString(ctx, cls);
+  }
+
+  auto classes = split_classes(get_class_attr(el));
+  for (auto& tok : tokens) {
+    if (std::find(classes.begin(), classes.end(), tok) == classes.end())
+      classes.push_back(tok);
+  }
+  set_class_attr(el, join_classes(classes));
+
+  if (has_obs) {
+    rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el),
+        "class", old_val);
+  }
+  return JS_UNDEFINED;
+}
+
+JSValue js_classList_remove(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_classList(ctx, this_val);
+  if (!el) return JS_UNDEFINED;
+
+  auto* rctx = get_ctx(ctx);
+  bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+  std::optional<std::string> old_val;
+  if (has_obs && rctx->mutation_observers->hasAttributeOldValueObserver())
+    old_val = get_class_attr(el);
+
+  // Validate all tokens before mutating
+  std::vector<std::string> tokens;
+  for (int i = 0; i < argc; i++) {
+    const char* cls = JS_ToCString(ctx, argv[i]);
+    if (!cls) return JS_EXCEPTION;
+    if (!validate_token(ctx, cls)) { JS_FreeCString(ctx, cls); return JS_EXCEPTION; }
+    tokens.emplace_back(cls);
+    JS_FreeCString(ctx, cls);
+  }
+
+  auto classes = split_classes(get_class_attr(el));
+  for (auto& tok : tokens)
+    classes.erase(std::remove(classes.begin(), classes.end(), tok), classes.end());
+  set_class_attr(el, join_classes(classes));
+
+  if (has_obs) {
+    rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el),
+        "class", old_val);
+  }
+  return JS_UNDEFINED;
+}
+
+JSValue js_classList_contains(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_classList(ctx, this_val);
+  if (!el || argc < 1) return JS_FALSE;
+  const char* cls = JS_ToCString(ctx, argv[0]);
+  if (!cls) return JS_EXCEPTION;
+  if (!validate_token(ctx, cls)) { JS_FreeCString(ctx, cls); return JS_EXCEPTION; }
+  auto classes = split_classes(get_class_attr(el));
+  bool found = std::find(classes.begin(), classes.end(), cls) != classes.end();
+  JS_FreeCString(ctx, cls);
+  return JS_NewBool(ctx, found);
+}
+
+JSValue js_classList_toggle(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_classList(ctx, this_val);
+  if (!el || argc < 1) return JS_FALSE;
+  const char* cls = JS_ToCString(ctx, argv[0]);
+  if (!cls) return JS_EXCEPTION;
+  if (!validate_token(ctx, cls)) { JS_FreeCString(ctx, cls); return JS_EXCEPTION; }
+
+  auto* rctx = get_ctx(ctx);
+  bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+  std::optional<std::string> old_val;
+  if (has_obs && rctx->mutation_observers->hasAttributeOldValueObserver())
+    old_val = get_class_attr(el);
+
+  auto classes = split_classes(get_class_attr(el));
+  auto it = std::find(classes.begin(), classes.end(), cls);
+
+  bool added;
+  bool force_present = argc >= 2 && !JS_IsUndefined(argv[1]);
+  if (force_present) {
+    bool force = JS_ToBool(ctx, argv[1]) > 0;
+    if (force) {
+      if (it == classes.end()) classes.push_back(cls);
+      added = true;
+    } else {
+      if (it != classes.end()) classes.erase(it);
+      added = false;
+    }
+  } else {
+    if (it != classes.end()) { classes.erase(it); added = false; }
+    else { classes.push_back(cls); added = true; }
+  }
+
+  JS_FreeCString(ctx, cls);
+  set_class_attr(el, join_classes(classes));
+
+  if (has_obs) {
+    rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el),
+        "class", old_val);
+  }
+  return JS_NewBool(ctx, added);
+}
+
+JSValue js_classList_replace(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+  auto* el = unwrap_classList(ctx, this_val);
+  if (!el || argc < 2) return JS_FALSE;
+  const char* oldCls = JS_ToCString(ctx, argv[0]);
+  if (!oldCls) return JS_EXCEPTION;
+  if (!validate_token(ctx, oldCls)) { JS_FreeCString(ctx, oldCls); return JS_EXCEPTION; }
+  const char* newCls = JS_ToCString(ctx, argv[1]);
+  if (!newCls) { JS_FreeCString(ctx, oldCls); return JS_EXCEPTION; }
+  if (!validate_token(ctx, newCls)) { JS_FreeCString(ctx, oldCls); JS_FreeCString(ctx, newCls); return JS_EXCEPTION; }
+
+  auto* rctx = get_ctx(ctx);
+  bool has_obs = rctx && rctx->mutation_observers && !rctx->mutation_observers->empty();
+  std::optional<std::string> old_val;
+  if (has_obs && rctx->mutation_observers->hasAttributeOldValueObserver())
+    old_val = get_class_attr(el);
+
+  auto classes = split_classes(get_class_attr(el));
+  auto it = std::find(classes.begin(), classes.end(), oldCls);
+  bool replaced = false;
+  if (it != classes.end()) {
+    *it = newCls;
+    // Remove any other occurrences of newCls to keep the set unique
+    classes.erase(std::remove(it + 1, classes.end(), newCls), classes.end());
+    replaced = true;
+    set_class_attr(el, join_classes(classes));
+    if (has_obs) {
+      rctx->mutation_observers->notifyAttribute(ctx, lxb_dom_interface_node(el),
+          "class", old_val);
+    }
+  }
+
+  JS_FreeCString(ctx, oldCls);
+  JS_FreeCString(ctx, newCls);
+  return JS_NewBool(ctx, replaced);
+}
+
+} // namespace
+
+std::string get_class_attr(lxb_dom_element_t* el) {
+  size_t len = 0;
+  const lxb_char_t* val = lxb_dom_element_get_attribute(el,
+      reinterpret_cast<const lxb_char_t*>("class"), 5, &len);
+  return val ? std::string(reinterpret_cast<const char*>(val), len) : "";
+}
+
+void set_class_attr(lxb_dom_element_t* el, const std::string& classes) {
+  // Always write the attribute (even when empty) so classList.value serializes
+  // back to "" rather than the attribute disappearing after the last token is removed.
+  lxb_dom_element_set_attribute(el,
+      reinterpret_cast<const lxb_char_t*>("class"), 5,
+      reinterpret_cast<const lxb_char_t*>(classes.data()), classes.size());
+}
+
+void ClassListBindings::install(JSContext* ctx) {
+  if (js_classList_class_id == 0) JS_NewClassID(&js_classList_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_classList_class_id, &js_classList_class);
+}
+
+JSValue ClassListBindings::make(JSContext* ctx, lxb_dom_element_t* el) {
+  JSValue obj = JS_NewObjectClass(ctx, js_classList_class_id);
+  JS_SetOpaque(obj, el);
+  JS_SetPropertyStr(ctx, obj, "add",      JS_NewCFunction(ctx, js_classList_add,      "add",      1));
+  JS_SetPropertyStr(ctx, obj, "remove",   JS_NewCFunction(ctx, js_classList_remove,   "remove",   1));
+  JS_SetPropertyStr(ctx, obj, "contains", JS_NewCFunction(ctx, js_classList_contains, "contains", 1));
+  JS_SetPropertyStr(ctx, obj, "toggle",   JS_NewCFunction(ctx, js_classList_toggle,   "toggle",   1));
+  JS_SetPropertyStr(ctx, obj, "replace",  JS_NewCFunction(ctx, js_classList_replace,  "replace",  2));
+  return obj;
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/ClassListBindings.hpp

@@ -0,0 +1,29 @@
+#pragma once
+
+// element.classList (DOMTokenList) — registered as its own QuickJS class since
+// it's a distinct object handed out by the "classList" accessor, not a set of
+// methods on Element itself.
+
+#include "quickjs.h"
+#include <string>
+
+struct lxb_dom_element;
+typedef struct lxb_dom_element lxb_dom_element_t;
+
+namespace margelo::nitro::nitrojsdom {
+
+class ClassListBindings {
+public:
+  // Registers the DOMTokenList class. Must run before make() is called.
+  static void install(JSContext* ctx);
+
+  // Wraps `el` as a classList instance (add/remove/contains/toggle/replace).
+  static JSValue make(JSContext* ctx, lxb_dom_element_t* el);
+};
+
+// Shared with ElementBindings (className getter/setter) and StyleBindings-adjacent
+// callers that need the raw `class` attribute value.
+std::string get_class_attr(lxb_dom_element_t* el);
+void set_class_attr(lxb_dom_element_t* el, const std::string& classes);
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DatasetBindings.cpp

@@ -0,0 +1,120 @@
+#include "DatasetBindings.hpp"
+#include "../DOMBindingsInternal.hpp"
+#include <lexbor/dom/dom.h>
+#include <vector>
+
+namespace margelo::nitro::nitrojsdom {
+
+namespace {
+
+JSClassID js_dataset_class_id = 0;
+
+lxb_dom_element_t* unwrap_dataset(JSContext* ctx, JSValue val) {
+  return static_cast<lxb_dom_element_t*>(JS_GetOpaque(val, js_dataset_class_id));
+}
+
+std::string dataset_prop_to_attr(JSContext* ctx, JSAtom prop) {
+  JSValue key_val = JS_AtomToString(ctx, prop);
+  const char* key = JS_ToCString(ctx, key_val);
+  JS_FreeValue(ctx, key_val);
+  std::string attr_name = key ? ("data-" + camel_to_attr_suffix(key)) : "";
+  if (key) JS_FreeCString(ctx, key);
+  return attr_name;
+}
+
+int js_dataset_get_own_property(JSContext* ctx, JSPropertyDescriptor* desc, JSValue obj, JSAtom prop) {
+  auto* el = unwrap_dataset(ctx, obj);
+  if (!el) return 0;
+  std::string attr_name = dataset_prop_to_attr(ctx, prop);
+  if (attr_name.empty()) return 0;
+
+  size_t len = 0;
+  const lxb_char_t* val = lxb_dom_element_get_attribute(el,
+      reinterpret_cast<const lxb_char_t*>(attr_name.data()), attr_name.size(), &len);
+  if (!val) return 0;
+
+  if (desc) {
+    desc->flags = JS_PROP_ENUMERABLE | JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE;
+    desc->value = JS_NewStringLen(ctx, reinterpret_cast<const char*>(val), len);
+    desc->getter = JS_UNDEFINED;
+    desc->setter = JS_UNDEFINED;
+  }
+  return 1;
+}
+
+int js_dataset_define_own_property(JSContext* ctx, JSValue this_obj, JSAtom prop, JSValue val,
+                                    JSValue, JSValue, int) {
+  auto* el = unwrap_dataset(ctx, this_obj);
+  if (!el) return 0;
+  std::string attr_name = dataset_prop_to_attr(ctx, prop);
+  if (attr_name.empty()) return 0;
+
+  const char* str = JS_ToCString(ctx, val);
+  if (str) {
+    lxb_dom_element_set_attribute(el,
+        reinterpret_cast<const lxb_char_t*>(attr_name.data()), attr_name.size(),
+        reinterpret_cast<const lxb_char_t*>(str), strlen(str));
+    JS_FreeCString(ctx, str);
+  }
+  return 1;
+}
+
+int js_dataset_delete_property(JSContext* ctx, JSValue obj, JSAtom prop) {
+  auto* el = unwrap_dataset(ctx, obj);
+  if (!el) return 1;
+  std::string attr_name = dataset_prop_to_attr(ctx, prop);
+  if (!attr_name.empty()) {
+    lxb_dom_element_remove_attribute(el,
+        reinterpret_cast<const lxb_char_t*>(attr_name.data()), attr_name.size());
+  }
+  return 1;
+}
+
+int js_dataset_get_own_property_names(JSContext* ctx, JSPropertyEnum** ptab, uint32_t* plen, JSValue obj) {
+  *ptab = nullptr;
+  *plen = 0;
+  auto* el = unwrap_dataset(ctx, obj);
+  if (!el) return 0;
+
+  std::vector<std::string> keys;
+  for (lxb_dom_attr_t* attr = lxb_dom_element_first_attribute(el); attr; attr = lxb_dom_element_next_attribute(attr)) {
+    size_t len = 0;
+    const lxb_char_t* name = lxb_dom_attr_qualified_name(attr, &len);
+    std::string n(reinterpret_cast<const char*>(name), len);
+    if (n.rfind("data-", 0) == 0) keys.push_back(attr_suffix_to_camel(n.substr(5)));
+  }
+
+  auto* tab = static_cast<JSPropertyEnum*>(js_malloc(ctx, sizeof(JSPropertyEnum) * (keys.empty() ? 1 : keys.size())));
+  if (!tab) return -1;
+  for (size_t i = 0; i < keys.size(); i++) {
+    tab[i].is_enumerable = 1;
+    tab[i].atom = JS_NewAtom(ctx, keys[i].c_str());
+  }
+  *ptab = tab;
+  *plen = (uint32_t)keys.size();
+  return 0;
+}
+
+JSClassExoticMethods js_dataset_exotic = {
+  .get_own_property       = js_dataset_get_own_property,
+  .get_own_property_names = js_dataset_get_own_property_names,
+  .delete_property        = js_dataset_delete_property,
+  .define_own_property    = js_dataset_define_own_property,
+};
+
+JSClassDef js_dataset_class = { "DOMStringMap", .finalizer = nullptr, .exotic = &js_dataset_exotic };
+
+} // namespace
+
+void DatasetBindings::install(JSContext* ctx) {
+  JS_NewClassID(&js_dataset_class_id);
+  JS_NewClass(JS_GetRuntime(ctx), js_dataset_class_id, &js_dataset_class);
+}
+
+JSValue DatasetBindings::make(JSContext* ctx, lxb_dom_element_t* el) {
+  JSValue obj = JS_NewObjectClass(ctx, js_dataset_class_id);
+  JS_SetOpaque(obj, el);
+  return obj;
+}
+
+} // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/DatasetBindings.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+// element.dataset (DOMStringMap), mirroring data-* attributes. Implemented as a
+// QuickJS exotic-property class so `el.dataset.foo = 'x'` writes straight
+// through to the `data-foo` attribute, rather than a one-shot snapshot object.
+
+#include "quickjs.h"
+
+struct lxb_dom_element;
+typedef struct lxb_dom_element lxb_dom_element_t;
+
+namespace margelo::nitro::nitrojsdom {
+
+class DatasetBindings {
+public:
+  static void install(JSContext* ctx);
+  static JSValue make(JSContext* ctx, lxb_dom_element_t* el);
+};
+
+} // namespace margelo::nitro::nitrojsdom