@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/domparsing/parse5-adapter-serialization.js

@@ -0,0 +1,63 @@
+"use strict";
+const nodeTypes = require("../node-type");
+const { domSymbolTree } = require("../helpers/internal-constants");
+// Serialization only requires a subset of the tree adapter interface.
+
+// Tree traversing
+exports.getFirstChild = node => node.firstChild;
+
+exports.getChildNodes = node => domSymbolTree.childrenToArray(node);
+
+exports.getParentNode = node => node.parentNode;
+
+exports.getAttrList = element => {
+  const attributeList = [...element._attributeList];
+
+  if (element._isValue && attributeList.every(attr => attr.name !== "is")) {
+    attributeList.unshift({
+      name: "is",
+      namespace: null,
+      prefix: null,
+      value: element._isValue
+    });
+  }
+
+  return attributeList;
+};
+
+// Node data
+exports.getTagName = element => element._qualifiedName; // https://github.com/inikulin/parse5/issues/231
+
+exports.getNamespaceURI = element => element.namespaceURI;
+
+exports.getTextNodeContent = exports.getCommentNodeContent = node => node.data;
+
+exports.getDocumentTypeNodeName = node => node.name;
+
+exports.getDocumentTypeNodePublicId = node => node.publicId;
+
+exports.getDocumentTypeNodeSystemId = node => node.systemId;
+
+exports.getTemplateContent = templateElement => templateElement._templateContents;
+
+exports.getDocumentMode = document => document._mode;
+
+// Node types
+exports.isTextNode = node => node.nodeType === nodeTypes.TEXT_NODE;
+
+exports.isCommentNode = node => node.nodeType === nodeTypes.COMMENT_NODE;
+
+exports.isDocumentTypeNode = node => node.nodeType === nodeTypes.DOCUMENT_TYPE_NODE;
+
+exports.isElementNode = node => node.nodeType === nodeTypes.ELEMENT_NODE;
+
+// Source code location
+exports.setNodeSourceCodeLocation = (node, location) => {
+  node.sourceCodeLocation = location;
+};
+
+exports.getNodeSourceCodeLocation = node => node.sourceCodeLocation;
+
+exports.updateNodeSourceCodeLocation = (node, endLocation) => {
+  Object.assign(node.sourceCodeLocation, endLocation);
+};

package/lib/jsdom/living/domparsing/serialization.js

@@ -0,0 +1,36 @@
+"use strict";
+
+const produceXMLSerialization = require("w3c-xmlserializer");
+const parse5 = require("parse5");
+const DOMException = require("../../../generated/idl/DOMException");
+const { domSymbolTree } = require("../helpers/internal-constants");
+const utils = require("../../../generated/idl/utils");
+const treeAdapter = require("./parse5-adapter-serialization");
+const NODE_TYPE = require("../node-type");
+
+module.exports.fragmentSerialization = (node, { outer, requireWellFormed, globalObject }) => {
+  const contextDocument =
+    node.nodeType === NODE_TYPE.DOCUMENT_NODE ? node : node._ownerDocument;
+  if (contextDocument._parsingMode === "html") {
+    const config = {
+      ...contextDocument._parseOptions,
+      treeAdapter
+    };
+    return outer ? parse5.serializeOuter(node, config) : parse5.serialize(node, config);
+  }
+
+  const childNodes = outer ? [node] : domSymbolTree.childrenToArray(node);
+
+  try {
+    let serialized = "";
+    for (let i = 0; i < childNodes.length; ++i) {
+      serialized += produceXMLSerialization(
+        utils.wrapperForImpl(childNodes[i]),
+        { requireWellFormed }
+      );
+    }
+    return serialized;
+  } catch (e) {
+    throw DOMException.create(globalObject, [e.message, "InvalidStateError"]);
+  }
+};

package/lib/jsdom/living/encoding/TextDecoder-impl.js

