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

package/cpp/quickjs/bindings/WindowBindings.cpp

@@ -1,10 +1,11 @@
 #include "WindowBindings.hpp"
 #include "DOMExceptionBindings.hpp"
+#include "EventBindings.hpp"
 #include "../DOMBindingsInternal.hpp"
 #include "../QuickJSRuntime.hpp"
+#include <cstdlib>
 #include <cstring>
 #include <optional>
-#include <random>
 #include <string>
 #include <vector>
 
@@ -191,6 +192,23 @@ JSValue js_console_method(JSContext* ctx, JSValue, int argc, JSValue* argv, int
   return JS_UNDEFINED;
 }
 
+JSValue js_window_reportError(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+  JSValue error_value = argc >= 1 ? argv[0] : JS_UNDEFINED;
+  std::string message = "Uncaught";
+  if (argc >= 1) {
+    JSValue msg_prop = JS_GetPropertyStr(ctx, argv[0], "message");
+    if (!JS_IsException(msg_prop) && !JS_IsUndefined(msg_prop)) {
+      const char* s = JS_ToCString(ctx, msg_prop);
+      if (s) { message = s; JS_FreeCString(ctx, s); }
+    } else if (JS_IsException(msg_prop)) {
+      JS_FreeValue(ctx, JS_GetException(ctx));
+    }
+    JS_FreeValue(ctx, msg_prop);
+  }
+  EventBindings::dispatchErrorEvent(ctx, message, error_value);
+  return JS_UNDEFINED;
+}
+
 // ── window.alert / confirm / prompt ───────────────────────────────────────────
 
 JSValue js_window_alert(JSContext* ctx, JSValue, int argc, JSValue* argv) {
@@ -346,12 +364,12 @@ JSValue js_native_random_bytes(JSContext* ctx, JSValue, int argc, JSValue* argv)
   if (argc >= 1) JS_ToInt32(ctx, &count, argv[0]);
   if (count < 0) count = 0;
 
-  static thread_local std::mt19937 gen{std::random_device{}()};
-  std::uniform_int_distribution<int> dist(0, 255);
+  std::vector<uint8_t> bytes(static_cast<size_t>(count));
+  if (count > 0) arc4random_buf(bytes.data(), bytes.size());
 
   JSValue arr = JS_NewArray(ctx);
   for (int32_t i = 0; i < count; i++) {
-    JS_SetPropertyUint32(ctx, arr, static_cast<uint32_t>(i), JS_NewInt32(ctx, dist(gen)));
+    JS_SetPropertyUint32(ctx, arr, static_cast<uint32_t>(i), JS_NewInt32(ctx, bytes[static_cast<size_t>(i)]));
   }
   return arr;
 }
@@ -373,6 +391,67 @@ const char* kCryptoBootstrapScript = R"JS(
     for (var i = 0; i < bytes.length; i++) view[i] = bytes[i];
     return typedArray;
   };
+  globalThis.crypto.randomUUID = function() {
+    var bytes = __nativeRandomBytes(16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    var hex = [];
+    for (var i = 0; i < 16; i++) {
+      var h = bytes[i].toString(16);
+      hex.push(h.length === 1 ? '0' + h : h);
+    }
+    return hex.slice(0, 4).join('') + '-' + hex.slice(4, 6).join('') + '-' +
+      hex.slice(6, 8).join('') + '-' + hex.slice(8, 10).join('') + '-' + hex.slice(10, 16).join('');
+  };
+})();
+)JS";
+
+// ── console ergonomics (group/table/assert/trace/count) ──────────────────────
+// Layered in pure JS on top of the native log/warn/error/info/debug methods
+// above rather than adding new native levels — none of these need anything
+// the onConsole callback can't already receive as stringified args.
+
+const char* kConsoleExtrasBootstrapScript = R"JS(
+(function() {
+  var counts = Object.create(null);
+
+  console.group = function() {
+    console.log.apply(console, arguments);
+  };
+  console.groupCollapsed = console.group;
+  console.groupEnd = function() {};
+
+  console.trace = function() {
+    var args = Array.prototype.slice.call(arguments);
+    args.unshift('Trace:');
+    console.log.apply(console, args);
+  };
+
+  console.assert = function(condition) {
+    if (condition) return;
+    var args = Array.prototype.slice.call(arguments, 1);
+    args.unshift('Assertion failed:');
+    console.error.apply(console, args);
+  };
+
+  console.table = function(data) {
+    try {
+      console.log(JSON.stringify(data));
+    } catch (e) {
+      console.log(String(data));
+    }
+  };
+
+  console.count = function(label) {
+    label = label === undefined ? 'default' : String(label);
+    counts[label] = (counts[label] || 0) + 1;
+    console.log(label + ': ' + counts[label]);
+  };
+
+  console.countReset = function(label) {
+    label = label === undefined ? 'default' : String(label);
+    counts[label] = 0;
+  };
 })();
 )JS";
 
