@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/traversal/TreeWalker-impl.js

@@ -0,0 +1,217 @@
+"use strict";
+
+const DOMException = require("../../../generated/idl/DOMException");
+const { filter, FILTER_ACCEPT, FILTER_REJECT, FILTER_SKIP } = require("./helpers");
+
+const FIRST = false;
+const LAST = true;
+const NEXT = false;
+const PREVIOUS = true;
+
+exports.implementation = class TreeWalkerImpl {
+  constructor(globalObject, args, privateData) {
+    this._active = false;
+    this.root = privateData.root;
+    this.currentNode = this.root;
+    this.whatToShow = privateData.whatToShow;
+    this.filter = privateData.filter;
+
+    this._globalObject = globalObject;
+  }
+
+  get currentNode() {
+    return this._currentNode;
+  }
+
+  set currentNode(node) {
+    if (node === null) {
+      throw DOMException.create(this._globalObject, ["Cannot set currentNode to null", "NotSupportedError"]);
+    }
+
+    this._currentNode = node;
+  }
+
+  parentNode() {
+    let node = this._currentNode;
+    while (node !== null && node !== this.root) {
+      node = node.parentNode;
+
+      if (node !== null && filter(this, node) === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+    }
+    return null;
+  }
+
+  firstChild() {
+    return this._traverseChildren(FIRST);
+  }
+
+  lastChild() {
+    return this._traverseChildren(LAST);
+  }
+
+  previousSibling() {
+    return this._traverseSiblings(PREVIOUS);
+  }
+
+  nextSibling() {
+    return this._traverseSiblings(NEXT);
+  }
+
+  previousNode() {
+    let node = this._currentNode;
+
+    while (node !== this.root) {
+      let sibling = node.previousSibling;
+
+      while (sibling !== null) {
+        node = sibling;
+        let result = filter(this, node);
+
+        while (result !== FILTER_REJECT && node.hasChildNodes()) {
+          node = node.lastChild;
+          result = filter(this, node);
+        }
+
+        if (result === FILTER_ACCEPT) {
+          return (this._currentNode = node);
+        }
+
+        sibling = node.previousSibling;
+      }
+
+      if (node === this.root || node.parentNode === null) {
+        return null;
+      }
+
+      node = node.parentNode;
+
+      if (filter(this, node) === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+    }
+
+    return null;
+  }
+
+  nextNode() {
+    let node = this._currentNode;
+    let result = FILTER_ACCEPT;
+
+    for (;;) {
+      while (result !== FILTER_REJECT && node.hasChildNodes()) {
+        node = node.firstChild;
+        result = filter(this, node);
+        if (result === FILTER_ACCEPT) {
+          return (this._currentNode = node);
+        }
+      }
+
+      do {
+        if (node === this.root) {
+          return null;
+        }
+
+        const sibling = node.nextSibling;
+
+        if (sibling !== null) {
+          node = sibling;
+          break;
+        }
+
+        node = node.parentNode;
+      } while (node !== null);
+
+      if (node === null) {
+        return null;
+      }
+
+      result = filter(this, node);
+
+      if (result === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+    }
+  }
+
+  _traverseChildren(type) {
+    let node = this._currentNode;
+    node = type === FIRST ? node.firstChild : node.lastChild;
+
+    if (node === null) {
+      return null;
+    }
+
+    main: for (;;) {
+      const result = filter(this, node);
+
+      if (result === FILTER_ACCEPT) {
+        return (this._currentNode = node);
+      }
+
+      if (result === FILTER_SKIP) {
+        const child = type === FIRST ? node.firstChild : node.lastChild;
+
+        if (child !== null) {
+          node = child;
+          continue;
+        }
+      }
+
+      for (;;) {
+        const sibling = type === FIRST ? node.nextSibling : node.previousSibling;
+
+        if (sibling !== null) {
+          node = sibling;
+          continue main;
+        }
+
+        const parent = node.parentNode;
+
+        if (parent === null || parent === this.root || parent === this._currentNode) {
+          return null;
+        }
+
+        node = parent;
+      }
+    }
+  }
+
+  _traverseSiblings(type) {
+    let node = this._currentNode;
+
+    if (node === this.root) {
+      return null;
+    }
+
+    for (;;) {
+      let sibling = type === NEXT ? node.nextSibling : node.previousSibling;
+
+      while (sibling !== null) {
+        node = sibling;
+        const result = filter(this, node);
+
+        if (result === FILTER_ACCEPT) {
+          return (this._currentNode = node);
+        }
+
+        sibling = type === NEXT ? node.firstChild : node.lastChild;
+
+        if (result === FILTER_REJECT || sibling === null) {
+          sibling = type === NEXT ? node.nextSibling : node.previousSibling;
+        }
+      }
+
+      node = node.parentNode;
+
+      if (node === null || node === this.root) {
+        return null;
+      }
+
+      if (filter(this, node) === FILTER_ACCEPT) {
+        return null;
+      }
+    }
+  }
+};

package/lib/jsdom/living/traversal/helpers.js

@@ -0,0 +1,44 @@
+"use strict";
+const DOMException = require("../../../generated/idl/DOMException");
+const conversions = require("webidl-conversions");
+
+exports.FILTER_ACCEPT = 1; // NodeFilter.FILTER_ACCEPT
+exports.FILTER_REJECT = 2; // NodeFilter.FILTER_REJECT
+exports.FILTER_SKIP = 3; // NodeFilter.FILTER_SKIP
+
+exports.filter = (nodeIteratorOrTreeWalkerImpl, nodeImpl) => {
+  if (nodeIteratorOrTreeWalkerImpl._active) {
+    throw DOMException.create(nodeIteratorOrTreeWalkerImpl._globalObject, [
+      "Recursive node filtering",
+      "InvalidStateError"
+    ]);
+  }
+
+  const n = nodeImpl.nodeType - 1;
+
+  if (!((1 << n) & nodeIteratorOrTreeWalkerImpl.whatToShow)) {
+    return exports.FILTER_SKIP;
+  }
+
+  // Saving in a variable is important so we don't accidentally call it as a method later.
+  const { filter } = nodeIteratorOrTreeWalkerImpl;
+
+  if (filter === null) {
+    return exports.FILTER_ACCEPT;
+  }
+
+  nodeIteratorOrTreeWalkerImpl._active = true;
+
+  let result;
+
+  // https://github.com/whatwg/dom/issues/494
+  try {
+    result = filter(nodeImpl);
+  } finally {
+    nodeIteratorOrTreeWalkerImpl._active = false;
+  }
+
+  result = conversions["unsigned short"](result);
+
+  return result;
+};

package/lib/jsdom/living/webidl/DOMException-impl.js

@@ -0,0 +1,46 @@
+"use strict";
+const idlUtils = require("../../../generated/idl/utils");
+
+const legacyErrorCodes = {
+  IndexSizeError: 1,
+  HierarchyRequestError: 3,
+  WrongDocumentError: 4,
+  InvalidCharacterError: 5,
+  NoModificationAllowedError: 7,
+  NotFoundError: 8,
+  NotSupportedError: 9,
+  InUseAttributeError: 10,
+  InvalidStateError: 11,
+  SyntaxError: 12,
+  InvalidModificationError: 13,
+  NamespaceError: 14,
+  InvalidAccessError: 15,
+  TypeMismatchError: 17,
+  SecurityError: 18,
+  NetworkError: 19,
+  AbortError: 20,
+  URLMismatchError: 21,
+  QuotaExceededError: 22,
+  TimeoutError: 23,
+  InvalidNodeTypeError: 24,
+  DataCloneError: 25
+};
+
+exports.implementation = class DOMExceptionImpl {
+  constructor(globalObject, [message, name]) {
+    this.name = name;
+    this.message = message;
+  }
+
+  get code() {
+    return legacyErrorCodes[this.name] || 0;
+  }
+};
+
+// A proprietary V8 extension that causes the stack property to appear.
+exports.init = impl => {
+  if (Error.captureStackTrace) {
+    const wrapper = idlUtils.wrapperForImpl(impl);
+    Error.captureStackTrace(wrapper, wrapper.constructor);
+  }
+};

package/lib/jsdom/living/websockets/WebSocket-impl.js

@@ -0,0 +1,211 @@
+"use strict";
+const { WebSocket } = require("undici");
+const { parseURL, serializeURL, serializeURLOrigin } = require("whatwg-url");
+const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");
+const { fireAnEvent } = require("../helpers/events");
+const { copyToArrayBufferInTargetRealmDestructively } = require("../helpers/binary-data");
+const IterableWeakSet = require("../helpers/iterable-weak-set");
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+const Blob = require("../../../generated/idl/Blob");
+const CloseEvent = require("../../../generated/idl/CloseEvent");
+const DOMException = require("../../../generated/idl/DOMException");
+const MessageEvent = require("../../../generated/idl/MessageEvent");
+
+const openSockets = new WeakMap();
+
+class WebSocketImpl extends EventTargetImpl {
+  constructor(globalObject, [url, protocols]) {
+    super(globalObject);
+
+    // Do our own URL parsing because we want to be consistent with the rest of jsdom and use whatwg-url, not Node.js's
+    // URL.
+    const urlRecord = parseURL(url);
+    if (urlRecord === null) {
+      throw DOMException.create(this._globalObject, [`The URL '${url}' is invalid.`, "SyntaxError"]);
+    }
+    if (urlRecord.scheme !== "ws" && urlRecord.scheme !== "wss") {
+      throw DOMException.create(this._globalObject, [
+        `The URL's scheme must be either 'ws' or 'wss'. '${urlRecord.scheme}' is not allowed.`,
+        "SyntaxError"
+      ]);
+    }
+    if (urlRecord.fragment !== null) {
+      throw DOMException.create(this._globalObject, [
+        `The URL contains a fragment identifier ('${urlRecord.fragment}'). Fragment identifiers ` +
+        "are not allowed in WebSocket URLs.",
+        "SyntaxError"
+      ]);
+    }
+
+    this._urlRecord = urlRecord;
+    this._urlSerialized = serializeURL(urlRecord);
+    this._binaryType = "blob";
+
+    const wsOptions = {
+      dispatcher: globalObject._dispatcher,
+      protocols,
+      headers: {
+        // Origin is required for WebSocket and uses the window's origin
+        origin: globalObject._origin
+      }
+    };
+
+    this._ws = wrapAndRethrowNodeDOMExceptions(() => {
+      return new WebSocket(serializeURL(urlRecord), wsOptions);
+    }, this._globalObject);
+
+    // Always use "arraybuffer" for `this._ws`'s `binaryType`. It will be converted to the correct type by `_onMessage`,
+    // and jsdom's `Blob`s are just wrappers around `ArrayBuffer`s anyway.
+    this._ws.binaryType = "arraybuffer";
+
+    // Track open sockets for cleanup
+    let openSocketsForWindow = openSockets.get(globalObject._globalProxy);
+    if (openSocketsForWindow === undefined) {
+      openSocketsForWindow = new IterableWeakSet();
+      openSockets.set(globalObject._globalProxy, openSocketsForWindow);
+    }
+    openSocketsForWindow.add(this);
+
+    // Set up event forwarding. We use `setTimeout()` to work around https://github.com/nodejs/undici/issues/4741 where
+    // undici fires events synchronously during `close()`, but the spec requires them to fire asynchronously.
+    this._ws.addEventListener("open", () => {
+      setTimeout(() => fireAnEvent("open", this), 0);
+    });
+
+    this._ws.addEventListener("message", event => {
+      // Capture readyState now, before setTimeout, because undici may transition to CLOSED before our setTimeout fires,
+      // but the spec says readyState must be OPEN during message events.
+      const readyStateWhenReceived = this._ws.readyState;
+      setTimeout(() => {
+        const prevReadyState = this._readyState;
+        this._readyState = readyStateWhenReceived;
+        this._onMessage(event);
+        this._readyState = prevReadyState;
+      }, 0);
+    });
+
+    this._ws.addEventListener("error", () => {
+      setTimeout(() => fireAnEvent("error", this), 0);
+    });
+
+    this._ws.addEventListener("close", event => {
+      setTimeout(() => {
+        // Set readyState to CLOSED when firing the close event. We manage this ourselves because undici has bugs with
+        // readyState during close: https://github.com/nodejs/undici/issues/4742.
+        this._readyState = this._ws.CLOSED;
+        openSocketsForWindow.delete(this);
+        fireAnEvent("close", this, CloseEvent, {
+          wasClean: event.wasClean,
+          code: event.code,
+          reason: event.reason
+        });
+      }, 0);
+    });
+  }
+
+  _onMessage({ data }) {
+    let dataForEvent;
+    if (typeof data === "string") {
+      dataForEvent = data;
+    } else if (this._binaryType === "arraybuffer") {
+      dataForEvent = copyToArrayBufferInTargetRealmDestructively(data, this._globalObject);
+    } else {
+      // `this._binaryType === "blob"`
+      dataForEvent = Blob.create(this._globalObject, [undefined, { type: "" }], {
+        fastPathArrayBufferToWrap: data
+      });
+    }
+
+    fireAnEvent("message", this, MessageEvent, {
+      data: dataForEvent,
+      origin: serializeURLOrigin(this._urlRecord)
+    });
+  }
+
+  get url() {
+    return this._urlSerialized;
+  }
+
+  get readyState() {
+    // Use captured readyState if available (workaround for undici bug #4742)
+    return this._readyState ?? this._ws.readyState;
+  }
+
+  get bufferedAmount() {
+    return this._ws.bufferedAmount;
+  }
+
+  get extensions() {
+    return this._ws.extensions;
+  }
+
+  get protocol() {
+    return this._ws.protocol;
+  }
+
+  get binaryType() {
+    return this._binaryType;
+  }
+
+  set binaryType(value) {
+    this._binaryType = value;
+  }
+
+  close(code, reason) {
+    return wrapAndRethrowNodeDOMExceptions(() => {
+      // Set readyState to CLOSING before calling undici's close(). We manage this ourselves because
+      // undici has bugs with readyState during close - see https://github.com/nodejs/undici/issues/4742
+      // Only set to CLOSING if not already CLOSED (calling close() on a closed socket is a no-op).
+      if (this._readyState !== this._ws.CLOSED) {
+        this._readyState = this._ws.CLOSING;
+      }
+      return this._ws.close(code, reason);
+    }, this._globalObject);
+  }
+
+  send(data) {
+    return wrapAndRethrowNodeDOMExceptions(() => {
+      // Convert jsdom Blob to ArrayBuffer. Other types are passed through as-is.
+      if (Blob.isImpl(data)) {
+        data = data._bytes.buffer;
+      }
+
+      return this._ws.send(data);
+    }, this._globalObject);
+  }
+
+  // https://websockets.spec.whatwg.org/#make-disappear
+  // But with additional work from jsdom to remove all event listeners.
+  _makeDisappear() {
+    this._eventListeners = Object.create(null);
+    if (this._ws.readyState === this._ws.OPEN || this._ws.readyState === this._ws.CONNECTING) {
+      // Close without a code - undici doesn't allow reserved codes like 1001
+      this._ws.close();
+    }
+  }
+
+  static cleanUpWindow(window) {
+    const openSocketsForWindow = openSockets.get(window._globalProxy);
+    if (openSocketsForWindow !== undefined) {
+      for (const ws of openSocketsForWindow) {
+        ws._makeDisappear();
+      }
+      openSockets.delete(window._globalProxy);
+    }
+  }
+}
+
+function wrapAndRethrowNodeDOMExceptions(func, globalObject) {
+  try {
+    return func();
+  } catch (e) {
+    if (e instanceof globalThis.DOMException) {
+      throw DOMException.create(globalObject, [e.message, e.name]);
+    }
+    throw e;
+  }
+}
+
+setupForSimpleEventAccessors(WebSocketImpl.prototype, ["open", "message", "error", "close"]);
+
+exports.implementation = WebSocketImpl;

package/lib/jsdom/living/webstorage/Storage-impl.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const DOMException = require("../../../generated/idl/DOMException");
+const StorageEvent = require("../../../generated/idl/StorageEvent");
+const idlUtils = require("../../../generated/idl/utils");
+const { fireAnEvent } = require("../helpers/events");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storage-interface
+class StorageImpl {
+  constructor(globalObject, args, privateData) {
+    const { associatedWindow, storageArea, url, type, storageQuota } = privateData;
+
+    this._associatedWindow = associatedWindow;
+    this._items = storageArea;
+    this._url = url;
+    this._type = type;
+    this._quota = storageQuota;
+
+    this._globalObject = globalObject;
+  }
+
+  _dispatchStorageEvent(key, oldValue, newValue) {
+    return this._associatedWindow._currentOriginData.windowsInSameOrigin
+      .filter(target => target !== this._associatedWindow)
+      .forEach(target => fireAnEvent("storage", target, StorageEvent, {
+        key,
+        oldValue,
+        newValue,
+        url: this._url,
+        storageArea: target["_" + this._type]
+      }));
+  }
+
+  get length() {
+    return this._items.size;
+  }
+
+  key(n) {
+    if (n >= this._items.size) {
+      return null;
+    }
+    return [...this._items.keys()][n];
+  }
+
+  getItem(key) {
+    if (this._items.has(key)) {
+      return this._items.get(key);
+    }
+    return null;
+  }
+
+  setItem(key, value) {
+    const oldValue = this._items.get(key) || null;
+
+    if (oldValue === value) {
+      return;
+    }
+
+    // Concatenate all keys and values to measure their length against the quota
+    let itemsTotalLength = key.length + value.length;
+    for (const [curKey, curValue] of this._items) {
+      // If the key already exists, skip it as it will be set to the new value instead
+      if (key !== curKey) {
+        itemsTotalLength += curKey.length + curValue.length;
+      }
+    }
+    if (itemsTotalLength > this._quota) {
+      throw DOMException.create(this._globalObject, [
+        `The ${this._quota}-code unit storage quota has been exceeded.`,
+        "QuotaExceededError"
+      ]);
+    }
+
+    setTimeout(this._dispatchStorageEvent.bind(this), 0, key, oldValue, value);
+
+    this._items.set(key, value);
+  }
+
+  removeItem(key) {
+    if (this._items.has(key)) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, key, this._items.get(key), null);
+
+      this._items.delete(key);
+    }
+  }
+
+  clear() {
+    if (this._items.size > 0) {
+      setTimeout(this._dispatchStorageEvent.bind(this), 0, null, null, null);
+
+      this._items.clear();
+    }
+  }
+
+  get [idlUtils.supportedPropertyNames]() {
+    return this._items.keys();
+  }
+}
+
+module.exports = {
+  implementation: StorageImpl
+};

package/lib/jsdom/living/window/BarProp-impl.js

@@ -0,0 +1,10 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/window-object.html#browser-interface-elements
+class BarPropImpl {}
+
+// Since many BarProps do not apply to modern browsers,
+// returning true in all cases seems to be common practice.
+BarPropImpl.prototype.visible = true;
+
+exports.implementation = BarPropImpl;

package/lib/jsdom/living/window/External-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+// https://html.spec.whatwg.org/multipage/obsolete.html#dom-external
+exports.implementation = class ExternalImpl {
+  // The AddSearchProvider() and IsSearchProviderInstalled() methods must do nothing
+  AddSearchProvider() {}
+
+  IsSearchProviderInstalled() {}
+};