@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/events/StorageEvent-impl.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const StorageEventInit = require("../../../generated/idl/StorageEventInit");
+
+// https://html.spec.whatwg.org/multipage/webstorage.html#the-storageevent-interface
+class StorageEventImpl extends EventImpl {
+  initStorageEvent(type, bubbles, cancelable, key, oldValue, newValue, url, storageArea) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.key = key;
+    this.oldValue = oldValue;
+    this.newValue = newValue;
+    this.url = url;
+    this.storageArea = storageArea;
+  }
+}
+StorageEventImpl.defaultInit = StorageEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: StorageEventImpl
+};

package/lib/jsdom/living/events/SubmitEvent-impl.js

@@ -0,0 +1,13 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const SubmitEventInit = require("../../../generated/idl/SubmitEventInit");
+
+// https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#the-submitevent-interface
+class SubmitEventImpl extends EventImpl {}
+SubmitEventImpl.defaultInit = SubmitEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: SubmitEventImpl
+};

package/lib/jsdom/living/events/TouchEvent-impl.js

@@ -0,0 +1,14 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const TouchEventInit = require("../../../generated/idl/TouchEventInit");
+
+class TouchEventImpl extends UIEventImpl {
+
+}
+TouchEventImpl.defaultInit = TouchEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: TouchEventImpl
+};

package/lib/jsdom/living/events/TransitionEvent-impl.js

@@ -0,0 +1,10 @@
+"use strict";
+const EventImpl = require("./Event-impl").implementation;
+const TransitionEventInit = require("../../../generated/idl/TransitionEventInit");
+
+class TransitionEventImpl extends EventImpl {}
+TransitionEventImpl.defaultInit = TransitionEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: TransitionEventImpl
+};

package/lib/jsdom/living/events/UIEvent-impl.js

@@ -0,0 +1,43 @@
+"use strict";
+
+const isWindow = require("../helpers/is-window");
+const UIEventInit = require("../../../generated/idl/UIEventInit");
+const EventImpl = require("./Event-impl").implementation;
+
+class UIEventImpl extends EventImpl {
+  constructor(globalObject, args, privateData) {
+    const eventInitDict = args[1];
+
+    // undefined check included so that we can omit the property in internal usage.
+    if (eventInitDict && eventInitDict.view !== null && eventInitDict.view !== undefined) {
+      if (!isWindow(eventInitDict.view)) {
+        throw new TypeError(`Failed to construct '${new.target.name.replace(/Impl$/, "")}': member view is not of ` +
+                            "type Window.");
+      }
+    }
+
+    super(globalObject, args, privateData);
+  }
+
+  initUIEvent(type, bubbles, cancelable, view, detail) {
+    if (view !== null) {
+      if (!isWindow(view)) {
+        throw new TypeError(`Failed to execute 'initUIEvent' on '${this.constructor.name.replace(/Impl$/, "")}': ` +
+                            "parameter 4 is not of type 'Window'.");
+      }
+    }
+
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.view = view;
+    this.detail = detail;
+  }
+}
+UIEventImpl.defaultInit = UIEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: UIEventImpl
+};

package/lib/jsdom/living/events/WheelEvent-impl.js

@@ -0,0 +1,12 @@
+"use strict";
+
+const MouseEventImpl = require("./MouseEvent-impl").implementation;
+
+const WheelEventInit = require("../../../generated/idl/WheelEventInit");
+
+class WheelEventImpl extends MouseEventImpl {}
+WheelEventImpl.defaultInit = WheelEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: WheelEventImpl
+};

package/lib/jsdom/living/fetch/Headers-impl.js

