@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/nodes/HTMLElement-impl.js

@@ -0,0 +1,211 @@
+"use strict";
+const { mixin } = require("../../utils");
+const ElementImpl = require("./Element-impl").implementation;
+const DOMException = require("../../../generated/idl/DOMException");
+const PointerEvent = require("../../../generated/idl/PointerEvent");
+const ElementInternals = require("../../../generated/idl/ElementInternals");
+const ElementCSSInlineStyleImpl = require("./ElementCSSInlineStyle-impl").implementation;
+const GlobalEventHandlersImpl = require("./GlobalEventHandlers-impl").implementation;
+const HTMLOrSVGElementImpl = require("./HTMLOrSVGElement-impl").implementation;
+const { firstChildWithLocalName } = require("../helpers/traversal");
+const { isDisabled } = require("../helpers/form-controls");
+const { fireAnEvent } = require("../helpers/events");
+const { asciiLowercase } = require("../helpers/strings");
+const { lookupCEDefinition } = require("../helpers/custom-elements");
+
+class HTMLElementImpl extends ElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+    this._initHTMLOrSVGElement();
+    this._initElementCSSInlineStyle();
+    this._initGlobalEvents();
+
+    this._clickInProgress = false;
+
+    // <summary> uses HTMLElement and has activation behavior
+    this._hasActivationBehavior = this._localName === "summary";
+
+    // https://html.spec.whatwg.org/#attached-internals
+    this._attachedInternals = null;
+  }
+
+  _activationBehavior() {
+    const parent = this.parentNode;
+    if (parent && parent._localName === "details" &&
+        this === firstChildWithLocalName(parent, "summary")) {
+      if (parent.hasAttributeNS(null, "open")) {
+        parent.removeAttributeNS(null, "open");
+      } else {
+        parent.setAttributeNS(null, "open", "");
+      }
+    }
+  }
+
+  // https://html.spec.whatwg.org/multipage/dom.html#the-translate-attribute
+  get translate() {
+    const translateAttr = this.getAttributeNS(null, "translate");
+    const translateAttrString = asciiLowercase(translateAttr || "");
+
+    if (translateAttrString === "yes" || (translateAttr && translateAttrString === "")) {
+      return true;
+    } else if (translateAttrString === "no") {
+      return false;
+    }
+
+    if (this === this.ownerDocument.documentElement) {
+      return true;
+    }
+
+    return this.parentElement && this.parentElement.translate;
+  }
+  set translate(value) {
+    if (value === true) {
+      this.setAttributeNS(null, "translate", "yes");
+    } else {
+      this.setAttributeNS(null, "translate", "no");
+    }
+  }
+
+  click() {
+    // https://html.spec.whatwg.org/multipage/interaction.html#dom-click
+    // https://html.spec.whatwg.org/multipage/webappapis.html#fire-a-synthetic-pointer-event
+
+    if (isDisabled(this)) {
+      return;
+    }
+
+    if (this._clickInProgress) {
+      return;
+    }
+
+    this._clickInProgress = true;
+
+    // https://github.com/whatwg/html/issues/4452
+    // https://github.com/whatwg/html/issues/11236
+    fireAnEvent("click", this, PointerEvent, {
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+      isTrusted: false,
+      pointerId: -1,
+      view: this.ownerDocument.defaultView
+    });
+
+    this._clickInProgress = false;
+  }
+
+  get draggable() {
+    const attributeValue = asciiLowercase(this.getAttributeNS(null, "draggable") || "");
+
+    if (attributeValue === "true") {
+      return true;
+    } else if (attributeValue === "false") {
+      return false;
+    }
+
+    return this._localName === "img" || (this._localName === "a" && this.hasAttributeNS(null, "href"));
+  }
+  set draggable(value) {
+    this.setAttributeNS(null, "draggable", String(value));
+  }
+
+  get dir() {
+    let dirValue = this.getAttributeNS(null, "dir");
+    if (dirValue !== null) {
+      dirValue = dirValue.toLowerCase();
+
+      if (["ltr", "rtl", "auto"].includes(dirValue)) {
+        return dirValue;
+      }
+    }
+    return "";
+  }
+  set dir(value) {
+    this.setAttributeNS(null, "dir", value);
+  }
+
+  // https://html.spec.whatwg.org/#dom-attachinternals
+  attachInternals() {
+    if (this._isValue !== null) {
+      throw DOMException.create(this._globalObject, [
+        "Unable to attach ElementInternals to a customized built-in element.",
+        "NotSupportedError"
+      ]);
+    }
+
+    const definition = lookupCEDefinition(this._ownerDocument, this._namespaceURI, this._localName, null);
+
+    if (definition === null) {
+      throw DOMException.create(this._globalObject, [
+        "Unable to attach ElementInternals to non-custom elements.",
+        "NotSupportedError"
+      ]);
+    }
+
+    if (definition.disableInternals === true) {
+      throw DOMException.create(this._globalObject, [
+        "ElementInternals is disabled by disabledFeature static field.",
+        "NotSupportedError"
+      ]);
+    }
+
+    if (this._attachedInternals !== null) {
+      throw DOMException.create(this._globalObject, [
+        "ElementInternals for the specified element was already attached.",
+        "NotSupportedError"
+      ]);
+    }
+
+    if (this._ceState !== "precustomized" && this._ceState !== "custom") {
+      throw DOMException.create(this._globalObject, [
+        "The attachInternals() function cannot be called prior to the execution of the custom element constructor.",
+        "NotSupportedError"
+      ]);
+    }
+
+    this._attachedInternals = ElementInternals.createImpl(this._globalObject, [], { targetElement: this });
+
+    return this._attachedInternals;
+  }
+
+  // Keep in sync with SVGElement. https://github.com/jsdom/jsdom/issues/2599
+  _attrModified(name, value, oldValue) {
+    if (name === "style" && value !== oldValue && !this._settingCssText) {
+      this._settingCssText = true;
+      this._style.cssText = value;
+      this._settingCssText = false;
+    } else if (name.startsWith("on")) {
+      this._globalEventChanged(name.substring(2));
+    }
+
+    super._attrModified(name, value, oldValue);
+  }
+
+  get offsetParent() {
+    return null;
+  }
+
+  get offsetTop() {
+    return 0;
+  }
+
+  get offsetLeft() {
+    return 0;
+  }
+
+  get offsetWidth() {
+    return 0;
+  }
+
+  get offsetHeight() {
+    return 0;
+  }
+}
+
+mixin(HTMLElementImpl.prototype, ElementCSSInlineStyleImpl.prototype);
+mixin(HTMLElementImpl.prototype, GlobalEventHandlersImpl.prototype);
+mixin(HTMLElementImpl.prototype, HTMLOrSVGElementImpl.prototype);
+
+module.exports = {
+  implementation: HTMLElementImpl
+};