@@ -0,0 +1,25 @@
+"use strict";
+const { TextDecoder } = require("@exodus/bytes/encoding.js");
+
+// A thin wrapper is needed since there are constructor arguments, which mismatches webidl2js's assumed pattern.
+exports.implementation = class TextDecoderImpl {
+  constructor(globalObject, [label, options]) {
+    this._innerImpl = new TextDecoder(label, options);
+  }
+
+  decode(input, options) {
+    return this._innerImpl.decode(input, options);
+  }
+
+  get encoding() {
+    return this._innerImpl.encoding;
+  }
+
+  get fatal() {
+    return this._innerImpl.fatal;
+  }
+
+  get ignoreBOM() {
+    return this._innerImpl.ignoreBOM;
+  }
+};

package/lib/jsdom/living/encoding/TextEncoder-impl.js

@@ -0,0 +1,26 @@
+"use strict";
+const { TextEncoder } = require("@exodus/bytes/encoding.js");
+const { copyToArrayBufferInTargetRealm } = require("../helpers/binary-data");
+
+// We can't directly use the native TextEncoder as the impl class, because its encode() method returns a Uint8Array in
+// the Node.js realm. We need to wrap it so that encode() returns a Uint8Array in the jsdom window's realm, so that
+// `result.buffer instanceof ArrayBuffer` works correctly in user code.
+
+const encoder = new TextEncoder();
+
+exports.implementation = class TextEncoderImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+    this.encoding = "utf-8";
+  }
+
+  encode(input) {
+    const encoded = encoder.encode(input);
+    const ab = copyToArrayBufferInTargetRealm(encoded.buffer, this._globalObject);
+    return new this._globalObject.Uint8Array(ab);
+  }
+
+  encodeInto(source, destination) {
+    return encoder.encodeInto(source, destination);
+  }
+};

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

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

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

@@ -0,0 +1,14 @@
+"use strict";
+const EventImpl = require("./Event-impl").implementation;
+
+class BlobEventImpl extends EventImpl {}
+
+// Cannot use the usual pattern since `data` is required.
+BlobEventImpl.defaultInit = {
+  __proto__: null,
+  timecode: 0
+};
+
+module.exports = {
+  implementation: BlobEventImpl
+};

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

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

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const UIEventImpl = require("./UIEvent-impl").implementation;
+const CompositionEventInit = require("../../../generated/idl/CompositionEventInit");
+
+class CompositionEventImpl extends UIEventImpl {
+  initCompositionEvent(type, bubbles, cancelable, view, data) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, 0);
+    this.data = data;
+  }
+}
+CompositionEventImpl.defaultInit = CompositionEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: CompositionEventImpl
+};

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

@@ -0,0 +1,21 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const CustomEventInit = require("../../../generated/idl/CustomEventInit");
+
+class CustomEventImpl extends EventImpl {
+  initCustomEvent(type, bubbles, cancelable, detail) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.detail = detail;
+  }
+}
+CustomEventImpl.defaultInit = CustomEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: CustomEventImpl
+};

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

