@depup/jsdom 28.1.0-depup.1

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

@@ -0,0 +1,438 @@
+"use strict";
+const DOMException = require("../../../generated/idl/DOMException");
+
+const isWindow = require("../helpers/is-window");
+const reportException = require("../helpers/runtime-script-errors");
+const idlUtils = require("../../../generated/idl/utils");
+const { nodeRoot } = require("../helpers/node");
+const {
+  isNode, isShadowRoot, isSlotable, getEventTargetParent,
+  isShadowInclusiveAncestor, retarget
+} = require("../helpers/shadow-dom");
+
+const MouseEvent = require("../../../generated/idl/MouseEvent");
+
+const EVENT_PHASE = {
+  NONE: 0,
+  CAPTURING_PHASE: 1,
+  AT_TARGET: 2,
+  BUBBLING_PHASE: 3
+};
+
+class EventTargetImpl {
+  constructor(globalObject) {
+    this._globalObject = globalObject;
+    this._eventListeners = Object.create(null);
+  }
+
+  // Default argument is necessary because webidl2js cannot handle `= {}` with unions at the moment.
+  addEventListener(type, callback, options = { __proto__: null, capture: false, once: false }) {
+    let { capture, once, passive, signal } = flattenMoreEventListenerOptions(options);
+
+    if (signal !== null && signal.aborted) {
+      return;
+    }
+
+    if (callback === null) {
+      return;
+    }
+
+    if (passive === null) {
+      passive = defaultPassiveValue(type, this);
+    }
+
+    if (!this._eventListeners[type]) {
+      this._eventListeners[type] = [];
+    }
+
+    for (let i = 0; i < this._eventListeners[type].length; ++i) {
+      const listener = this._eventListeners[type][i];
+      if (
+        listener.callback.objectReference === callback.objectReference &&
+        listener.capture === capture
+      ) {
+        return;
+      }
+    }
+
+    this._eventListeners[type].push({
+      callback,
+      capture,
+      once,
+      passive,
+      signal
+    });
+
+    if (signal !== null) {
+      signal._addAlgorithm(() => {
+        this.removeEventListener(type, callback, options);
+      });
+    }
+  }
+
+  // Default argument is necessary because webidl2js cannot handle `= {}` with unions at the moment.
+  removeEventListener(type, callback, options = { __proto__: null, capture: false }) {
+    const capture = flattenEventListenerOptions(options);
+
+    if (callback === null) {
+      // Optimization, not in the spec.
+      return;
+    }
+
+    if (!this._eventListeners[type]) {
+      return;
+    }
+
+    for (let i = 0; i < this._eventListeners[type].length; ++i) {
+      const listener = this._eventListeners[type][i];
+      if (
+        listener.callback.objectReference === callback.objectReference &&
+        listener.capture === capture
+      ) {
+        this._eventListeners[type].splice(i, 1);
+        break;
+      }
+    }
+  }
+
+  dispatchEvent(eventImpl) {
+    if (eventImpl._dispatchFlag || !eventImpl._initializedFlag) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to dispatch an uninitialized event",
+        "InvalidStateError"
+      ]);
+    }
+    if (eventImpl.eventPhase !== EVENT_PHASE.NONE) {
+      throw DOMException.create(this._globalObject, [
+        "Tried to dispatch a dispatching event",
+        "InvalidStateError"
+      ]);
+    }
+
+    eventImpl.isTrusted = false;
+
+    return this._dispatch(eventImpl);
+  }
+
+  // https://dom.spec.whatwg.org/#get-the-parent
+  _getTheParent() {
+    return null;
+  }
+
+  // https://dom.spec.whatwg.org/#concept-event-dispatch
+  // legacyOutputDidListenersThrowFlag optional parameter is not necessary here since it is only used by indexDB.
+  _dispatch(eventImpl, legacyTargetOverrideFlag /* , legacyOutputDidListenersThrowFlag */) {
+    let targetImpl = this;
+    let clearTargets = false;
+    let activationTarget = null;
+
+    eventImpl._dispatchFlag = true;
+
+    const targetOverride = legacyTargetOverrideFlag ?
+      idlUtils.implForWrapper(targetImpl._globalObject._document) :
+      targetImpl;
+    let relatedTarget = retarget(eventImpl.relatedTarget, targetImpl);
+
+    if (targetImpl !== relatedTarget || targetImpl === eventImpl.relatedTarget) {
+      const touchTargets = [];
+
+      appendToEventPath(eventImpl, targetImpl, targetOverride, relatedTarget, touchTargets, false);
+
+      const isActivationEvent = MouseEvent.isImpl(eventImpl) && eventImpl.type === "click";
+
+      if (isActivationEvent && targetImpl._hasActivationBehavior) {
+        activationTarget = targetImpl;
+      }
+
+      let slotInClosedTree = false;
+      let slotable = isSlotable(targetImpl) && targetImpl._assignedSlot ? targetImpl : null;
+      let parent = getEventTargetParent(targetImpl, eventImpl);
+
+      // Populate event path
+      // https://dom.spec.whatwg.org/#event-path
+      while (parent !== null) {
+        if (slotable !== null) {
+          if (parent.localName !== "slot") {
+            throw new Error(`JSDOM Internal Error: Expected parent to be a Slot`);
+          }
+
+          slotable = null;
+
+          const parentRoot = nodeRoot(parent);
+          if (isShadowRoot(parentRoot) && parentRoot.mode === "closed") {
+            slotInClosedTree = true;
+          }
+        }
+
+        if (isSlotable(parent) && parent._assignedSlot) {
+          slotable = parent;
+        }
+
+        relatedTarget = retarget(eventImpl.relatedTarget, parent);
+
+        if (
+          (isNode(parent) && isShadowInclusiveAncestor(nodeRoot(targetImpl), parent)) ||
+          idlUtils.wrapperForImpl(parent).constructor.name === "Window"
+        ) {
+          if (isActivationEvent && eventImpl.bubbles && activationTarget === null &&
+              parent._hasActivationBehavior) {
+            activationTarget = parent;
+          }
+
+          appendToEventPath(eventImpl, parent, null, relatedTarget, touchTargets, slotInClosedTree);
+        } else if (parent === relatedTarget) {
+          parent = null;
+        } else {
+          targetImpl = parent;
+
+          if (isActivationEvent && activationTarget === null && targetImpl._hasActivationBehavior) {
+            activationTarget = targetImpl;
+          }
+
+          appendToEventPath(eventImpl, parent, targetImpl, relatedTarget, touchTargets, slotInClosedTree);
+        }
+
+        if (parent !== null) {
+          parent = getEventTargetParent(parent, eventImpl);
+        }
+
+        slotInClosedTree = false;
+      }
+
+      let clearTargetsStructIndex = -1;
+      for (let i = eventImpl._path.length - 1; i >= 0 && clearTargetsStructIndex === -1; i--) {
+        if (eventImpl._path[i].target !== null) {
+          clearTargetsStructIndex = i;
+        }
+      }
+      const clearTargetsStruct = eventImpl._path[clearTargetsStructIndex];
+
+      clearTargets =
+          (isNode(clearTargetsStruct.target) && isShadowRoot(nodeRoot(clearTargetsStruct.target))) ||
+          (isNode(clearTargetsStruct.relatedTarget) && isShadowRoot(nodeRoot(clearTargetsStruct.relatedTarget)));
+
+      if (activationTarget !== null && activationTarget._legacyPreActivationBehavior) {
+        activationTarget._legacyPreActivationBehavior();
+      }
+
+      for (let i = eventImpl._path.length - 1; i >= 0; --i) {
+        const struct = eventImpl._path[i];
+
+        if (struct.target !== null) {
+          eventImpl.eventPhase = EVENT_PHASE.AT_TARGET;
+        } else {
+          eventImpl.eventPhase = EVENT_PHASE.CAPTURING_PHASE;
+        }
+
+        invokeEventListeners(struct, eventImpl, "capturing");
+      }
+
+      for (let i = 0; i < eventImpl._path.length; i++) {
+        const struct = eventImpl._path[i];
+
+        if (struct.target !== null) {
+          eventImpl.eventPhase = EVENT_PHASE.AT_TARGET;
+        } else {
+          if (!eventImpl.bubbles) {
+            continue;
+          }
+
+          eventImpl.eventPhase = EVENT_PHASE.BUBBLING_PHASE;
+        }
+
+        invokeEventListeners(struct, eventImpl, "bubbling");
+      }
+    }
+
+    eventImpl.eventPhase = EVENT_PHASE.NONE;
+
+    eventImpl.currentTarget = null;
+    eventImpl._path = [];
+    eventImpl._dispatchFlag = false;
+    eventImpl._stopPropagationFlag = false;
+    eventImpl._stopImmediatePropagationFlag = false;
+
+    if (clearTargets) {
+      eventImpl.target = null;
+      eventImpl.relatedTarget = null;
+    }
+
+    if (activationTarget !== null) {
+      if (!eventImpl._canceledFlag) {
+        activationTarget._activationBehavior(eventImpl);
+      } else if (activationTarget._legacyCanceledActivationBehavior) {
+        activationTarget._legacyCanceledActivationBehavior();
+      }
+    }
+
+    return !eventImpl._canceledFlag;
+  }
+}
+
+module.exports = {
+  implementation: EventTargetImpl
+};
+
+// https://dom.spec.whatwg.org/#concept-event-listener-invoke
+function invokeEventListeners(struct, eventImpl, phase) {
+  const structIndex = eventImpl._path.indexOf(struct);
+  for (let i = structIndex; i >= 0; i--) {
+    const t = eventImpl._path[i];
+    if (t.target) {
+      eventImpl.target = t.target;
+      break;
+    }
+  }
+
+  eventImpl.relatedTarget = idlUtils.wrapperForImpl(struct.relatedTarget);
+
+  if (eventImpl._stopPropagationFlag) {
+    return;
+  }
+
+  eventImpl.currentTarget = idlUtils.wrapperForImpl(struct.item);
+
+  const listeners = struct.item._eventListeners;
+  innerInvokeEventListeners(eventImpl, listeners, phase, struct.itemInShadowTree);
+}
+
+// https://dom.spec.whatwg.org/#concept-event-listener-inner-invoke
+function innerInvokeEventListeners(eventImpl, listeners, phase, itemInShadowTree) {
+  let found = false;
+
+  const { type, target } = eventImpl;
+  const wrapper = idlUtils.wrapperForImpl(target);
+
+  if (!listeners || !listeners[type]) {
+    return found;
+  }
+
+  // Copy event listeners before iterating since the list can be modified during the iteration.
+  const handlers = listeners[type].slice();
+
+  for (let i = 0; i < handlers.length; i++) {
+    const listener = handlers[i];
+    const { callback, capture, once, passive } = listener;
+
+    // Check if the event listener has been removed since the listeners has been cloned.
+    if (!listeners[type].includes(listener)) {
+      continue;
+    }
+
+    found = true;
+
+    if (
+      (phase === "capturing" && !capture) ||
+      (phase === "bubbling" && capture)
+    ) {
+      continue;
+    }
+
+    if (once) {
+      listeners[type].splice(listeners[type].indexOf(listener), 1);
+    }
+
+    let window = null;
+    if (wrapper && wrapper._document) {
+      // Triggered by Window
+      window = wrapper;
+    } else if (target._ownerDocument) {
+      // Triggered by most webidl2js'ed instances
+      window = target._ownerDocument._defaultView;
+    } else if (wrapper._ownerDocument) {
+      // Currently triggered by some non-webidl2js things
+      window = wrapper._ownerDocument._defaultView;
+    }
+
+    let currentEvent;
+    if (window) {
+      currentEvent = window._currentEvent;
+      if (!itemInShadowTree) {
+        window._currentEvent = eventImpl;
+      }
+    }
+
+    if (passive) {
+      eventImpl._inPassiveListenerFlag = true;
+    }
+
+    try {
+      callback.call(eventImpl.currentTarget, eventImpl);
+    } catch (e) {
+      if (window) {
+        reportException(window, e);
+      }
+      // Errors in window-less documents just get swallowed... can you think of anything better?
+    }
+
+    eventImpl._inPassiveListenerFlag = false;
+
+    if (window) {
+      window._currentEvent = currentEvent;
+    }
+
+    if (eventImpl._stopImmediatePropagationFlag) {
+      return found;
+    }
+  }
+
+  return found;
+}
+
+function flattenMoreEventListenerOptions(options) {
+  const dict = {
+    capture: flattenEventListenerOptions(options),
+    once: false,
+    passive: null,
+    signal: null
+  };
+
+  if (options !== null && typeof options === "object") {
+    dict.once = options.once;
+    if ("passive" in options) {
+      dict.passive = options.passive;
+    }
+    if ("signal" in options) {
+      dict.signal = options.signal;
+    }
+  }
+  return dict;
+}
+
+function flattenEventListenerOptions(options) {
+  if (typeof options === "boolean") {
+    return options;
+  }
+  return options.capture;
+}
+
+function defaultPassiveValue(type, eventTarget) {
+  switch (type) {
+    case "touchstart":
+    case "touchmove":
+    case "wheel":
+    case "mousewheel":
+      return isWindow(eventTarget) ||
+        eventTarget._ownerDocument === eventTarget ||
+        eventTarget._ownerDocument.documentElement === eventTarget ||
+        eventTarget._ownerDocument.body === eventTarget;
+    default:
+      return false;
+  }
+}
+
+// https://dom.spec.whatwg.org/#concept-event-path-append
+function appendToEventPath(eventImpl, target, targetOverride, relatedTarget, touchTargets, slotInClosedTree) {
+  const itemInShadowTree = isNode(target) && isShadowRoot(nodeRoot(target));
+  const rootOfClosedTree = isShadowRoot(target) && target.mode === "closed";
+
+  eventImpl._path.push({
+    item: target,
+    itemInShadowTree,
+    target: targetOverride,
+    relatedTarget,
+    touchTargets,
+    rootOfClosedTree,
+    slotInClosedTree
+  });
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const FocusEventInit = require("../../../generated/idl/FocusEventInit");
+
+class FocusEventImpl extends UIEventImpl {}
+FocusEventImpl.defaultInit = FocusEventInit.convert(undefined, undefined);
+
+exports.implementation = FocusEventImpl;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+const UIEventImpl = require("./UIEvent-impl").implementation;
+const InputEventInit = require("../../../generated/idl/InputEventInit");
+
+// https://w3c.github.io/uievents/#interface-inputevent
+class InputEventImpl extends UIEventImpl { }
+InputEventImpl.defaultInit = InputEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: InputEventImpl
+};

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