package/lib/jsdom/living/nodes/HTMLEmbedElement-impl.js

@@ -0,0 +1,8 @@
+"use strict";
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLEmbedElementImpl extends HTMLElementImpl {}
+
+module.exports = {
+  implementation: HTMLEmbedElementImpl
+};

package/lib/jsdom/living/nodes/HTMLFieldSetElement-impl.js

@@ -0,0 +1,43 @@
+"use strict";
+const HTMLCollection = require("../../../generated/idl/HTMLCollection");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const DefaultConstraintValidationImpl =
+  require("../constraint-validation/DefaultConstraintValidation-impl").implementation;
+const { formOwner } = require("../helpers/form-controls");
+const { mixin } = require("../../utils");
+const { descendantsByLocalNames } = require("../helpers/traversal");
+
+const listedElements = new Set(["button", "fieldset", "input", "object", "output", "select", "textarea"]);
+
+class HTMLFieldSetElementImpl extends HTMLElementImpl {
+  constructor(globalObject, args, privateData) {
+    super(globalObject, args, privateData);
+
+    this._customValidityErrorMessage = "";
+  }
+
+  get elements() {
+    return HTMLCollection.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => descendantsByLocalNames(this, listedElements)
+    });
+  }
+
+  get form() {
+    return formOwner(this);
+  }
+
+  get type() {
+    return "fieldset";
+  }
+
+  _barredFromConstraintValidationSpecialization() {
+    return true;
+  }
+}
+
+mixin(HTMLFieldSetElementImpl.prototype, DefaultConstraintValidationImpl.prototype);
+
+module.exports = {
+  implementation: HTMLFieldSetElementImpl
+};

