xbintsc 0.5.36 → 0.5.37

package/runtime/ext_gui/dom_api_canvas_image.cpp

@@ -0,0 +1,239 @@
+/*
+ * xbintsc GUI engine — the Canvas2D image APIs (`putImageData`,
+ * `createImageData`, `createPattern`, `toDataURL`, `toBlob`).
+ *
+ * `ImageData` is the same `{ width, height, data }` shape `getImageData` already
+ * returns (a byte array), patterns are canvas-owned handles like gradients, and
+ * `toDataURL`/`toBlob` export the bitmap as a PNG data URL / callback result.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cmath>
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+#include "image.h"
+
+namespace domapi {
+
+namespace {
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+/** Read an `ImageData`-shaped value into width/height/RGBA bytes. */
+bool image_data_arg(xt_value value, int *width, int *height, std::vector<unsigned char> *bytes) {
+  if (!XT_IS_OBJECT(value)) return false;
+  xt_value w = xt_object_get_cstr(value, "width");
+  xt_value h = xt_object_get_cstr(value, "height");
+  if (!XT_IS_NUMBER(w) || !XT_IS_NUMBER(h)) return false;
+  *width = (int)xt_to_number(w);
+  *height = (int)xt_to_number(h);
+  if (*width <= 0 || *height <= 0) return false;
+  xt_value data = xt_object_get_cstr(value, "data");
+  if (!XT_IS_ARRAY(data)) return false;
+  int32_t count = (int32_t)xt_to_number(xt_array_length(data));
+  if (count < *width * *height * 4) return false;
+  bytes->resize((size_t)count);
+  for (int32_t i = 0; i < count; i++) {
+    (*bytes)[(size_t)i] = (unsigned char)xt_to_number(xt_array_get(data, xt_number((double)i)));
+  }
+  return true;
+}
+
+xt_value make_image_data(int width, int height, const std::vector<unsigned char> &bytes) {
+  xt_value result = xt_object_new();
+  xt_value data = xt_array_new(0, nullptr);
+  for (unsigned char byte : bytes) xt_array_push(data, xt_number((double)byte));
+  xt_object_set(result, xt_string_from_cstr("width"), xt_number((double)width));
+  xt_object_set(result, xt_string_from_cstr("height"), xt_number((double)height));
+  xt_object_set(result, xt_string_from_cstr("data"), data);
+  return result;
+}
+
+/** Decode a `createPattern` source: an `<img>` or another `<canvas>`. */
+bool source_image(XtGuiWindow *win, xt_value value, xtgui::Image *out) {
+  xtgui::Node *node = resolve_node(value, &win);
+  if (node == nullptr || !node->isElement()) return false;
+  if (node->isTag("img")) {
+    const std::string *src = node->attr("src");
+    if (src == nullptr) return false;
+    const xtgui::Image *image = xtgui::xt_image_load(*src);
+    if (image == nullptr || image->width <= 0 || image->height <= 0) return false;
+    *out = *image;
+    return true;
+  }
+  xtgui::Canvas2D *canvas = xt_gui_canvas_find(win, node);
+  if (canvas == nullptr) return false;
+  *out = canvas->image();
+  return out->width > 0 && out->height > 0;
+}
+
+const char kBase64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+std::string base64_encode(const std::vector<unsigned char> &bytes) {
+  std::string out;
+  out.reserve((bytes.size() + 2) / 3 * 4);
+  size_t i = 0;
+  while (i + 2 < bytes.size()) {
+    uint32_t triple = ((uint32_t)bytes[i] << 16) | ((uint32_t)bytes[i + 1] << 8) | bytes[i + 2];
+    out.push_back(kBase64[(triple >> 18) & 0x3F]);
+    out.push_back(kBase64[(triple >> 12) & 0x3F]);
+    out.push_back(kBase64[(triple >> 6) & 0x3F]);
+    out.push_back(kBase64[triple & 0x3F]);
+    i += 3;
+  }
+  if (i < bytes.size()) {
+    uint32_t triple = (uint32_t)bytes[i] << 16;
+    bool two = i + 1 < bytes.size();
+    if (two) triple |= (uint32_t)bytes[i + 1] << 8;
+    out.push_back(kBase64[(triple >> 18) & 0x3F]);
+    out.push_back(kBase64[(triple >> 12) & 0x3F]);
+    out.push_back(two ? kBase64[(triple >> 6) & 0x3F] : '=');
+    out.push_back('=');
+  }
+  return out;
+}
+
+xt_value blob_callback(xt_value self, xt_value env, int32_t argc, xt_value *argv) {
+  (void)self;
+  (void)argc;
+  (void)argv;
+  xt_value fn = xt_closure_env(env, 0);
+  xt_value blob = xt_closure_env(env, 1);
+  xt_value args[1] = {blob};
+  return xt_call_with_this(fn, XT_UNDEFINED, 1, args);
+}
+
+}  // namespace
+
+/** The canvas behind a context handle or a `<canvas>` element handle. */
+xtgui::Canvas2D *canvas_or_element(xt_value self) {
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) return canvas;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(self, &win);
+  if (node == nullptr || win == nullptr) return nullptr;
+  return xt_gui_canvas_find(win, node);
+}
+
+xt_value canvas_pattern_handle(xt_value context, const xtgui::Canvas2D *canvas, uint64_t id) {
+  const std::string key = "__xt_gui_pattern_" + std::to_string(id);
+  xt_value cached = xt_object_get_cstr(context, key.c_str());
+  if (XT_IS_OBJECT(cached)) return cached;
+  xt_value handle = xt_object_new_with_proto(xt_object_prototype());
+  if (canvas != nullptr) {
+    xt_object_set(handle, xt_string_from_cstr("__xt_gui_canvas"), xt_number((double)canvas->id()));
+  }
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_pattern"), xt_number((double)id));
+  xt_object_set(context, xt_string_from_cstr(key.c_str()), handle);
+  return handle;
+}
+
+uint64_t canvas_pattern_id(xt_value handle, const xtgui::Canvas2D *canvas) {
+  if (canvas == nullptr || !XT_IS_OBJECT(handle)) return 0;
+  xt_value canvasId = xt_object_get_cstr(handle, "__xt_gui_canvas");
+  xt_value patternId = xt_object_get_cstr(handle, "__xt_gui_pattern");
+  if (!XT_IS_NUMBER(canvasId) || !XT_IS_NUMBER(patternId)) return 0;
+  if ((uint64_t)xt_to_number(canvasId) != canvas->id()) return 0;
+  uint64_t id = (uint64_t)xt_to_number(patternId);
+  return canvas->find_pattern(id) == nullptr ? 0 : id;
+}
+
+METHOD(canvas_put_image_data) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr || argc < 3) return XT_UNDEFINED;
+  int width = 0;
+  int height = 0;
+  std::vector<unsigned char> bytes;
+  if (!image_data_arg(xt_arg(argc, argv, 0), &width, &height, &bytes)) return XT_UNDEFINED;
+  int dx = (int)canvas_number_arg(argc, argv, 1, 0.0);
+  int dy = (int)canvas_number_arg(argc, argv, 2, 0.0);
+  int dirty_x = (int)canvas_number_arg(argc, argv, 3, 0.0);
+  int dirty_y = (int)canvas_number_arg(argc, argv, 4, 0.0);
+  int dirty_width = (int)canvas_number_arg(argc, argv, 5, 0.0);
+  int dirty_height = (int)canvas_number_arg(argc, argv, 6, 0.0);
+  canvas->set_image_data(bytes, width, height, dx, dy, dirty_x, dirty_y, dirty_width,
+                         dirty_height);
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_create_image_data) {
+  (void)env;
+  int width = 0;
+  int height = 0;
+  if (argc >= 2) {
+    width = (int)canvas_number_arg(argc, argv, 0, 0.0);
+    height = (int)canvas_number_arg(argc, argv, 1, 0.0);
+  } else if (argc >= 1) {
+    int source_width = 0;
+    int source_height = 0;
+    std::vector<unsigned char> bytes;
+    if (image_data_arg(xt_arg(argc, argv, 0), &source_width, &source_height, &bytes)) {
+      width = source_width;
+      height = source_height;
+    }
+  }
+  if (width <= 0 || height <= 0) return XT_UNDEFINED;
+  return make_image_data(width, height, std::vector<unsigned char>((size_t)width * height * 4, 0));
+}
+
+METHOD(canvas_create_pattern) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr || argc < 1) return XT_NULL;
+  XtGuiWindow *win = nullptr;
+  resolve_node(xt_object_get_cstr(self, "__xt_gui_node"), &win);
+  xtgui::Image source;
+  if (win == nullptr || !source_image(win, xt_arg(argc, argv, 0), &source)) return XT_NULL;
+  std::string repetition = argc >= 2 ? canvas_string_arg(argc, argv, 1) : "repeat";
+  xtgui::CanvasPattern::Repeat repeat = xtgui::CanvasPattern::Repeat::Both;
+  if (repetition == "repeat-x") repeat = xtgui::CanvasPattern::Repeat::X;
+  else if (repetition == "repeat-y") repeat = xtgui::CanvasPattern::Repeat::Y;
+  else if (repetition == "no-repeat") repeat = xtgui::CanvasPattern::Repeat::None;
+  xtgui::CanvasPattern *pattern = canvas->create_pattern(source, repeat);
+  return canvas_pattern_handle(self, canvas, pattern->id());
+}
+
+/** `toDataURL(type?)`: a PNG data URL (the engine has one encoder; a browser
+ * also falls back to PNG for an unsupported type). */
+METHOD(canvas_to_data_url) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_or_element(self);
+  if (canvas == nullptr) return xt_string_from_cstr("data:,");
+  std::vector<unsigned char> png;
+  if (!canvas->encode_png(&png)) return xt_string_from_cstr("data:,");
+  std::string url = "data:image/png;base64," + base64_encode(png);
+  return xt_string_from_cstr(url.c_str());
+}
+
+/** `toBlob(callback, type?)`: build a Blob-shaped result and deliver it from a
+ * microtask, as the browser does. The bytes are on `__xt_gui_blob_data`; there
+ * is no `URL.createObjectURL` in this runtime. */
+METHOD(canvas_to_blob) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_or_element(self);
+  xt_value callback = argc >= 1 ? xt_arg(argc, argv, 0) : XT_UNDEFINED;
+  if (canvas == nullptr || !XT_IS_FUNCTION(callback)) return XT_UNDEFINED;
+  std::vector<unsigned char> png;
+  if (!canvas->encode_png(&png)) return XT_UNDEFINED;
+  xt_value data = xt_array_new(0, nullptr);
+  for (unsigned char byte : png) xt_array_push(data, xt_number((double)byte));
+  xt_value blob = xt_object_new();
+  xt_object_set(blob, xt_string_from_cstr("type"), xt_string_from_cstr("image/png"));
+  xt_object_set(blob, xt_string_from_cstr("size"), xt_number((double)png.size()));
+  xt_object_set(blob, xt_string_from_cstr("__xt_gui_blob_data"), data);
+  xt_value captured[2] = {callback, blob};
+  xt_value task = xt_closure_new((void *)blob_callback, 2, captured);
+  xt_value args[1] = {task};
+  xt_queue_microtask(1, args);
+  return XT_UNDEFINED;
+}
+
+#undef METHOD
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_canvas_paths.cpp

