MessagePort, MessageChannel and StructuredClone implementation

lib/jsdom/browser/Window.js

@@ -14,10 +14,12 @@ const OnErrorEventHandlerNonNull = require("../living/generated/OnErrorEventHand
 const { fireAPageTransitionEvent } = require("../living/helpers/page-transition-event");
 const namedPropertiesWindow = require("../living/named-properties-window");
 const postMessage = require("../living/post-message");
+const structuredClone = require("../living/structured-clone/structuredClone");
 const DOMException = require("domexception/webidl2js-wrapper");
 const { btoa, atob } = require("abab");
 const idlUtils = require("../living/generated/utils");
 const WebSocketImpl = require("../living/websockets/WebSocket-impl").implementation;
+const MessageChannel = require("../living/message-channel/MessageChannel-impl").implementation;
 const BarProp = require("../living/generated/BarProp");
 const documents = require("../living/documents.js");
 const External = require("../living/generated/External");
@@ -755,6 +757,8 @@ function Window(options) {
   });
 
   this.postMessage = postMessage(window);
+  this.structuredClone = structuredClone(window);
+  this.MessageChannel = MessageChannel;
 
   this.atob = function (str) {
     const result = atob(str);

lib/jsdom/living/message-channel/MessageChannel-impl.js

@@ -0,0 +1,26 @@
+"use strict";
+
+const MessagePortImpl = require("../message-port/MessagePort-impl");
+
+class MessageChannelImpl {
+  constructor(globalObject) {
+    this._ports = [
+      new MessagePortImpl(globalObject),
+      new MessagePortImpl(globalObject)
+    ];
+
+    MessagePortImpl.entangle(...this._ports);
+  }
+
+  get port1() {
+    return this._ports[0];
+  }
+
+  get port2() {
+    return this._ports[1];
+  }
+}
+
+module.exports = {
+  implementation: MessageChannelImpl
+};

lib/jsdom/living/message-channel/MessageChannel.webidl

@@ -0,0 +1,7 @@
+[Exposed=(Window,Worker)]
+interface MessageChannel {
+  constructor();
+
+  readonly attribute MessagePort port1;
+  readonly attribute MessagePort port2;
+};

lib/jsdom/living/message-port/MessagePort-impl.js

@@ -0,0 +1,176 @@
+"use strict";
+
+const DOMException = require("domexception/webidl2js-wrapper");
+const MessageEvent = require("../generated/MessageEvent");
+const { fireAnEvent } = require("../helpers/events");
+const EventTargetImpl = require("../events/EventTarget-impl").implementation;
+const { structuredSerializeWithTransfer } = require("../structured-clone/structuredSerializeWithTransfer");
+const { structuredDeserializeWithTransfer } = require("../structured-clone/structuredDeserializeWithTransfer");
+
+class PortMessageQueue {
+  constructor() {
+    this._enabled = false;
+
+    /**
+     * @type {[*, object]} queue
+     */
+
+    this.queue = [];
+  }
+
+  get enabled() {
+    return this._enabled;
+  }
+
+  enable() {
+    if (this._enabled) {
+      return;
+    }
+
+    this._enabled = true;
+  }
+
+  enqueue(message, options) {
+    this.queue.push([message, options]);
+  }
+}
+
+
+class MessagePortImpl extends EventTargetImpl {
+  constructor(globalObject) {
+    super(globalObject);
+
+    this._globalObject = globalObject;
+    this._onmessage = undefined;
+    this._onmessageerror = undefined;
+    this._dataHolder = {
+      _remotePort: null,
+      _portMessageQueue: new PortMessageQueue()
+    };
+  }
+
+  /**
+   * @param {MessagePortImpl} port1
+   * @param {MessagePortImpl} port2
+   */
+
+  static entangle(port1, port2) {
+    port1._dataHolder._remotePort = port2;
+    port2._dataHolder._remotePort = port1;
+  }
+
+  /**
+   * @param {MessagePortImpl} port1
+   * @param {MessagePortImpl} port2
+   */
+
+  static disentangle(port1, port2) {
+    port2._dataHolder._remotePort = null;
+    port1._dataHolder._remotePort = null;
+  }
+
+  get onmessage() {
+    return this._onmessage;
+  }
+
+  set onmessage(value) {
+    this._onmessage = value;
+    this.start();
+  }
+
+  postMessage(message, optionsOrTransfer) {
+    const options = {};
+
+    if (Array.isArray(optionsOrTransfer)) {
+      options.transfer = optionsOrTransfer;
+    } else if (typeof optionsOrTransfer === "object") {
+      Object.assign(options, optionsOrTransfer);
+    }
+
+    const { transfer } = options;
+
+    if (transfer.some(t => t === this)) {
+      throw DOMException.create(this._globalObject, [
+        "The object can not be cloned.",
+        "DataCloneError"
+      ]);
+    }
+
+    let doomed = false;
+    const targetPort = this._dataHolder._remotePort;
+
+    if (targetPort !== null && transfer.includes(targetPort)) {
+      doomed = true;
+    }
+
+    const serializeWithTransferResult = structuredSerializeWithTransfer(this._globalObject)(message, transfer);
+
+    if (!targetPort || doomed) {
+      // eslint-disable-next-line no-console
+      console.warn("Target port was posted to itself, causing the communication channel to be lost.");
+      return;
+    }
+
+    /**
+     * Out of standard, but we don't have the event loop
+     */
+
+    if (!this._dataHolder._portMessageQueue.enabled) {
+      this._dataHolder._portMessageQueue.enqueue(message, options);
+      return;
+    }
+
+    queueMicrotask(() => {
+      const finalTargetPort = targetPort;
+      /**
+       * Let deserializeRecord be StructuredDeserializeWithTransfer(serializeWithTransferResult, targetRealm).
+       * If this throws an exception, catch it, fire an event named messageerror at finalTargetPort, using
+       *        MessageEvent, and then return.
+       */
+
+      let deserializeRecord;
+
+      try {
+        deserializeRecord = structuredDeserializeWithTransfer(serializeWithTransferResult, this._globalObject);
+      } catch (err) {
+        fireAnEvent("messageerror", finalTargetPort, MessageEvent, { data: err });
+      }
+
+      /**
+       * Let messageClone be deserializeRecord.[[Deserialized]].
+       */
+
+      const messageClone = deserializeRecord.Deserialized;
+
+      /**
+       * Let newPorts be a new frozen array consisting of all MessagePort objects in
+       * deserializeRecord.[[TransferredValues]], if any, maintaining their relative order.
+       */
+
+      const newPorts = Object.freeze(
+        deserializeRecord.TransferredValues.filter(value => value instanceof MessagePortImpl)
+      );
+
+      fireAnEvent("message", finalTargetPort, MessageEvent, { data: messageClone, ports: newPorts });
+    });
+  }
+
+  start() {
+    this._dataHolder._portMessageQueue.enable();
+
+    let event;
+
+    while ((event = this._dataHolder._portMessageQueue.queue.shift())) {
+      const [message, options] = event;
+      this.postMessage(message, options);
+    }
+  }
+
+  close() {
+    MessagePortImpl.disentangle(this, this._dataHolder._remotePort);
+  }
+}
+
+module.exports = {
+  implementation: MessagePortImpl
+};

lib/jsdom/living/message-port/MessagePort.webidl

@@ -0,0 +1,15 @@
+[Exposed=(Window,Worker,AudioWorklet), Transferable]
+interface MessagePort : EventTarget {
+  undefined postMessage(any message, sequence<object> transfer);
+  undefined postMessage(any message, optional StructuredSerializeOptions options = {});
+  undefined start();
+  undefined close();
+
+  // event handlers
+  attribute EventHandler onmessage;
+  attribute EventHandler onmessageerror;
+};
+
+dictionary StructuredSerializeOptions {
+  sequence<object> transfer = [];
+};

lib/jsdom/living/post-message.js

@@ -30,7 +30,6 @@ module.exports = function (globalObject) {
 
     // TODO: event.source - requires reference to source window
     // TODO: event.origin - requires reference to source window
-    // TODO: event.ports
     // TODO: event.data - structured clone message - requires cloning DOM nodes
     setTimeout(() => {
       fireAnEvent("message", this, MessageEvent, { data: message });

lib/jsdom/living/structured-clone/structuredClone.js

@@ -0,0 +1,17 @@
+"use strict";
+
+const { structuredDeserializeWithTransfer } = require("./structuredDeserializeWithTransfer");
+const { structuredSerializeWithTransfer } = require("./structuredSerializeWithTransfer");
+
+module.exports = function (globalObject) {
+  return function (value, options = {}) {
+    // Let serialized be ? StructuredSerializeWithTransfer(value, options["transfer"]).
+    const serialized = structuredSerializeWithTransfer(globalObject)(value, options.transfer);
+
+    // Let deserializeRecord be ? StructuredDeserializeWithTransfer(serialized, this's relevant realm).
+    const deserializeRecord = structuredDeserializeWithTransfer(serialized, globalObject);
+
+    // Return deserializeRecord.[[Deserialized]].
+    return deserializeRecord.Deserialized;
+  };
+};