package/lib/jsdom/living/nodes/HTMLFontElement-impl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+
+class HTMLFontElementImpl extends HTMLElementImpl { }
+
+module.exports = {
+  implementation: HTMLFontElementImpl
+};

package/lib/jsdom/living/nodes/HTMLFormControlsCollection-impl.js

@@ -0,0 +1,33 @@
+"use strict";
+
+const HTMLCollectionImpl = require("./HTMLCollection-impl").implementation;
+const RadioNodeList = require("../../../generated/idl/RadioNodeList");
+
+exports.implementation = class HTMLFormControlsCollectionImpl extends HTMLCollectionImpl {
+  namedItem(name) {
+    if (name === "") {
+      return null;
+    }
+
+    this._update();
+
+    const nodeList = RadioNodeList.createImpl(this._globalObject, [], {
+      element: this,
+      query: () => this._list.filter(
+        e => e.getAttributeNS(null, "id") === name || e.getAttributeNS(null, "name") === name
+      )
+    });
+
+    switch (nodeList.length) {
+      case 0: {
+        return null;
+      }
+      case 1: {
+        return nodeList.item(0);
+      }
+      default: {
+        return nodeList;
+      }
+    }
+  }
+};

package/lib/jsdom/living/nodes/HTMLFormElement-impl.js