@@ -0,0 +1,179 @@
+/*
+ * xbintsc GUI engine — the Canvas2D path and fill/stroke bindings.
+ *
+ * `beginPath`/`moveTo`/… build the context's current path; `fill`/`stroke`
+ * paint it (or a `Path2D` supplied as the argument), with the optional
+ * `"evenodd"` fill rule honoured.
+ */
+
+#include "dom_api_internal.h"
+
+#include <string>
+#include <vector>
+
+#include "canvas.h"
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+namespace domapi {
+/* -- paths ---------------------------------------------------------------- */
+
+namespace {
+
+/** One argument of the fill/stroke family: a `Path2D` handle or a fill rule. */
+bool canvas_fill_rule(xt_value value, bool *even_odd) {
+  if (!XT_IS_STRING(value)) return false;
+  std::string rule = to_string_value(value);
+  if (rule == "evenodd") {
+    *even_odd = true;
+    return true;
+  }
+  if (rule == "nonzero") {
+    *even_odd = false;
+    return true;
+  }
+  return false;
+}
+
+/** Collect the `Path2D` arguments of `fill`/`stroke` (the DOM accepts one path
+ * plus an optional fill rule, in either order). */
+std::vector<std::vector<xtgui::CanvasSubpath>> canvas_path_args(int32_t argc, xt_value *argv,
+                                                               bool *even_odd, bool *has_path) {
+  std::vector<std::vector<xtgui::CanvasSubpath>> paths;
+  *even_odd = false;
+  *has_path = false;
+  for (int32_t i = 0; i < argc; i++) {
+    xt_value value = xt_arg(argc, argv, i);
+    bool rule = false;
+    if (canvas_fill_rule(value, &rule)) {
+      *even_odd = rule;
+      continue;
+    }
+    if (path2d_is(value)) {
+      paths.push_back(path2d_subpaths(value));
+      *has_path = true;
+    }
+  }
+  return paths;
+}
+
+}  // namespace
+
+METHOD(canvas_begin_path) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->begin_path();
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_close_path) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) canvas->close_path();
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_move_to) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr)
+    canvas->move_to((float)canvas_number_arg(argc, argv, 0, 0.0), (float)canvas_number_arg(argc, argv, 1, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_line_to) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr)
+    canvas->line_to((float)canvas_number_arg(argc, argv, 0, 0.0), (float)canvas_number_arg(argc, argv, 1, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_rect) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr)
+    canvas->rect((float)canvas_number_arg(argc, argv, 0, 0.0), (float)canvas_number_arg(argc, argv, 1, 0.0),
+                 (float)canvas_number_arg(argc, argv, 2, 0.0), (float)canvas_number_arg(argc, argv, 3, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_arc) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr) {
+    canvas->arc((float)canvas_number_arg(argc, argv, 0, 0.0), (float)canvas_number_arg(argc, argv, 1, 0.0),
+                (float)canvas_number_arg(argc, argv, 2, 0.0), (float)canvas_number_arg(argc, argv, 3, 0.0),
+                (float)canvas_number_arg(argc, argv, 4, 0.0), value_truthy(xt_arg(argc, argv, 5)));
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_quadratic_curve_to) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr)
+    canvas->quadratic_curve_to((float)canvas_number_arg(argc, argv, 0, 0.0),
+                               (float)canvas_number_arg(argc, argv, 1, 0.0),
+                               (float)canvas_number_arg(argc, argv, 2, 0.0),
+                               (float)canvas_number_arg(argc, argv, 3, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_bezier_curve_to) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas != nullptr)
+    canvas->bezier_curve_to((float)canvas_number_arg(argc, argv, 0, 0.0),
+                            (float)canvas_number_arg(argc, argv, 1, 0.0),
+                            (float)canvas_number_arg(argc, argv, 2, 0.0),
+                            (float)canvas_number_arg(argc, argv, 3, 0.0),
+                            (float)canvas_number_arg(argc, argv, 4, 0.0),
+                            (float)canvas_number_arg(argc, argv, 5, 0.0));
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_fill) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr) return XT_UNDEFINED;
+  bool even_odd = false;
+  bool has_path = false;
+  std::vector<std::vector<xtgui::CanvasSubpath>> paths =
+      canvas_path_args(argc, argv, &even_odd, &has_path);
+  if (has_path) {
+    for (const std::vector<xtgui::CanvasSubpath> &path : paths) {
+      canvas->fill_paths(path, even_odd);
+    }
+  } else {
+    canvas->fill(even_odd);
+  }
+  return XT_UNDEFINED;
+}
+
+METHOD(canvas_stroke) {
+  (void)env;
+  xtgui::Canvas2D *canvas = canvas_from_context(self);
+  if (canvas == nullptr) return XT_UNDEFINED;
+  bool even_odd = false;
+  bool has_path = false;
+  std::vector<std::vector<xtgui::CanvasSubpath>> paths =
+      canvas_path_args(argc, argv, &even_odd, &has_path);
+  if (has_path) {
+    for (const std::vector<xtgui::CanvasSubpath> &path : paths) {
+      canvas->stroke_paths(path);
+    }
+  } else {
+    canvas->stroke();
+  }
+  return XT_UNDEFINED;
+}
+
+
+#undef METHOD
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_computed_style.cpp

