@depup/jsdom 28.1.0-depup.1

package/lib/jsdom/living/window-properties.js

@@ -0,0 +1,241 @@
+"use strict";
+const idlUtils = require("../../generated/idl/utils.js");
+const HTMLCollection = require("../../generated/idl/HTMLCollection.js");
+const { HTML_NS } = require("./helpers/namespaces.js");
+const { nodeRoot } = require("./helpers/node.js");
+const { treeOrderSorter } = require("../utils.js");
+
+// We count iframe/frame here too even though it's not in the relevant part of the spec because we still need to track
+// named iframes/frames, and we'll process the element -> WindowProxy work as special cases.
+const nameAttributeElementLocalNames = new Set(["embed", "form", "img", "object", "iframe", "frame"]);
+
+const trackers = new WeakMap(); // WeakMap<WindowProperties, Map<string, Set<Element>>>
+
+function upsert(map, key, value) {
+  let set = map.get(key);
+  if (!set) {
+    set = new Set();
+    map.set(key, set);
+  }
+  set.add(value);
+}
+
+function remove(map, key, value) {
+  const set = map.get(key);
+  if (set) {
+    set.delete(value);
+    if (set.size === 0) {
+      map.delete(key);
+    }
+  }
+}
+
+function getNamedObject(window, name) {
+  const tracker = trackers.get(window);
+  const set = tracker.get(name);
+  if (set === undefined) {
+    return undefined;
+  }
+
+  const sorted = [...set].sort(treeOrderSorter);
+  for (const element of sorted) {
+    if (element.localName === "iframe" || element.localName === "frame") {
+      const { contentWindow } = element;
+      if (contentWindow && element.getAttributeNS(null, "name") === name) {
+        return contentWindow;
+      }
+    }
+  }
+
+  if (set.size === 1) {
+    return idlUtils.wrapperForImpl(set.values().next().value);
+  }
+
+  return HTMLCollection.create(window, [], {
+    element: idlUtils.implForWrapper(window._document).documentElement,
+    query() {
+      // Do *not* reuse `sorted` or `set` from above. We need to re-get and re-iterate the set each time because it
+      // might have changed due to elements being attached, removed, or having their names changed!
+      const currentSet = tracker.get(name);
+      return [...currentSet].sort(treeOrderSorter);
+    }
+  });
+}
+
+exports.elementAttached = element => {
+  const window = element._ownerDocument._globalObject;
+  if (!window) {
+    return;
+  }
+
+  if (element.namespaceURI !== HTML_NS) {
+    return;
+  }
+  if (nodeRoot(element) !== element._ownerDocument) {
+    return;
+  }
+
+  const tracker = trackers.get(window);
+
+  if (nameAttributeElementLocalNames.has(element.localName)) {
+    const nameAttr = element.getAttributeNS(null, "name");
+    if (nameAttr !== null) {
+      upsert(tracker, nameAttr, element);
+    }
+  }
+
+  const idAttr = element.getAttributeNS(null, "id");
+  if (idAttr !== null) {
+    upsert(tracker, idAttr, element);
+  }
+};
+
+exports.elementDetached = element => {
+  const window = element._ownerDocument._globalObject;
+  if (!window) {
+    return;
+  }
+
+  if (element.namespaceURI !== HTML_NS) {
+    return;
+  }
+
+  const tracker = trackers.get(window);
+
+  const idAttr = element.getAttributeNS(null, "id");
+  if (idAttr !== null) {
+    remove(tracker, idAttr, element);
+  }
+
+  const nameAttr = element.getAttributeNS(null, "name");
+  if (nameAttr !== null) {
+    remove(tracker, nameAttr, element);
+  }
+};
+
+exports.elementAttributeModified = (element, attributeName, value, oldValue) => {
+  const window = element._ownerDocument._globalObject;
+  if (!window) {
+    return;
+  }
+
+  if (element.namespaceURI !== HTML_NS) {
+    return;
+  }
+  if (nodeRoot(element) !== element._ownerDocument) {
+    return;
+  }
+
+  const tracker = trackers.get(window);
+
+  // TODO what about attribute namespace?
+
+  if (attributeName === "id") {
+    if (element.getAttributeNS(null, "name") !== oldValue) {
+      remove(tracker, oldValue, element);
+    }
+    if (value !== null) {
+      upsert(tracker, value, element);
+    }
+  } else if (attributeName === "name") {
+    if (nameAttributeElementLocalNames.has(element.localName)) {
+      if (element.getAttributeNS(null, "id") !== oldValue) {
+        remove(tracker, oldValue, element);
+      }
+      if (value !== null) {
+        upsert(tracker, value, element);
+      }
+    }
+  }
+};
+
+exports.create = (eventTargetPrototype, window) => {
+  const windowProperties = Object.create(eventTargetPrototype, {
+    [Symbol.toStringTag]: {
+      value: "WindowProperties",
+      configurable: true
+    }
+  });
+
+  const windowPropertiesProxy = new Proxy(windowProperties, {
+    getOwnPropertyDescriptor(target, property) {
+      if (typeof property === "symbol") {
+        return Reflect.getOwnPropertyDescriptor(target, property);
+      }
+
+      // Named property visibility algorithm check, modified as discused in
+      // https://github.com/whatwg/webidl/issues/607.
+      let targetObj = Object.getPrototypeOf(target);
+      while (targetObj !== null) {
+        if (Object.hasOwn(targetObj, property)) {
+          return Reflect.getOwnPropertyDescriptor(target, property);
+        }
+
+        targetObj = Object.getPrototypeOf(targetObj);
+      }
+
+      const value = getNamedObject(window, property);
+      if (value) {
+        return {
+          value,
+          enumerable: false, // Window is [LegacyUnenumerableNamedProperties]
+          writable: true,
+          configurable: true
+        };
+      }
+
+      return Reflect.getOwnPropertyDescriptor(target, property);
+    },
+    has(target, property) {
+      if (typeof property === "symbol") {
+        return Reflect.has(target, property);
+      }
+
+      const desc = this.getOwnPropertyDescriptor(target, property);
+      if (desc !== undefined) {
+        return true;
+      }
+
+      const parent = Object.getPrototypeOf(target);
+      return Reflect.has(parent, property);
+    },
+    get(target, property, receiver) {
+      if (typeof property === "symbol") {
+        return Reflect.get(target, property, receiver);
+      }
+
+      const desc = this.getOwnPropertyDescriptor(target, property);
+      if (desc === undefined) {
+        const parent = Object.getPrototypeOf(target);
+        return Reflect.get(parent, property, receiver);
+      }
+
+      // Named properties object only has data properties.
+      return desc.value;
+    },
+    set(target, property, value, receiver) {
+      if (typeof property === "symbol") {
+        return Reflect.set(target, property, value, receiver);
+      }
+
+      const ownDesc = this.getOwnPropertyDescriptor(target, property);
+      return idlUtils.ordinarySetWithOwnDescriptor(target, property, value, receiver, ownDesc);
+    },
+    defineProperty() {
+      return false;
+    },
+    deleteProperty() {
+      return false;
+    },
+    setPrototypeOf() {
+      throw new TypeError("Immutable prototype object WindowProperties cannot have its prototype set.");
+    },
+    preventExtensions() {
+      return false;
+    }
+  });
+
+  trackers.set(window, new Map());
+
+  return windowPropertiesProxy;
+};