@@ -389,10 +468,184 @@ const char* kNavigatorBootstrapScript = R"JS(
     cookieEnabled: false,
     hardwareConcurrency: 1,
   };
+  navigator.sendBeacon = function(url, data) {
+    try {
+      fetch(url, { method: 'POST', body: data }).catch(function() {});
+    } catch (e) {
+      return false;
+    }
+    return true;
+  };
+
+  // jsdom itself doesn't implement the Clipboard API at all (no OS clipboard
+  // to back it, same reasoning as window.history/getSelection). This is an
+  // in-memory stand-in purely so 'copy discount code'-style embedded widgets
+  // that call navigator.clipboard.writeText() directly don't throw — reads
+  // back whatever was last written, nothing more.
+  var clipboardText = '';
+  navigator.clipboard = {
+    writeText: function(text) {
+      clipboardText = String(text);
+      return Promise.resolve();
+    },
+    readText: function() {
+      return Promise.resolve(clipboardText);
+    },
+  };
+
   globalThis.navigator = navigator;
 })();
 )JS";
 
+// ── structuredClone ────────────────────────────────────────────────────────
+
+const char* kStructuredCloneBootstrapScript = R"JS(
+(function() {
+  globalThis.structuredClone = function(value) {
+    var seen = new Map();
+    function clone(v) {
+      if (v === null || typeof v !== 'object') {
+        if (typeof v === 'function' || typeof v === 'symbol') {
+          throw new DOMException(String(v) + ' could not be cloned.', 'DataCloneError');
+        }
+        return v;
+      }
+      if (seen.has(v)) return seen.get(v);
+      if (v instanceof Date) return new Date(v.getTime());
+      if (v instanceof RegExp) return new RegExp(v.source, v.flags);
+      if (Array.isArray(v)) {
+        var arr = [];
+        seen.set(v, arr);
+        for (var i = 0; i < v.length; i++) arr.push(clone(v[i]));
+        return arr;
+      }
+      if (v instanceof Map) {
+        var m = new Map();
+        seen.set(v, m);
+        v.forEach(function(val, key) { m.set(clone(key), clone(val)); });
+        return m;
+      }
+      if (v instanceof Set) {
+        var s = new Set();
+        seen.set(v, s);
+        v.forEach(function(val) { s.add(clone(val)); });
+        return s;
+      }
+      if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView && ArrayBuffer.isView(v)) {
+        return new v.constructor(v);
+      }
+      if (typeof ArrayBuffer !== 'undefined' && v instanceof ArrayBuffer) {
+        return v.slice(0);
+      }
+      var proto = Object.getPrototypeOf(v);
+      if (proto !== Object.prototype && proto !== null) {
+        throw new DOMException('The object could not be cloned.', 'DataCloneError');
+      }
+      var out = {};
+      seen.set(v, out);
+      for (var key in v) {
+        if (Object.prototype.hasOwnProperty.call(v, key)) out[key] = clone(v[key]);
+      }
+      return out;
+    }
+    return clone(value);
+  };
+})();
+)JS";
+
+// ── window.history ────────────────────────────────────────────────────────
+// No real page navigation exists in this sandbox, so History tracks its own
+// in-memory entry stack rather than session history. pushState/replaceState
+// never fire popstate (per spec); go/back/forward do, since those are the
+// events CMS-widget routers actually listen for. `title` is accepted but
+// ignored (same as jsdom — nothing renders a document title). State is
+// structuredClone()'d on write (per spec — matches pushState/replaceState's
+// documented "serializable" semantics), so callers mutating their object
+// after the call can't leak into a stored entry. `go()`'s delta is truncated
+// to an integer so a fractional/NaN input can't produce a non-integer
+// `_index`.
+
+const char* kHistoryBootstrapScript = R"JS(
+(function() {
+  function History() {
+    this._entries = [null];
+    this._index = 0;
+  }
+  Object.defineProperty(History.prototype, 'length', {
+    get: function() { return this._entries.length; },
+    enumerable: true,
+  });
+  Object.defineProperty(History.prototype, 'state', {
+    get: function() { return this._entries[this._index]; },
+    enumerable: true,
+  });
+  function cloneState(state) {
+    return state === undefined ? null : structuredClone(state);
+  }
+  History.prototype.pushState = function(state, _title, url) {
+    this._entries = this._entries.slice(0, this._index + 1);
+    this._entries.push(cloneState(state));
+    this._index++;
+    if (url !== undefined && url !== null) location.href = url;
+  };
+  History.prototype.replaceState = function(state, _title, url) {
+    this._entries[this._index] = cloneState(state);
+    if (url !== undefined && url !== null) location.href = url;
+  };
+  History.prototype.go = function(delta) {
+    delta = delta === undefined ? 0 : Math.trunc(Number(delta) || 0);
+    if (delta === 0) return;
+    var next = this._index + delta;
+    if (next < 0 || next > this._entries.length - 1) return;
+    this._index = next;
+    var ev = new Event('popstate');
+    ev.state = this._entries[this._index];
+    dispatchEvent(ev);
+  };
+  History.prototype.back = function() { this.go(-1); };
+  History.prototype.forward = function() { this.go(1); };
+
+  globalThis.History = History;
+  globalThis.history = new History();
+})();
+)JS";
+
+// ── window.getSelection ──────────────────────────────────────────────────
+// No layout engine backs this sandbox, so there is nothing to select — this
+// mirrors matchMedia's stance: an always-empty Selection rather than a
+// missing global, so defensive `window.getSelection().toString()` checks in
+// third-party scripts don't crash the sandbox.
+
+const char* kSelectionBootstrapScript = R"JS(
+(function() {
+  function Selection() {}
+  Object.defineProperty(Selection.prototype, 'rangeCount', { get: function() { return 0; }, enumerable: true });
+  Object.defineProperty(Selection.prototype, 'isCollapsed', { get: function() { return true; }, enumerable: true });
+  Object.defineProperty(Selection.prototype, 'anchorNode', { get: function() { return null; }, enumerable: true });
+  Object.defineProperty(Selection.prototype, 'anchorOffset', { get: function() { return 0; }, enumerable: true });
+  Object.defineProperty(Selection.prototype, 'focusNode', { get: function() { return null; }, enumerable: true });
+  Object.defineProperty(Selection.prototype, 'focusOffset', { get: function() { return 0; }, enumerable: true });
+  Object.defineProperty(Selection.prototype, 'type', { get: function() { return 'None'; }, enumerable: true });
+  Selection.prototype.toString = function() { return ''; };
+  Selection.prototype.removeAllRanges = function() {};
+  Selection.prototype.collapse = function() {};
+  Selection.prototype.collapseToStart = function() {};
+  Selection.prototype.collapseToEnd = function() {};
+  Selection.prototype.selectAllChildren = function() {};
+  Selection.prototype.addRange = function() {};
+  Selection.prototype.containsNode = function() { return false; };
+  Selection.prototype.getRangeAt = function(index) {
+    throw new DOMException(
+      "Failed to execute 'getRangeAt' on 'Selection': " + index + ' is not a valid index.', 'IndexSizeError');
+  };
+  Selection.prototype.empty = Selection.prototype.removeAllRanges;
+
+  var selectionInstance = new Selection();
+  globalThis.Selection = Selection;
+  globalThis.getSelection = function() { return selectionInstance; };
+})();
+)JS";
+
 // ── matchMedia ─────────────────────────────────────────────────────────────
 // No layout engine backs this sandbox, so every query reports "no match" —
 // mirrors jsdom's own stance that layout-dependent APIs return inert defaults