@@ -0,0 +1,124 @@
+/*
+ * xbintsc GUI engine — `getComputedStyle(element, pseudoElt)`.
+ *
+ * The handle reads through the *cascade* (`XtDocument::styleOf`), not the
+ * element's inline `style` object, and exposes the result both as named
+ * properties (`cs.width`, via the runtime's dynamic-property hooks) and through
+ * `getPropertyValue`/`getPropertyPriority`. Each read flushes a pending restyle
+ * first, so the handle stays correct after later DOM mutations, and
+ * `::before`/`::after` resolve the current generated-content node instead of a
+ * stale pointer.
+ */
+
+#include "dom_api_internal.h"
+
+#include "css.h"
+#include "style.h"
+
+namespace domapi {
+
+namespace {
+
+/** Which pseudo-element the handle addresses. `kPseudoUnknown` is a pseudo the
+ * engine never generates (`::marker`, `::selection`, …): it keeps answering
+ * empty values instead of falling back to the parent element's style. */
+enum ComputedPseudo { kPseudoNone = 0, kPseudoBefore = 1, kPseudoAfter = 2, kPseudoUnknown = 3 };
+
+int pseudo_from_argument(xt_value value) {
+  if (!XT_IS_STRING(value)) return kPseudoNone;
+  std::string text = xtgui::xt_css_lower(xtgui::xt_css_trim(to_string_value(value)));
+  if (text.empty()) return kPseudoNone;
+  if (text == "::before" || text == ":before") return kPseudoBefore;
+  if (text == "::after" || text == ":after") return kPseudoAfter;
+  return kPseudoUnknown;
+}
+
+const xtgui::XtStyle *computed_style_of(xt_value self) {
+  xt_value element = xt_object_get_cstr(self, "__xt_gui_element");
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = resolve_node(element, &win);
+  if (node == nullptr || win == nullptr || win->document == nullptr) return nullptr;
+  xt_gui_flush_dom(win);
+  xt_value sideValue = xt_object_get_cstr(self, "__xt_gui_pseudo");
+  int side = XT_IS_NUMBER(sideValue) ? (int)xt_to_number(sideValue) : kPseudoNone;
+  if (side == kPseudoUnknown) return nullptr;
+  if (side == kPseudoBefore) node = node->pseudo_before;
+  else if (side == kPseudoAfter) node = node->pseudo_after;
+  if (node == nullptr) return nullptr;
+  return win->document->styleOf(node);
+}
+
+std::string computed_value(const xtgui::XtStyle *style, const std::string &rawName) {
+  if (style == nullptr) return std::string();
+  if (rawName.compare(0, 6, "__xt_") == 0) return std::string();
+  /* `cs.backgroundColor` and `cs.getPropertyValue("background-color")` name the
+   * same longhand; map the camel-cased spelling to the CSS one. */
+  std::string mapped;
+  for (char c : rawName) {
+    if (c >= 'A' && c <= 'Z') {
+      mapped.push_back('-');
+      mapped.push_back((char)std::tolower((unsigned char)c));
+    } else {
+      mapped.push_back(c);
+    }
+  }
+  std::string property = xtgui::xt_css_lower(xtgui::xt_css_trim(mapped));
+  if (property.empty()) return std::string();
+  if (property.size() > 2 && property[0] == '-' && property[1] == '-') {
+    auto found = style->variables.find(property);
+    return found == style->variables.end() ? std::string() : found->second;
+  }
+  return xtgui::xt_style_property_to_string(*style, property);
+}
+
+xt_value computed_view_get(xt_value self, xt_value key, void *data) {
+  (void)data;
+  if (!XT_IS_STRING(key)) return XT_UNDEFINED;
+  return xt_string_from_cstr(computed_value(computed_style_of(self),
+                                            to_string_value(key)).c_str());
+}
+
+/** Computed style is read-only; assigning a named property is a no-op. */
+int computed_view_set(xt_value self, xt_value key, xt_value value, void *data) {
+  (void)self;
+  (void)key;
+  (void)value;
+  (void)data;
+  return 1;
+}
+
+const xt_object_hooks kComputedStyleHooks = {computed_view_get, computed_view_set, nullptr,
+                                             nullptr, nullptr};
+
+}  // namespace
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(computed_style_get_property_value) {
+  (void)env;
+  if (argc < 1) return xt_string_from_cstr("");
+  return xt_string_from_cstr(
+      computed_value(computed_style_of(self), to_string_value(xt_arg(argc, argv, 0))).c_str());
+}
+
+/** Computed styles never carry a declaration priority (spec: always ""). */
+METHOD(computed_style_get_property_priority) {
+  (void)self;
+  (void)env;
+  (void)argc;
+  (void)argv;
+  return xt_string_from_cstr("");
+}
+
+#undef METHOD
+
+xt_value computed_style_handle(xt_value element, xt_value pseudo) {
+  xt_value handle = xt_object_new_with_proto(computed_style_proto());
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_element"), element);
+  xt_object_set(handle, xt_string_from_cstr("__xt_gui_pseudo"),
+                xt_number((double)pseudo_from_argument(pseudo)));
+  xt_object_set_hooks(handle, &kComputedStyleHooks, nullptr);
+  return handle;
+}
+
+}  // namespace domapi