@@ -0,0 +1,29 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const EventModifierMixinImpl = require("./EventModifierMixin-impl").implementation;
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const KeyboardEventInit = require("../../../generated/idl/KeyboardEventInit");
+
+class KeyboardEventImpl extends UIEventImpl {
+  initKeyboardEvent(type, bubbles, cancelable, view, key, location, ctrlKey, altKey, shiftKey, metaKey) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, 0);
+    this.key = key;
+    this.location = location;
+    this.ctrlKey = ctrlKey;
+    this.altKey = altKey;
+    this.shiftKey = shiftKey;
+    this.metaKey = metaKey;
+  }
+}
+mixin(KeyboardEventImpl.prototype, EventModifierMixinImpl.prototype);
+KeyboardEventImpl.defaultInit = KeyboardEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: KeyboardEventImpl
+};

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

@@ -0,0 +1,25 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const MessageEventInit = require("../../../generated/idl/MessageEventInit");
+
+class MessageEventImpl extends EventImpl {
+  initMessageEvent(type, bubbles, cancelable, data, origin, lastEventId, source, ports) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.data = data;
+    this.origin = origin;
+    this.lastEventId = lastEventId;
+    this.source = source;
+    this.ports = ports;
+  }
+}
+MessageEventImpl.defaultInit = MessageEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: MessageEventImpl
+};

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