package/lib/jsdom/living/xhr/FormData-impl.js

@@ -0,0 +1,191 @@
+"use strict";
+const DOMException = require("../../../generated/idl/DOMException");
+const idlUtils = require("../../../generated/idl/utils");
+const { closest } = require("../helpers/traversal");
+const { isDisabled, isButton, isSubmitButton } = require("../helpers/form-controls");
+const Blob = require("../../../generated/idl/Blob.js");
+const File = require("../../../generated/idl/File.js");
+const conversions = require("webidl-conversions");
+
+exports.implementation = class FormDataImpl {
+  constructor(globalObject, args) {
+    this._globalObject = globalObject;
+    this._entries = [];
+
+    if (args[0] !== undefined) {
+      const [form, submitter = null] = args;
+      if (submitter !== null) {
+        if (!isSubmitButton(submitter)) {
+          throw new TypeError("The specified element is not a submit button");
+        }
+        if (submitter.form !== form) {
+          throw DOMException.create(this._globalObject, [
+            "The specified element is not owned by this form element",
+            "NotFoundError"
+          ]);
+        }
+      }
+      this._entries = constructTheEntryList(form, submitter);
+    }
+  }
+
+  append(name, value, filename) {
+    const entry = createAnEntry(name, value, filename);
+    this._entries.push(entry);
+  }
+
+  delete(name) {
+    this._entries = this._entries.filter(entry => entry.name !== name);
+  }
+
+  get(name) {
+    const foundEntry = this._entries.find(entry => entry.name === name);
+    return foundEntry !== undefined ? idlUtils.tryWrapperForImpl(foundEntry.value) : null;
+  }
+
+  getAll(name) {
+    return this._entries.filter(entry => entry.name === name).map(entry => idlUtils.tryWrapperForImpl(entry.value));
+  }
+
+  has(name) {
+    return this._entries.findIndex(entry => entry.name === name) !== -1;
+  }
+
+  set(name, value, filename) {
+    const entry = createAnEntry(name, value, filename);
+
+    const foundIndex = this._entries.findIndex(e => e.name === name);
+    if (foundIndex !== -1) {
+      this._entries[foundIndex] = entry;
+      this._entries = this._entries.filter((e, i) => e.name !== name || i === foundIndex);
+    } else {
+      this._entries.push(entry);
+    }
+  }
+
+  * [Symbol.iterator]() {
+    for (const entry of this._entries) {
+      yield [entry.name, idlUtils.tryWrapperForImpl(entry.value)];
+    }
+  }
+};
+
+function createAnEntry(name, value, filename) {
+  const entry = { name };
+
+  // https://github.com/whatwg/xhr/issues/75
+
+  if (Blob.isImpl(value) && !File.isImpl(value)) {
+    const oldValue = value;
+    value = File.createImpl(value._globalObject, [
+      [],
+      "blob",
+      { type: oldValue.type }
+    ]);
+    // "representing the same bytes"
+    value._bytes = oldValue._bytes;
+  }
+
+  if (File.isImpl(value) && filename !== undefined) {
+    const oldValue = value;
+    value = File.createImpl(value._globalObject, [
+      [],
+      filename,
+      // spec makes no mention of `lastModified`; assume it is inherited
+      // (Chrome's behavior)
+      { type: oldValue.type, lastModified: oldValue.lastModified }
+    ]);
+    // "representing the same bytes"
+    value._bytes = oldValue._bytes;
+  }
+
+  entry.value = value;
+
+  return entry;
+}
+
+function constructTheEntryList(form, submitter) {
+  // https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#constructing-the-form-data-set
+  // TODO: handle encoding
+  // TODO: handling "constructing entry list"
+
+  const controls = form._getSubmittableElementNodes();
+  const entryList = [];
+
+  for (const field of controls) {
+    if (closest(field, "datalist") !== null) {
+      continue;
+    }
+    if (isDisabled(field)) {
+      continue;
+    }
+    if (isButton(field) && field !== submitter) {
+      continue;
+    }
+    if (field.type === "checkbox" && field._checkedness === false) {
+      continue;
+    }
+    if (field.type === "radio" && field._checkedness === false) {
+      continue;
+    }
+    if (field.localName === "object") { // in jsdom, no objects are "using a plugin"
+      continue;
+    }
+
+    const name = field.getAttributeNS(null, "name");
+    if (field.localName === "input" && field.type === "image") {
+      const prefix = name ? `${name}.` : "";
+      const coordinate = field._selectedCoordinate ?? { x: 0, y: 0 };
+      appendAnEntry(entryList, `${prefix}x`, coordinate.x);
+      appendAnEntry(entryList, `${prefix}y`, coordinate.y);
+      continue;
+    }
+
+    // TODO: handle form-associated custom elements.
+
+    if (name === null || name === "") {
+      continue;
+    }
+
+    if (field.localName === "select") {
+      for (const option of field.options) {
+        if (option._selectedness === true && !isDisabled(field)) {
+          appendAnEntry(entryList, name, option._getValue());
+        }
+      }
+    } else if (field.localName === "input" && (field.type === "checkbox" || field.type === "radio")) {
+      const value = field.hasAttributeNS(null, "value") ? field.getAttributeNS(null, "value") : "on";
+      appendAnEntry(entryList, name, value);
+    } else if (field.type === "file") {
+      if (field.files.length === 0) {
+        const value = File.createImpl(form._globalObject, [[], "", { type: "application/octet-stream" }]);
+        appendAnEntry(entryList, name, value);
+      } else {
+        for (let i = 0; i < field.files.length; ++i) {
+          appendAnEntry(entryList, name, field.files.item(i));
+        }
+      }
+    } else {
+      appendAnEntry(entryList, name, field._getValue());
+    }
+
+    const dirname = field.getAttributeNS(null, "dirname");
+    if (dirname !== null && dirname !== "") {
+      const dir = "ltr"; // jsdom does not (yet?) implement actual directionality
+      appendAnEntry(entryList, dirname, dir);
+    }
+  }
+
+  // TODO: formdata event
+
+  return entryList;
+}
+
+function appendAnEntry(entryList, name, value) {
+  name = conversions.USVString(name);
+  if (!File.isImpl(value)) {
+    value = conversions.USVString(value);
+  }
+  const entry = createAnEntry(name, value);
+  entryList.push(entry);
+}