@@ -0,0 +1,173 @@
+"use strict";
+
+const {
+  isForbiddenRequestHeader,
+  isForbiddenResponseHeaderName,
+  isPrivilegedNoCORSRequestHeaderName,
+  isNoCORSSafelistedRequestHeaderName,
+  isNoCORSSafelistedRequestHeader
+} = require("./header-types");
+const { isHeaderName, isHeaderValue, normalizeHeaderValue } = require("./header-utils");
+const HeaderList = require("./header-list");
+
+function assertName(name) {
+  if (!isHeaderName(name)) {
+    throw new TypeError("name is invalid");
+  }
+}
+
+function assertValue(value) {
+  if (!isHeaderValue(value)) {
+    throw new TypeError("value is invalid");
+  }
+}
+
+class HeadersImpl {
+  constructor(globalObject, args) {
+    this.guard = "none";
+    this.headerList = new HeaderList();
+
+    if (args[0]) {
+      this.#fill(args[0]);
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#headers-validate
+  #validate(name, value) {
+    assertName(name);
+    assertValue(value);
+
+    switch (this.guard) {
+      case "immutable": {
+        throw new TypeError("Headers is immutable");
+      }
+      case "request": {
+        if (isForbiddenRequestHeader(name, value)) {
+          return false;
+        }
+        break;
+      }
+      case "response": {
+        if (isForbiddenResponseHeaderName(name)) {
+          return false;
+        }
+        break;
+      }
+    }
+
+    return true;
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-headers-fill
+  #fill(init) {
+    if (Array.isArray(init)) {
+      for (const header of init) {
+        if (header.length !== 2) {
+          throw new TypeError("init is invalid");
+        }
+        this.append(header[0], header[1]);
+      }
+    } else {
+      for (const [key, value] of Object.entries(init)) {
+        this.append(key, value);
+      }
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-headers-remove-privileged-no-cors-request-headers
+  #removePrivilegedNoCORSHeaders() {
+    this.headerList.delete("range");
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-append
+  append(name, value) {
+    value = normalizeHeaderValue(value);
+    if (!this.#validate(name, value)) {
+      return;
+    }
+
+    if (this.guard === "request-no-cors") {
+      let temporaryValue = this.headerList.get(name);
+      if (temporaryValue === null) {
+        temporaryValue = value;
+      } else {
+        temporaryValue += ", " + value;
+      }
+      if (!isNoCORSSafelistedRequestHeader(name, temporaryValue)) {
+        return;
+      }
+    }
+
+    this.headerList.append(name, value);
+
+    if (this.guard === "request-no-cors") {
+      this.#removePrivilegedNoCORSHeaders();
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-delete
+  delete(name) {
+    if (!this.#validate(name, "")) {
+      return;
+    }
+
+    if (this.guard === "request-no-cors" &&
+      !isNoCORSSafelistedRequestHeaderName(name) &&
+      !isPrivilegedNoCORSRequestHeaderName(name)) {
+      return;
+    }
+
+    if (!this.headerList.contains(name)) {
+      return;
+    }
+
+    this.headerList.delete(name);
+
+    if (this.guard === "request-no-cors") {
+      this.#removePrivilegedNoCORSHeaders();
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-get
+  get(name) {
+    assertName(name);
+    return this.headerList.get(name);
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
+  getSetCookie() {
+    return this.headerList.getAll("Set-Cookie") || [];
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-has
+  has(name) {
+    assertName(name);
+    return this.headerList.contains(name);
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-set
+  set(name, value) {
+    value = normalizeHeaderValue(value);
+    if (!this.#validate(name, value)) {
+      return;
+    }
+
+    if (this.guard === "request-no-cors" && !isNoCORSSafelistedRequestHeader(name, value)) {
+      return;
+    }
+
+    this.headerList.set(name, value);
+
+    if (this.guard === "request-no-cors") {
+      this.#removePrivilegedNoCORSHeaders();
+    }
+  }
+
+  * [Symbol.iterator]() {
+    for (const header of this.headerList.sortAndCombine()) {
+      yield header;
+    }
+  }
+}
+
+exports.implementation = HeadersImpl;

package/lib/jsdom/living/fetch/header-list.js

@@ -0,0 +1,158 @@
+"use strict";
+
+/**
+ * Provides utility functions for efficiently managing a collection of headers. Corresponds to
+ * https://fetch.spec.whatwg.org/#concept-header-list.
+ *
+ * Notably, unlike `Headers`, this allows retrieving the original casing of header names and does no normalization of
+ * inputs, which is important for implementing `XMLHttpRequest`. See discussions on, e.g.,
+ * https://github.com/whatwg/fetch/pull/476.
+ *
+ */
+class HeaderList {
+  // Note: we can use normal `toLowerCase()` in this class, instead of `asciiLowercase()`, because we assume all inputs
+  // are byte strings.
+
+  constructor() {
+    // Internal storage: Map<lowercaseName, {name: originalName, values: Array<value>}>
+    this._headers = new Map();
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-append
+  append(name, value) {
+    const lower = name.toLowerCase();
+    const existing = this._headers.get(lower);
+    if (existing) {
+      existing.values.push(value);
+    } else {
+      this._headers.set(lower, { name, values: [value] });
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#header-list-contains
+  contains(name) {
+    return this._headers.has(name.toLowerCase());
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-get
+  get(name) {
+    const entry = this._headers.get(name.toLowerCase());
+    if (!entry) {
+      return null;
+    }
+    return entry.values.join(", ");
+  }
+
+  // No corresponding spec algorithm, but equivalent to e.g. the steps used in
+  // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie.
+  getAll(name) {
+    const entry = this._headers.get(name.toLowerCase());
+    if (!entry) {
+      return null;
+    }
+    return entry.values;
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-delete
+  delete(name) {
+    this._headers.delete(name.toLowerCase());
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-set
+  set(name, value) {
+    const lower = name.toLowerCase();
+    this._headers.set(lower, { name, values: [value] });
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-combine
+  combine(name, value) {
+    const lower = name.toLowerCase();
+    const existing = this._headers.get(lower);
+    if (existing) {
+      existing.values[0] += ", " + value;
+    } else {
+      this._headers.set(lower, { name, values: [value] });
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+  sortAndCombine() {
+    const names = [...this._headers.keys()].sort();
+
+    const headers = [];
+    for (const name of names) {
+      const { values } = this._headers.get(name);
+      if (name === "set-cookie") {
+        for (const value of values) {
+          headers.push([name, value]);
+        }
+      } else {
+        headers.push([name, values.join(", ")]);
+      }
+    }
+
+    return headers;
+  }
+
+  /**
+   * Yields [name, value] pairs for iteration.
+   * Each header with multiple values yields multiple pairs.
+   * Preserves original casing.
+   */
+  * [Symbol.iterator]() {
+    for (const { name, values } of this._headers.values()) {
+      for (const value of values) {
+        yield [name, value];
+      }
+    }
+  }
+
+  /**
+   * Yields unique header names (with original casing).
+   */
+  * names() {
+    for (const { name } of this._headers.values()) {
+      yield name;
+    }
+  }
+
+  /**
+   * Serializes the header list to an object.
+   * Format matches undici's headers object: {name: value} or {name: [values]} for multiple values.
+   */
+  toJSON() {
+    const result = {};
+    for (const { name, values } of this._headers.values()) {
+      result[name] = values.length === 1 ? values[0] : values;
+    }
+    return result;
+  }
+
+  /**
+   * Creates a HeaderList from a headers object.
+   * Format: {name: value} or {name: [values]} for multiple values.
+   * @param {object} obj - Headers object
+   */
+  static fromJSON(obj) {
+    const list = new HeaderList();
+    for (const [name, value] of Object.entries(obj)) {
+      if (Array.isArray(value)) {
+        for (const v of value) {
+          list.append(name, v);
+        }
+      } else {
+        list.append(name, value);
+      }
+    }
+    return list;
+  }
+
+  /**
+   * Creates a copy of this HeaderList.
+   */
+  clone() {
+    return HeaderList.fromJSON(this.toJSON());
+  }
+}
+
+module.exports = HeaderList;

package/lib/jsdom/living/fetch/header-types.js

@@ -0,0 +1,205 @@
+"use strict";
+
+const { MIMEType } = require("whatwg-mimetype");
+
+// https://fetch.spec.whatwg.org/#privileged-no-cors-request-header-name
+const PRIVILEGED_NO_CORS_REQUEST = new Set(["range"]);
+function isPrivilegedNoCORSRequestHeaderName(name) {
+  return PRIVILEGED_NO_CORS_REQUEST.has(name.toLowerCase());
+}
+
+// https://fetch.spec.whatwg.org/#no-cors-safelisted-request-header-name
+const NO_CORS_SAFELISTED_REQUEST = new Set([
+  `accept`,
+  `accept-language`,
+  `content-language`,
+  `content-type`
+]);
+function isNoCORSSafelistedRequestHeaderName(name) {
+  return NO_CORS_SAFELISTED_REQUEST.has(name.toLowerCase());
+}
+
+// https://fetch.spec.whatwg.org/#forbidden-response-header-name
+const FORBIDDEN_RESPONSE = new Set(["set-cookie", "set-cookie2"]);
+function isForbiddenResponseHeaderName(name) {
+  return FORBIDDEN_RESPONSE.has(name.toLowerCase());
+}
+
+// https://fetch.spec.whatwg.org/#cors-safelisted-request-header
+// Note: name and value are already ensured by the IDL layer to be byte strings.
+const CORS_UNSAFE_BYTE = /[\x00-\x08\x0A-\x1F"():<>?@[\\\]{}\x7F]/;
+function isCORSSafelistedRequestHeader(name, value) {
+  name = name.toLowerCase();
+  switch (name) {
+    case "accept":
+      if (value.match(CORS_UNSAFE_BYTE)) {
+        return false;
+      }
+      break;
+    case "accept-language":
+    case "content-language":
+      if (value.match(/[^\x30-\x39\x41-\x5A\x61-\x7A *,\-.;=]/)) {
+        return false;
+      }
+      break;
+    case "content-type": {
+      if (value.match(CORS_UNSAFE_BYTE)) {
+        return false;
+      }
+      const mimeType = MIMEType.parse(value);
+      if (mimeType === null) {
+        return false;
+      }
+      if (
+        ![
+          "application/x-www-form-urlencoded",
+          "multipart/form-data",
+          "text/plain"
+        ].includes(mimeType.essence)
+      ) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  if (value.length > 128) {
+    return false;
+  }
+  return true;
+}
+
+// https://fetch.spec.whatwg.org/#no-cors-safelisted-request-header
+function isNoCORSSafelistedRequestHeader(name, value) {
+  if (!isNoCORSSafelistedRequestHeaderName(name)) {
+    return false;
+  }
+  return isCORSSafelistedRequestHeader(name, value);
+}
+
+const BASIC_FORBIDDEN_REQUEST_HEADERS = new Set([
+  "accept-charset",
+  "accept-encoding",
+  "access-control-request-headers",
+  "access-control-request-method",
+  "connection",
+  "content-length",
+  "cookie",
+  "cookie2",
+  "date",
+  "dnt",
+  "expect",
+  "host",
+  "keep-alive",
+  "origin",
+  "referer",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "via"
+]);
+
+const METHOD_CHECKING_FORBIDDEN_REQUEST_HEADERS = new Set([
+  "x-http-method",
+  "x-http-method-override",
+  "x-method-override"
+]);
+
+const FORBIDDEN_METHODS = new Set([
+  "connect",
+  "trace",
+  "track"
+]);
+
+// https://fetch.spec.whatwg.org/#forbidden-method
+function isForbiddenMethod(value) {
+  return FORBIDDEN_METHODS.has(value.toLowerCase());
+}
+
+// https://fetch.spec.whatwg.org/#forbidden-request-header
+function isForbiddenRequestHeader(name, value) {
+  const lowercaseName = name.toLowerCase();
+  if (BASIC_FORBIDDEN_REQUEST_HEADERS.has(lowercaseName)) {
+    return true;
+  }
+  if (lowercaseName.startsWith("proxy-") || lowercaseName.startsWith("sec-")) {
+    return true;
+  }
+
+  if (METHOD_CHECKING_FORBIDDEN_REQUEST_HEADERS.has(lowercaseName)) {
+    const parsedValues = getDecodeAndSplit(value);
+    return parsedValues.some(isForbiddenMethod);
+  }
+
+  return false;
+}
+
+// https://fetch.spec.whatwg.org/#header-value-get-decode-and-split
+function getDecodeAndSplit(input) {
+  const values = [];
+  let temporaryValue = "";
+  let position = 0;
+
+  while (true) {
+    // Collect sequence of code points that are not " or ,
+    while (position < input.length && input[position] !== "\"" && input[position] !== ",") {
+      temporaryValue += input[position++];
+    }
+
+    // If position is not past end and code point is "
+    if (position < input.length && input[position] === '"') {
+      // Inlined: collect HTTP quoted string (extract-value = false)
+      const positionStart = position++;
+      while (true) {
+        while (position < input.length && input[position] !== "\"" && input[position] !== "\\") {
+          position++;
+        }
+        if (position >= input.length) {
+          break;
+        }
+        if (input[position++] === "\\") {
+          if (position >= input.length) {
+            break;
+          }
+          position++;
+        } else {
+          break; // It was "
+        }
+      }
+      temporaryValue += input.slice(positionStart, position);
+      if (position < input.length) {
+        continue;
+      }
+    }
+
+    // Remove HTTP tab or space from start and end
+    let start = 0;
+    let end = temporaryValue.length;
+    while (start < end && (temporaryValue[start] === "\t" || temporaryValue[start] === " ")) {
+      start++;
+    }
+    while (end > start && (temporaryValue[end - 1] === "\t" || temporaryValue[end - 1] === " ")) {
+      end--;
+    }
+
+    values.push(temporaryValue.slice(start, end));
+    temporaryValue = "";
+
+    if (position >= input.length) {
+      return values;
+    }
+    // Assert: code point at position is ,
+    position++;
+  }
+}
+
+module.exports = {
+  isPrivilegedNoCORSRequestHeaderName,
+  isNoCORSSafelistedRequestHeaderName,
+  isNoCORSSafelistedRequestHeader,
+  isForbiddenRequestHeader,
+  isForbiddenResponseHeaderName,
+  isCORSSafelistedRequestHeader
+};

package/lib/jsdom/living/fetch/header-utils.js

@@ -0,0 +1,26 @@
+"use strict";
+
+// https://fetch.spec.whatwg.org/#header-name
+function isHeaderName(name) {
+  return /^[!#$%&'*+\-.^`|~\w]+$/.test(name);
+}
+
+// https://fetch.spec.whatwg.org/#header-value
+function isHeaderValue(value) {
+  return value[0] !== "\t" &&
+    value[0] !== " " &&
+    value[value.length - 1] !== "\t" &&
+    value[value.length - 1] !== " " &&
+    !/[\0\r\n]/.test(value);
+}
+
+// https://fetch.spec.whatwg.org/#concept-header-value-normalize
+function normalizeHeaderValue(potentialValue) {
+  return potentialValue.replace(/^[\n\r\t ]+|[\n\r\t ]+$/g, "");
+}
+
+module.exports = {
+  isHeaderName,
+  isHeaderValue,
+  normalizeHeaderValue
+};