@@ -0,0 +1,72 @@
+"use strict";
+
+const { mixin } = require("../../utils");
+const EventModifierMixinImpl = require("./EventModifierMixin-impl").implementation;
+const UIEventImpl = require("./UIEvent-impl").implementation;
+
+const MouseEventInit = require("../../../generated/idl/MouseEventInit");
+
+class MouseEventImpl extends UIEventImpl {
+  get x() {
+    return this.clientX;
+  }
+  get y() {
+    return this.clientY;
+  }
+  get pageX() {
+    // TODO: consider dispatch flag and return page-relative event coordinate once layout is supported
+    return this.clientX; // TODO: add horizontal scroll offset once jsdom implements scrolling support
+  }
+  get pageY() {
+    // TODO: consider dispatch flag and return page-relative event coordinate once layout is supported
+    return this.clientY; // TODO: add vertical scroll offset once jsdom implements scrolling support
+  }
+  get offsetX() {
+    // TODO: consider dispatch flag and return target-relative event coordinate once layout is supported
+    return this.pageX;
+  }
+  get offsetY() {
+    // TODO: consider dispatch flag and return target-relative event coordinate once layout is supported
+    return this.pageY;
+  }
+
+  initMouseEvent(
+    type,
+    bubbles,
+    cancelable,
+    view,
+    detail,
+    screenX,
+    screenY,
+    clientX,
+    clientY,
+    ctrlKey,
+    altKey,
+    shiftKey,
+    metaKey,
+    button,
+    relatedTarget
+  ) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initUIEvent(type, bubbles, cancelable, view, detail);
+    this.screenX = screenX;
+    this.screenY = screenY;
+    this.clientX = clientX;
+    this.clientY = clientY;
+    this.ctrlKey = ctrlKey;
+    this.altKey = altKey;
+    this.shiftKey = shiftKey;
+    this.metaKey = metaKey;
+    this.button = button;
+    this.relatedTarget = relatedTarget;
+  }
+}
+mixin(MouseEventImpl.prototype, EventModifierMixinImpl.prototype);
+MouseEventImpl.defaultInit = MouseEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: MouseEventImpl
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+
+const EventImpl = require("./Event-impl").implementation;
+
+const PageTransitionEventInit = require("../../../generated/idl/PageTransitionEventInit");
+
+// https://html.spec.whatwg.org/multipage/browsing-the-web.html#pagetransitionevent
+class PageTransitionEventImpl extends EventImpl {
+  initPageTransitionEvent(type, bubbles, cancelable, persisted) {
+    if (this._dispatchFlag) {
+      return;
+    }
+
+    this.initEvent(type, bubbles, cancelable);
+    this.persisted = persisted;
+  }
+}
+PageTransitionEventImpl.defaultInit = PageTransitionEventInit.convert(undefined, undefined);
+
+exports.implementation = PageTransitionEventImpl;

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

@@ -0,0 +1,21 @@
+"use strict";
+const MouseEventImpl = require("./MouseEvent-impl").implementation;
+const PointerEventInit = require("../../../generated/idl/PointerEventInit");
+
+class PointerEventImpl extends MouseEventImpl {
+  getCoalescedEvents() {
+    // The EventImpl constructor initializes this.coalescedEvents from the init dictionary.
+    // Return a new array each time (webidl2js doesn't handle this for us.)
+    return [...this.coalescedEvents];
+  }
+
+  getPredictedEvents() {
+    // As above.
+    return [...this.predictedEvents];
+  }
+}
+PointerEventImpl.defaultInit = PointerEventInit.convert(undefined, undefined);
+
+module.exports = {
+  implementation: PointerEventImpl
+};

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

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

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

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

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

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