@@ -0,0 +1,49 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+const { implementation: DeviceMotionEventAccelerationImpl } =
+  require("../deviceorientation/DeviceMotionEventAcceleration-impl");
+const { implementation: DeviceMotionEventRotationRateImpl } =
+  require("../deviceorientation/DeviceMotionEventRotationRate-impl");
+
+class DeviceMotionEventImpl extends EventImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    const eventInitDict = args[1];
+
+    this.acceleration = null;
+    if (eventInitDict?.acceleration) {
+      const accelImpl = new DeviceMotionEventAccelerationImpl(globalObject, [], {});
+      accelImpl.x = eventInitDict.acceleration.x;
+      accelImpl.y = eventInitDict.acceleration.y;
+      accelImpl.z = eventInitDict.acceleration.z;
+      this.acceleration = accelImpl;
+    }
+
+    this.accelerationIncludingGravity = null;
+    if (eventInitDict?.accelerationIncludingGravity) {
+      const accelGImpl = new DeviceMotionEventAccelerationImpl(globalObject, [], {});
+      accelGImpl.x = eventInitDict.accelerationIncludingGravity.x;
+      accelGImpl.y = eventInitDict.accelerationIncludingGravity.y;
+      accelGImpl.z = eventInitDict.accelerationIncludingGravity.z;
+      this.accelerationIncludingGravity = accelGImpl;
+    }
+
+    this.rotationRate = null;
+    if (eventInitDict?.rotationRate) {
+      const rotImpl = new DeviceMotionEventRotationRateImpl(globalObject, [], {});
+      rotImpl.alpha = eventInitDict.rotationRate.alpha;
+      rotImpl.beta = eventInitDict.rotationRate.beta;
+      rotImpl.gamma = eventInitDict.rotationRate.gamma;
+      this.rotationRate = rotImpl;
+    }
+
+    this.interval = eventInitDict?.interval ?? 0;
+  }
+}
+DeviceMotionEventImpl.defaultInit = Object.create(null);
+
+module.exports = {
+  implementation: DeviceMotionEventImpl
+};

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

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

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

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

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