@@ -0,0 +1,248 @@
+"use strict";
+
+const idlUtils = require("../../../generated/idl/utils.js");
+const DOMException = require("../../../generated/idl/DOMException");
+const { serializeURL } = require("whatwg-url");
+const HTMLElementImpl = require("./HTMLElement-impl").implementation;
+const { domSymbolTree } = require("../helpers/internal-constants");
+const { fireAnEvent } = require("../helpers/events");
+const { formOwner, isListed, isSubmittable, isSubmitButton } = require("../helpers/form-controls");
+const HTMLFormControlsCollection = require("../../../generated/idl/HTMLFormControlsCollection");
+const { notImplementedMethod } = require("../../browser/not-implemented");
+const SubmitEvent = require("../../../generated/idl/SubmitEvent");
+
+const encTypes = new Set([
+  "application/x-www-form-urlencoded",
+  "multipart/form-data",
+  "text/plain"
+]);
+
+const methods = new Set([
+  "get",
+  "post",
+  "dialog"
+]);
+
+const constraintValidationPositiveResult = Symbol("positive");
+const constraintValidationNegativeResult = Symbol("negative");
+
+class HTMLFormElementImpl extends HTMLElementImpl {
+  _descendantAdded(parent, child) {
+    const form = this;
+    for (const el of domSymbolTree.treeIterator(child)) {
+      if (typeof el._changedFormOwner === "function") {
+        el._changedFormOwner(form);
+      }
+    }
+
+    super._descendantAdded(parent, child);
+  }
+
+  _descendantRemoved(parent, child) {
+    for (const el of domSymbolTree.treeIterator(child)) {
+      if (typeof el._changedFormOwner === "function") {
+        el._changedFormOwner(null);
+      }
+    }
+
+    super._descendantRemoved(parent, child);
+  }
+
+  _getSubmittableElementNodes() {
+    return domSymbolTree.treeToArray(this.getRootNode({}), {
+      filter: node => {
+        if (!isSubmittable(node)) {
+          return false;
+        }
+
+        return formOwner(node) === this;
+      }
+    });
+  }
+
+  _getElementNodes() {
+    return domSymbolTree.treeToArray(this.getRootNode({}), {
+      filter: node => {
+        if (!isListed(node) || (node._localName === "input" && node.type === "image")) {
+          return false;
+        }
+
+        return formOwner(node) === this;
+      }
+    });
+  }
+
+  // https://html.spec.whatwg.org/multipage/forms.html#dom-form-elements
+  get elements() {
+    return HTMLFormControlsCollection.createImpl(this._globalObject, [], {
+      element: this.getRootNode({}),
+      query: () => this._getElementNodes()
+    });
+  }
+
+  [idlUtils.indexedGet](index) {
+    return this._getElementNodes()[index] || null;
+  }
+
+  get [idlUtils.supportedPropertyIndices]() {
+    return Object.keys(this._getElementNodes());
+  }
+
+  get length() {
+    return this.elements.length;
+  }
+
+  _doRequestSubmit(submitter) {
+    if (!this.isConnected) {
+      return;
+    }
+
+    this.requestSubmit(submitter);
+  }
+
+  submit() {
+    notImplementedMethod(this._ownerDocument._defaultView, "HTMLFormElement", "submit");
+  }
+
+  requestSubmit(submitter = null) {
+    if (submitter !== null) {
+      if (!isSubmitButton(submitter)) {
+        throw new TypeError("The specified element is not a submit button");
+      }
+      if (submitter.form !== this) {
+        throw DOMException.create(this._globalObject, [
+          "The specified element is not owned by this form element",
+          "NotFoundError"
+        ]);
+      }
+    }
+
+    // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#form-submission-algorithm
+    // Step 6.3: if form doesn't have the 'novalidate' attribute, validate it and abort submission if form is invalid
+    if (!this.hasAttributeNS(null, "novalidate") && !this.reportValidity()) {
+      return;
+    }
+
+    if (!fireAnEvent("submit", this, SubmitEvent, { bubbles: true, cancelable: true, submitter })) {
+      return;
+    }
+
+    notImplementedMethod(this._ownerDocument._defaultView, "HTMLFormElement", "requestSubmit");
+  }
+
+  _doReset() {
+    if (!this.isConnected) {
+      return;
+    }
+
+    this.reset();
+  }
+
+  reset() {
+    if (!fireAnEvent("reset", this, undefined, { bubbles: true, cancelable: true })) {
+      return;
+    }
+
+    for (const el of this.elements) {
+      if (typeof el._formReset === "function") {
+        el._formReset();
+      }
+    }
+  }
+
+  get method() {
+    let method = this.getAttributeNS(null, "method");
+    if (method) {
+      method = method.toLowerCase();
+    }
+
+    if (methods.has(method)) {
+      return method;
+    }
+    return "get";
+  }
+
+  set method(V) {
+    this.setAttributeNS(null, "method", V);
+  }
+
+  get enctype() {
+    let type = this.getAttributeNS(null, "enctype");
+    if (type) {
+      type = type.toLowerCase();
+    }
+
+    if (encTypes.has(type)) {
+      return type;
+    }
+    return "application/x-www-form-urlencoded";
+  }
+
+  set enctype(V) {
+    this.setAttributeNS(null, "enctype", V);
+  }
+
+  get action() {
+    const attributeValue = this.getAttributeNS(null, "action");
+    if (attributeValue === null || attributeValue === "") {
+      return this._ownerDocument.URL;
+    }
+    const urlRecord = this._ownerDocument.encodingParseAURL(attributeValue);
+    if (urlRecord === null) {
+      return attributeValue;
+    }
+    return serializeURL(urlRecord);
+  }
+
+  set action(V) {
+    this.setAttributeNS(null, "action", V);
+  }
+
+  // If the checkValidity() method is invoked, the user agent must statically validate the
+  // constraints of the form element, and return true if the constraint validation returned
+  // a positive result, and false if it returned a negative result.
+  checkValidity() {
+    return this._staticallyValidateConstraints().result === constraintValidationPositiveResult;
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#interactively-validate-the-constraints
+  reportValidity() {
+    return this.checkValidity();
+  }
+
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#statically-validate-the-constraints
+  _staticallyValidateConstraints() {
+    const controls = [];
+    for (const el of this.elements) {
+      if (el.form === this && isSubmittable(el)) {
+        controls.push(el);
+      }
+    }
+
+    const invalidControls = [];
+
+    for (const control of controls) {
+      if (control._isCandidateForConstraintValidation() && !control._satisfiesConstraints()) {
+        invalidControls.push(control);
+      }
+    }
+
+    if (invalidControls.length === 0) {
+      return { result: constraintValidationPositiveResult };
+    }
+
+    const unhandledInvalidControls = [];
+    for (const invalidControl of invalidControls) {
+      const notCancelled = fireAnEvent("invalid", invalidControl, undefined, { cancelable: true });
+      if (notCancelled) {
+        unhandledInvalidControls.push(invalidControl);
+      }
+    }
+
+    return { result: constraintValidationNegativeResult, unhandledInvalidControls };
+  }
+}
+
+module.exports = {
+  implementation: HTMLFormElementImpl
+};