package/runtime/ext_gui/dom_api_dataset.cpp

@@ -0,0 +1,154 @@
+/*
+ * xbintsc GUI engine — `element.dataset`.
+ *
+ * A `DOMStringMap` is a *view* over the element's `data-*` attributes:
+ * `dataset.fooBar` reads `data-foo-bar`, assigning it writes the attribute and
+ * `delete dataset.fooBar` removes it. The runtime's dynamic-property hooks make
+ * that work for arbitrary keys without enumerating them.
+ */
+
+#include "dom_api_internal.h"
+
+#include <cctype>
+#include <string>
+
+namespace domapi {
+
+namespace {
+
+/** Symbol-keyed hidden slot holding the element handle. A string key would show
+ * up in `Object.keys(dataset)`, and `for (const k in dataset)` must only see the
+ * data attributes. */
+xt_value dataset_node_key() {
+  static xt_value key = XT_UNDEFINED;
+  if (key == XT_UNDEFINED) {
+    xt_value description = xt_string_from_cstr("xbintsc.datasetNode");
+    key = xt_symbol(1, &description);
+    xt_gc_add_root(&key);
+  }
+  return key;
+}
+
+/** Resolve the element this DOMStringMap is a view of. Resolving the dataset
+ * object itself would ask it for `__xt_gui_win`, a dynamic-key miss that would
+ * re-enter the view. */
+xtgui::Node *dataset_element(xt_value self, XtGuiWindow **win) {
+  return resolve_node(xt_object_get(self, dataset_node_key()), win);
+}
+
+bool dataset_key(xt_value key, std::string *out) {
+  if (!XT_IS_STRING(key)) return false;
+  *out = to_string_value(key);
+  /* Internal bookkeeping keys are never data attributes (and looking one up
+   * must not re-enter the view). */
+  if (out->compare(0, 6, "__xt_") == 0) return false;
+  return !out->empty();
+}
+
+/** `fooBar` -> `foo-bar` (the attribute half of the DOMStringMap mapping). */
+std::string to_attribute_name(const std::string &key) {
+  std::string out;
+  for (char c : key) {
+    if (c >= 'A' && c <= 'Z') {
+      out.push_back('-');
+      out.push_back((char)std::tolower((unsigned char)c));
+    } else {
+      out.push_back(c);
+    }
+  }
+  return out;
+}
+
+/** `foo-bar` -> `fooBar`. */
+std::string to_property_name(const std::string &name) {
+  std::string out;
+  bool upper = false;
+  for (char c : name) {
+    if (c == '-') {
+      upper = true;
+      continue;
+    }
+    out.push_back(upper ? (char)std::toupper((unsigned char)c) : c);
+    upper = false;
+  }
+  return out;
+}
+
+std::string attribute_of(const std::string &key) { return "data-" + to_attribute_name(key); }
+
+const std::string *dataset_attribute(const xtgui::Node *node, const std::string &key) {
+  return node != nullptr && node->isElement() ? node->attr(attribute_of(key)) : nullptr;
+}
+
+xt_value dataset_view_get(xt_value self, xt_value key, void *data) {
+  (void)data;
+  std::string name;
+  if (!dataset_key(key, &name)) return XT_UNDEFINED;
+  const std::string *value = dataset_attribute(dataset_element(self, nullptr), name);
+  return value == nullptr ? XT_UNDEFINED : xt_string_from_cstr(value->c_str());
+}
+
+int dataset_view_set(xt_value self, xt_value key, xt_value value, void *data) {
+  (void)data;
+  std::string name;
+  if (!dataset_key(key, &name)) return 0;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = dataset_element(self, &win);
+  if (node == nullptr || !node->isElement()) return 1;
+  set_attribute(win, node, attribute_of(name), to_string_value(value));
+  return 1;
+}
+
+int dataset_view_has(xt_value self, xt_value key, void *data) {
+  (void)data;
+  std::string name;
+  if (!dataset_key(key, &name)) return 0;
+  return dataset_attribute(dataset_element(self, nullptr), name) != nullptr ? 1 : 0;
+}
+
+int dataset_view_remove(xt_value self, xt_value key, void *data) {
+  (void)data;
+  std::string name;
+  if (!dataset_key(key, &name)) return 0;
+  XtGuiWindow *win = nullptr;
+  xtgui::Node *node = dataset_element(self, &win);
+  if (node == nullptr || !node->isElement()) return 1;
+  remove_attribute_raw(node, attribute_of(name));
+  mark_dirty(win);
+  return 1;
+}
+
+xt_value dataset_view_keys(xt_value self, void *data) {
+  (void)data;
+  xtgui::Node *node = dataset_element(self, nullptr);
+  xt_value result = xt_array_new(0, nullptr);
+  if (node == nullptr || !node->isElement()) return result;
+  for (const xtgui::Attr &attr : node->attrs) {
+    if (attr.name.size() <= 5 || attr.name.compare(0, 5, "data-") != 0) continue;
+    std::string name = to_property_name(attr.name.substr(5));
+    if (!name.empty()) xt_array_push(result, xt_string_from_cstr(name.c_str()));
+  }
+  return result;
+}
+
+const xt_object_hooks kDatasetHooks = {dataset_view_get, dataset_view_set, dataset_view_has,
+                                       dataset_view_remove, dataset_view_keys};
+
+}  // namespace
+
+#define METHOD(name) xt_value name(xt_value self, xt_value env, int32_t argc, xt_value *argv)
+
+METHOD(node_dataset_get) {
+  (void)env;
+  (void)argc;
+  (void)argv;
+  xt_value cached = xt_object_get_cstr(self, "__xt_gui_dataset");
+  if (XT_IS_OBJECT(cached)) return cached;
+  xt_value dataset = xt_object_new();
+  xt_object_set(dataset, dataset_node_key(), self);
+  xt_object_set_hooks(dataset, &kDatasetHooks, nullptr);
+  xt_object_set(self, xt_string_from_cstr("__xt_gui_dataset"), dataset);
+  return dataset;
+}
+
+}  // namespace domapi