@@ -435,6 +688,7 @@ void WindowBindings::install(JSContext* ctx) {
   JS_SetPropertyStr(ctx, global, "alert",   JS_NewCFunction(ctx, js_window_alert,   "alert",   1));
   JS_SetPropertyStr(ctx, global, "confirm", JS_NewCFunction(ctx, js_window_confirm, "confirm", 1));
   JS_SetPropertyStr(ctx, global, "prompt",  JS_NewCFunction(ctx, js_window_prompt,  "prompt",  2));
+  JS_SetPropertyStr(ctx, global, "reportError", JS_NewCFunction(ctx, js_window_reportError, "reportError", 1));
   JS_SetPropertyStr(ctx, global, "atob",    JS_NewCFunction(ctx, js_window_atob,    "atob",    1));
   JS_SetPropertyStr(ctx, global, "btoa",    JS_NewCFunction(ctx, js_window_btoa,    "btoa",    1));
 
@@ -456,6 +710,27 @@ void WindowBindings::install(JSContext* ctx) {
   }
   JS_FreeValue(ctx, location_result);
 
+  JSValue history_result = JS_Eval(ctx, kHistoryBootstrapScript, strlen(kHistoryBootstrapScript),
+                                    "<history-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(history_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, history_result);
+
+  JSValue selection_result = JS_Eval(ctx, kSelectionBootstrapScript, strlen(kSelectionBootstrapScript),
+                                      "<selection-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(selection_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, selection_result);
+
+  JSValue console_extras_result = JS_Eval(ctx, kConsoleExtrasBootstrapScript, strlen(kConsoleExtrasBootstrapScript),
+                                           "<console-extras-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(console_extras_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, console_extras_result);
+
   JSValue crypto_result = JS_Eval(ctx, kCryptoBootstrapScript, strlen(kCryptoBootstrapScript),
                                    "<crypto-bootstrap>", JS_EVAL_TYPE_GLOBAL);
   if (JS_IsException(crypto_result)) {
@@ -476,6 +751,13 @@ void WindowBindings::install(JSContext* ctx) {
     JS_FreeValue(ctx, JS_GetException(ctx));
   }
   JS_FreeValue(ctx, match_media_result);
+
+  JSValue structured_clone_result = JS_Eval(ctx, kStructuredCloneBootstrapScript, strlen(kStructuredCloneBootstrapScript),
+                                             "<structured-clone-bootstrap>", JS_EVAL_TYPE_GLOBAL);
+  if (JS_IsException(structured_clone_result)) {
+    JS_FreeValue(ctx, JS_GetException(ctx));
+  }
+  JS_FreeValue(ctx, structured_clone_result);
 }
 
 } // namespace margelo::nitro::nitrojsdom

package/cpp/quickjs/bindings/WindowBindings.hpp

@@ -1,8 +1,9 @@
 #pragma once
 
 // window.alert/confirm/prompt (bridged to onAlert/onConfirm/onPrompt native
-// callbacks), console.log/warn/error/info/debug, and the window.location
-// bootstrap script.
+// callbacks), console.log/warn/error/info/debug, and the window.location,
+// window.history, window.getSelection, crypto, navigator, matchMedia, and
+// structuredClone bootstrap scripts.
 
 #include "quickjs.h"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@salve-software/react-native-nitro-jsdom",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "packageManager": "yarn@4.9.1",
   "description": "A headless HTML/DOM environment for React Native.",
   "main": "./lib/commonjs/index.js",
@@ -24,7 +24,22 @@
   },
   "keywords": [
     "react-native",
-    "@salve-software/react-native-nitro-jsdom"
+    "react-native-jsdom",
+    "react-native-nitro-jsdom",
+    "nitro-modules",
+    "nitro",
+    "expo",
+    "jsdom",
+    "dom",
+    "html",
+    "html-parser",
+    "quickjs",
+    "lexbor",
+    "sandbox",
+    "headless-browser",
+    "webview-alternative",
+    "ios",
+    "android"
   ],
   "files": [
     "src",