@@ -0,0 +1,195 @@
+"use strict";
+
+const idlUtils = require("../../../generated/idl/utils");
+const EventInit = require("../../../generated/idl/EventInit");
+
+class EventImpl {
+  constructor(globalObject, args, privateData) {
+    const [type, eventInitDict = this.constructor.defaultInit] = args;
+
+    this.type = type;
+
+    this.bubbles = false;
+    this.cancelable = false;
+    for (const key in eventInitDict) {
+      this[key] = eventInitDict[key];
+    }
+    for (const key in this.constructor.defaultInit) {
+      if (!(key in eventInitDict)) {
+        this[key] = this.constructor.defaultInit[key];
+      }
+    }
+
+    this.target = null;
+    this.currentTarget = null;
+    this.eventPhase = 0;
+
+    this._globalObject = globalObject;
+    this._initializedFlag = true;
+    this._stopPropagationFlag = false;
+    this._stopImmediatePropagationFlag = false;
+    this._canceledFlag = false;
+    this._inPassiveListenerFlag = false;
+    this._dispatchFlag = false;
+    this._path = [];
+
+    this.isTrusted = privateData.isTrusted || false;
+    this.timeStamp = Date.now();
+  }
+
+  // https://dom.spec.whatwg.org/#set-the-canceled-flag
+  _setTheCanceledFlag() {
+    if (this.cancelable && !this._inPassiveListenerFlag) {
+      this._canceledFlag = true;
+    }
+  }
+
+  get srcElement() {
+    return this.target;
+  }
+
+  get returnValue() {
+    return !this._canceledFlag;
+  }
+
+  set returnValue(v) {
+    if (v === false) {
+      this._setTheCanceledFlag();
+    }
+  }
+
+  get defaultPrevented() {
+    return this._canceledFlag;
+  }
+
+  stopPropagation() {
+    this._stopPropagationFlag = true;
+  }
+
+  get cancelBubble() {
+    return this._stopPropagationFlag;
+  }
+
+  set cancelBubble(v) {
+    if (v) {
+      this._stopPropagationFlag = true;
+    }
+  }
+
+  stopImmediatePropagation() {
+    this._stopPropagationFlag = true;
+    this._stopImmediatePropagationFlag = true;
+  }
+
+  preventDefault() {
+    this._setTheCanceledFlag();
+  }
+
+  // https://dom.spec.whatwg.org/#dom-event-composedpath
+  // Current implementation is based of https://whatpr.org/dom/699.html#dom-event-composedpath
+  // due to a bug in composed path implementation https://github.com/whatwg/dom/issues/684
+  composedPath() {
+    const composedPath = [];
+
+    const { currentTarget, _path: path } = this;
+
+    if (path.length === 0) {
+      return composedPath;
+    }
+
+    composedPath.push(currentTarget);
+
+    let currentTargetIndex = 0;
+    let currentTargetHiddenSubtreeLevel = 0;
+
+    for (let index = path.length - 1; index >= 0; index--) {
+      const { item, rootOfClosedTree, slotInClosedTree } = path[index];
+
+      if (rootOfClosedTree) {
+        currentTargetHiddenSubtreeLevel++;
+      }
+
+      if (item === idlUtils.implForWrapper(currentTarget)) {
+        currentTargetIndex = index;
+        break;
+      }
+
+      if (slotInClosedTree) {
+        currentTargetHiddenSubtreeLevel--;
+      }
+    }
+
+    let currentHiddenLevel = currentTargetHiddenSubtreeLevel;
+    let maxHiddenLevel = currentTargetHiddenSubtreeLevel;
+
+    for (let i = currentTargetIndex - 1; i >= 0; i--) {
+      const { item, rootOfClosedTree, slotInClosedTree } = path[i];
+
+      if (rootOfClosedTree) {
+        currentHiddenLevel++;
+      }
+
+      if (currentHiddenLevel <= maxHiddenLevel) {
+        composedPath.unshift(idlUtils.wrapperForImpl(item));
+      }
+
+      if (slotInClosedTree) {
+        currentHiddenLevel--;
+        if (currentHiddenLevel < maxHiddenLevel) {
+          maxHiddenLevel = currentHiddenLevel;
+        }
+      }
+    }
+
+    currentHiddenLevel = currentTargetHiddenSubtreeLevel;
+    maxHiddenLevel = currentTargetHiddenSubtreeLevel;
+
+    for (let index = currentTargetIndex + 1; index < path.length; index++) {
+      const { item, rootOfClosedTree, slotInClosedTree } = path[index];
+
+      if (slotInClosedTree) {
+        currentHiddenLevel++;
+      }
+
+      if (currentHiddenLevel <= maxHiddenLevel) {
+        composedPath.push(idlUtils.wrapperForImpl(item));
+      }
+
+      if (rootOfClosedTree) {
+        currentHiddenLevel--;
+        if (currentHiddenLevel < maxHiddenLevel) {
+          maxHiddenLevel = currentHiddenLevel;
+        }
+      }
+    }
+
+    return composedPath;
+  }
+
+  _initialize(type, bubbles, cancelable) {
+    this.type = type;
+    this._initializedFlag = true;
+
+    this._stopPropagationFlag = false;
+    this._stopImmediatePropagationFlag = false;
+    this._canceledFlag = false;
+
+    this.isTrusted = false;
+    this.target = null;
+    this.bubbles = bubbles;
+    this.cancelable = cancelable;
+  }
+
+  initEvent(type, bubbles, cancelable) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this._initialize(type, bubbles, cancelable);
+  }
+}
+EventImpl.defaultInit = EventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: EventImpl
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+
+// This mixin doesn't have an IDL equivalent, but since MouseEvent and KeyboardEvent implement getModifierState() the
+// same way, its implementation is shared here.
+
+class EventModifierMixinImpl {
+  // Event's constructor assumes all options correspond to IDL attributes with the same names, and sets them on `this`.
+  // That is not the case for these modifier boolean options, but since the options are set on `this` anyway we'll
+  // access them that way. The spec doesn't say much about the case where keyArg is not one of the valid ones
+  // (https://w3c.github.io/uievents-key/#keys-modifier), but at least Chrome returns false for invalid modifiers. Since
+  // these invalid modifiers will be undefined on `this` (thus `false` after casting it to boolean), we don't need to do
+  // extra checking for validity.
+  getModifierState(keyArg) {
+    if (keyArg === "Control") {
+      return Boolean(this.ctrlKey);
+    }
+    if (["Alt", "Meta", "Shift"].includes(keyArg)) {
+      return Boolean(this[`${keyArg.toLowerCase()}Key`]);
+    }
+    return Boolean(this[`modifier${keyArg}`]);
+  }
+}
+
+exports.implementation = EventModifierMixinImpl;