WebSocket-impl-browser.js

/* eslint-env browser */

"use strict";

const DOMException = require("domexception");
const { parseURL, serializeURL, serializeURLOrigin } = require("whatwg-url");

const { setupForSimpleEventAccessors } = require("../helpers/create-event-accessor");

const EventTargetImpl = require("../events/EventTarget-impl").implementation;

const idlUtils = require("../generated/utils");
const Blob = require("../generated/Blob");
const CloseEvent = require("../generated/CloseEvent");
const Event = require("../generated/Event");
const MessageEvent = require("../generated/MessageEvent");

const productions = {
  // https://tools.ietf.org/html/rfc7230#section-3.2.6
  token: /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/
};

// https://tools.ietf.org/html/rfc6455#section-4.3
// See Sec-WebSocket-Protocol-Client, which is for the syntax of an entire header value. This function checks if a
// single header conforms to the rules.
function verifySecWebSocketProtocol(str) {
  return productions.token.test(str);
}

const openSockets = new WeakMap();

class WebSocketImpl extends EventTargetImpl {
  constructor(constructorArgs, privateData) {
    super([], privateData);
    const { window } = privateData;
    this._ownerDocument = idlUtils.implForWrapper(window._document);

    const url = constructorArgs[0];
    let protocols = constructorArgs[1] !== undefined ? constructorArgs[1] : [];

    const urlRecord = parseURL(url);
    if (urlRecord === null) {
      throw new DOMException(`The URL '${url}' is invalid.`, "SyntaxError");
    }
    if (urlRecord.scheme !== "ws" && urlRecord.scheme !== "wss") {
      throw new DOMException(
        `The URL's scheme must be either 'ws' or 'wss'. '${urlRecord.scheme}' is not allowed.`,
        "SyntaxError"
      );
    }
    if (urlRecord.fragment !== null) {
      throw new DOMException(`The URL contains a fragment identifier ('${urlRecord.fragment}'). Fragment identifiers ` +
                             "are not allowed in WebSocket URLs.", "SyntaxError");
    }

    if (typeof protocols === "string") {
      protocols = [protocols];
    }
    const protocolSet = new Set();
    for (const protocol of protocols) {
      if (!verifySecWebSocketProtocol(protocol)) {
        throw new DOMException(`The subprotocol '${protocol}' is invalid.`, "SyntaxError");
      }
      const lowered = protocol.toLowerCase();
      if (protocolSet.has(lowered)) {
        throw new DOMException(`The subprotocol '${protocol}' is duplicated.`, "SyntaxError");
      }
      protocolSet.add(lowered);
    }

    this._urlRecord = urlRecord;
    this.url = serializeURL(urlRecord);

    this._ws = new WebSocket(this.url, protocols);

    this._ws.onopen = () => {
      this._dispatch(Event.createImpl(["open"], { isTrusted: true }));
    };
    this._ws.onerror = () => {
      this._dispatch(Event.createImpl(["error"], { isTrusted: true }));
    };
    this._ws.onclose = event => {
      this._dispatch(CloseEvent.createImpl([
        "close", {
          wasClean: event.wasClean,
          code: event.code,
          reason: event.reason
        }
      ], { isTrusted: true }));
    };
    this._ws.onmessage = event => {
      this._dispatch(MessageEvent.createImpl([
        "message", {
          data: event.data,
          origin: serializeURLOrigin(this._urlRecord)
        }
      ], {
        isTrusted: true
      }));
    };

    let openSocketsForWindow = openSockets.get(window._globalProxy);
    if (openSocketsForWindow === undefined) {
      openSocketsForWindow = new Set();
      openSockets.set(window._globalProxy, openSocketsForWindow);
    }
    openSocketsForWindow.add(this);
  }

  // https://html.spec.whatwg.org/multipage/web-sockets.html#make-disappear
  _makeDisappear() {
    this._eventListeners = Object.create(null);
    this._ws.close(1001);
  }

  static cleanUpWindow(window) {
    const openSocketsForWindow = openSockets.get(window._globalProxy);
    if (openSocketsForWindow !== undefined) {
      for (const ws of openSocketsForWindow) {
        ws._makeDisappear();
      }
    }
  }

  get readyState() {
    return this._ws.readyState;
  }

  get bufferedAmount() {
    return this._ws.bufferedAmount;
  }

  get extensions() {
    return this._ws.extensions;
  }

  get protocol() {
    return this._ws.protocol;
  }

  close(code = undefined, reason = undefined) {
    if (code !== undefined && code !== 1000 && !(code >= 3000 && code <= 4999)) {
      throw new DOMException(
        `The code must be either 1000, or between 3000 and 4999. ${code} is neither.`,
        "InvalidAccessError"
      );
    }
    if (reason !== undefined && Buffer.byteLength(reason, "utf8") > 123) {
      throw new DOMException("The message must not be greater than 123 bytes.", "SyntaxError");
    }
    return this._ws.close(code, reason);
  }

  get binaryType() {
    return this._ws.binaryType;
  }

  set binaryType(val) {
    this._ws.binaryType = val;
  }

  send(data) {
    if (Blob.isImpl(data)) {
      data = data._buffer;
    }
    this._ws.send(data);
  }
}

setupForSimpleEventAccessors(WebSocketImpl.prototype, ["open", "message", "error", "close"]);

exports.implementation = WebSocketImpl;