Changeset e29cc2e for trip-planner-front/node_modules/ws/lib/websocket.js

Timestamp:

11/25/21 22:08:24 (3 years ago)

Author:

Ema <ema_spirova@…>

Branches:

master

Children:

8d391a1

Parents:

59329aa

Message:

primeNG components

File:

• trip-planner-front/node_modules/ws/lib/websocket.js (modified) (45 diffs)

trip-planner-front/node_modules/ws/lib/websocket.js

@@ -2 +2 @@
 
 const EventEmitter = require('events');
+const crypto = require('crypto');
 const https = require('https');
 const http = require('http');
 const net = require('net');
 const tls = require('tls');
-const { randomBytes, createHash } = require('crypto');
-const { URL } = require('url');
+const url = require('url');
 
 const PerMessageDeflate = require('./permessage-deflate');
+const EventTarget = require('./event-target');
+const extension = require('./extension');
 const Receiver = require('./receiver');
 const Sender = require('./sender');
@@ -20 +22 @@
   NOOP
 } = require('./constants');
-const { addEventListener, removeEventListener } = require('./event-target');
-const { format, parse } = require('./extension');
-const { toBuffer } = require('./buffer-util');
 
 const readyStates = ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'];
@@ -37 +36 @@
    * Create a new `WebSocket`.
    *
-   * @param {(String|url.URL)} address The URL to which to connect
-   * @param {(String|String[])} [protocols] The subprotocols
-   * @param {Object} [options] Connection options
+   * @param {(String|url.Url|url.URL)} address The URL to which to connect
+   * @param {(String|String[])} protocols The subprotocols
+   * @param {Object} options Connection options
    */
   constructor(address, protocols, options) {
     super();
 
+    this.readyState = WebSocket.CONNECTING;
+    this.protocol = '';
+
     this._binaryType = BINARY_TYPES[0];
-    this._closeCode = 1006;
     this._closeFrameReceived = false;
     this._closeFrameSent = false;
     this._closeMessage = '';
     this._closeTimer = null;
+    this._closeCode = 1006;
     this._extensions = {};
-    this._protocol = '';
-    this._readyState = WebSocket.CONNECTING;
     this._receiver = null;
     this._sender = null;
@@ -58 +58 @@
 
     if (address !== null) {
-      this._bufferedAmount = 0;
       this._isServer = false;
       this._redirects = 0;
@@ -75 +74 @@
   }
 
+  get CONNECTING() {
+    return WebSocket.CONNECTING;
+  }
+  get CLOSING() {
+    return WebSocket.CLOSING;
+  }
+  get CLOSED() {
+    return WebSocket.CLOSED;
+  }
+  get OPEN() {
+    return WebSocket.OPEN;
+  }
+
   /**
    * This deviates from the WHATWG interface since ws doesn't support the
@@ -101 +113 @@
    */
   get bufferedAmount() {
-    if (!this._socket) return this._bufferedAmount;
-
-    return this._socket._writableState.length + this._sender._bufferedBytes;
+    if (!this._socket) return 0;
+
+    //
+    // `socket.bufferSize` is `undefined` if the socket is closed.
+    //
+    return (this._socket.bufferSize || 0) + this._sender._bufferedBytes;
   }
 
@@ -114 +129 @@
 
   /**
-   * @type {String}
-   */
-  get protocol() {
-    return this._protocol;
-  }
-
-  /**
-   * @type {Number}
-   */
-  get readyState() {
-    return this._readyState;
-  }
-
-  /**
-   * @type {String}
-   */
-  get url() {
-    return this._url;
-  }
-
-  /**
    * Set up the socket and the internal resources.
    *
    * @param {net.Socket} socket The network socket between the server and client
    * @param {Buffer} head The first packet of the upgraded stream
-   * @param {Number} [maxPayload=0] The maximum allowed message size
+   * @param {Number} maxPayload The maximum allowed message size
    * @private
    */
   setSocket(socket, head, maxPayload) {
     const receiver = new Receiver(
-      this.binaryType,
+      this._binaryType,
       this._extensions,
-      this._isServer,
       maxPayload
     );
@@ -174 +167 @@
     socket.on('error', socketOnError);
 
-    this._readyState = WebSocket.OPEN;
+    this.readyState = WebSocket.OPEN;
     this.emit('open');
   }
@@ -184 +177 @@
    */
   emitClose() {
+    this.readyState = WebSocket.CLOSED;
+
     if (!this._socket) {
-      this._readyState = WebSocket.CLOSED;
       this.emit('close', this._closeCode, this._closeMessage);
       return;
@@ -195 +189 @@
 
     this._receiver.removeAllListeners();
-    this._readyState = WebSocket.CLOSED;
     this.emit('close', this._closeCode, this._closeMessage);
   }
@@ -214 +207 @@
    *              +---+
    *
-   * @param {Number} [code] Status code explaining why the connection is closing
-   * @param {String} [data] A string explaining why the connection is closing
+   * @param {Number} code Status code explaining why the connection is closing
+   * @param {String} data A string explaining why the connection is closing
    * @public
    */
@@ -230 +223 @@
     }
 
-    this._readyState = WebSocket.CLOSING;
+    this.readyState = WebSocket.CLOSING;
     this._sender.close(code, data, !this._isServer, (err) => {
       //
@@ -254 +247 @@
    * Send a ping.
    *
-   * @param {*} [data] The data to send
-   * @param {Boolean} [mask] Indicates whether or not to mask `data`
-   * @param {Function} [cb] Callback which is executed when the ping is sent
+   * @param {*} data The data to send
+   * @param {Boolean} mask Indicates whether or not to mask `data`
+   * @param {Function} cb Callback which is executed when the ping is sent
    * @public
    */
   ping(data, mask, cb) {
-    if (this.readyState === WebSocket.CONNECTING) {
-      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
-    }
-
     if (typeof data === 'function') {
       cb = data;
@@ -272 +261 @@
     }
 
+    if (this.readyState !== WebSocket.OPEN) {
+      const err = new Error(
+        `WebSocket is not open: readyState ${this.readyState} ` +
+          `(${readyStates[this.readyState]})`
+      );
+
+      if (cb) return cb(err);
+      throw err;
+    }
+
     if (typeof data === 'number') data = data.toString();
-
-    if (this.readyState !== WebSocket.OPEN) {
-      sendAfterClose(this, data, cb);
-      return;
-    }
-
     if (mask === undefined) mask = !this._isServer;
     this._sender.ping(data || EMPTY_BUFFER, mask, cb);
@@ -286 +279 @@
    * Send a pong.
    *
-   * @param {*} [data] The data to send
-   * @param {Boolean} [mask] Indicates whether or not to mask `data`
-   * @param {Function} [cb] Callback which is executed when the pong is sent
+   * @param {*} data The data to send
+   * @param {Boolean} mask Indicates whether or not to mask `data`
+   * @param {Function} cb Callback which is executed when the pong is sent
    * @public
    */
   pong(data, mask, cb) {
-    if (this.readyState === WebSocket.CONNECTING) {
-      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
-    }
-
     if (typeof data === 'function') {
       cb = data;
@@ -304 +293 @@
     }
 
+    if (this.readyState !== WebSocket.OPEN) {
+      const err = new Error(
+        `WebSocket is not open: readyState ${this.readyState} ` +
+          `(${readyStates[this.readyState]})`
+      );
+
+      if (cb) return cb(err);
+      throw err;
+    }
+
     if (typeof data === 'number') data = data.toString();
-
-    if (this.readyState !== WebSocket.OPEN) {
-      sendAfterClose(this, data, cb);
-      return;
-    }
-
     if (mask === undefined) mask = !this._isServer;
     this._sender.pong(data || EMPTY_BUFFER, mask, cb);
@@ -319 +312 @@
    *
    * @param {*} data The message to send
-   * @param {Object} [options] Options object
-   * @param {Boolean} [options.compress] Specifies whether or not to compress
-   *     `data`
-   * @param {Boolean} [options.binary] Specifies whether `data` is binary or
-   *     text
-   * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
-   *     last one
-   * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
-   * @param {Function} [cb] Callback which is executed when data is written out
+   * @param {Object} options Options object
+   * @param {Boolean} options.compress Specifies whether or not to compress `data`
+   * @param {Boolean} options.binary Specifies whether `data` is binary or text
+   * @param {Boolean} options.fin Specifies whether the fragment is the last one
+   * @param {Boolean} options.mask Specifies whether or not to mask `data`
+   * @param {Function} cb Callback which is executed when data is written out
    * @public
    */
   send(data, options, cb) {
-    if (this.readyState === WebSocket.CONNECTING) {
-      throw new Error('WebSocket is not open: readyState 0 (CONNECTING)');
-    }
-
     if (typeof options === 'function') {
       cb = options;
@@ -340 +326 @@
     }
 
+    if (this.readyState !== WebSocket.OPEN) {
+      const err = new Error(
+        `WebSocket is not open: readyState ${this.readyState} ` +
+          `(${readyStates[this.readyState]})`
+      );
+
+      if (cb) return cb(err);
+      throw err;
+    }
+
     if (typeof data === 'number') data = data.toString();
 
-    if (this.readyState !== WebSocket.OPEN) {
-      sendAfterClose(this, data, cb);
-      return;
-    }
-
-    const opts = {
-      binary: typeof data !== 'string',
-      mask: !this._isServer,
-      compress: true,
-      fin: true,
-      ...options
-    };
+    const opts = Object.assign(
+      {
+        binary: typeof data !== 'string',
+        mask: !this._isServer,
+        compress: true,
+        fin: true
+      },
+      options
+    );
 
     if (!this._extensions[PerMessageDeflate.extensionName]) {
@@ -375 +368 @@
 
     if (this._socket) {
-      this._readyState = WebSocket.CLOSING;
+      this.readyState = WebSocket.CLOSING;
       this._socket.destroy();
     }
@@ -382 +375 @@
 
 readyStates.forEach((readyState, i) => {
-  const descriptor = { enumerable: true, value: i };
-
-  Object.defineProperty(WebSocket.prototype, readyState, descriptor);
-  Object.defineProperty(WebSocket, readyState, descriptor);
-});
-
-[
-  'binaryType',
-  'bufferedAmount',
-  'extensions',
-  'protocol',
-  'readyState',
-  'url'
-].forEach((property) => {
-  Object.defineProperty(WebSocket.prototype, property, { enumerable: true });
+  WebSocket[readyState] = i;
 });
 
@@ -405 +384 @@
 ['open', 'error', 'close', 'message'].forEach((method) => {
   Object.defineProperty(WebSocket.prototype, `on${method}`, {
-    configurable: true,
-    enumerable: true,
     /**
      * Return the listener of the event.
@@ -415 +392 @@
     get() {
       const listeners = this.listeners(method);
-      for (let i = 0; i < listeners.length; i++) {
+      for (var i = 0; i < listeners.length; i++) {
         if (listeners[i]._listener) return listeners[i]._listener;
       }
@@ -429 +406 @@
     set(listener) {
       const listeners = this.listeners(method);
-      for (let i = 0; i < listeners.length; i++) {
+      for (var i = 0; i < listeners.length; i++) {
         //
         // Remove only the listeners added via `addEventListener`.
@@ -440 +417 @@
 });
 
-WebSocket.prototype.addEventListener = addEventListener;
-WebSocket.prototype.removeEventListener = removeEventListener;
+WebSocket.prototype.addEventListener = EventTarget.addEventListener;
+WebSocket.prototype.removeEventListener = EventTarget.removeEventListener;
 
 module.exports = WebSocket;
@@ -449 +426 @@
  *
  * @param {WebSocket} websocket The client to initialize
- * @param {(String|url.URL)} address The URL to which to connect
- * @param {String} [protocols] The subprotocols
- * @param {Object} [options] Connection options
- * @param {(Boolean|Object)} [options.perMessageDeflate=true] Enable/disable
+ * @param {(String|url.Url|url.URL)} address The URL to which to connect
+ * @param {String} protocols The subprotocols
+ * @param {Object} options Connection options
+ * @param {(Boolean|Object)} options.perMessageDeflate Enable/disable
  *     permessage-deflate
- * @param {Number} [options.handshakeTimeout] Timeout in milliseconds for the
+ * @param {Number} options.handshakeTimeout Timeout in milliseconds for the
  *     handshake request
- * @param {Number} [options.protocolVersion=13] Value of the
- *     `Sec-WebSocket-Version` header
- * @param {String} [options.origin] Value of the `Origin` or
+ * @param {Number} options.protocolVersion Value of the `Sec-WebSocket-Version`
+ *     header
+ * @param {String} options.origin Value of the `Origin` or
  *     `Sec-WebSocket-Origin` header
- * @param {Number} [options.maxPayload=104857600] The maximum allowed message
- *     size
- * @param {Boolean} [options.followRedirects=false] Whether or not to follow
- *     redirects
- * @param {Number} [options.maxRedirects=10] The maximum number of redirects
- *     allowed
+ * @param {Number} options.maxPayload The maximum allowed message size
+ * @param {Boolean} options.followRedirects Whether or not to follow redirects
+ * @param {Number} options.maxRedirects The maximum number of redirects allowed
  * @private
  */
 function initAsClient(websocket, address, protocols, options) {
-  const opts = {
-    protocolVersion: protocolVersions[1],
-    maxPayload: 100 * 1024 * 1024,
-    perMessageDeflate: true,
-    followRedirects: false,
-    maxRedirects: 10,
-    ...options,
-    createConnection: undefined,
-    socketPath: undefined,
-    hostname: undefined,
-    protocol: undefined,
-    timeout: undefined,
-    method: undefined,
-    host: undefined,
-    path: undefined,
-    port: undefined
-  };
+  const opts = Object.assign(
+    {
+      protocolVersion: protocolVersions[1],
+      maxPayload: 100 * 1024 * 1024,
+      perMessageDeflate: true,
+      followRedirects: false,
+      maxRedirects: 10
+    },
+    options,
+    {
+      createConnection: undefined,
+      socketPath: undefined,
+      hostname: undefined,
+      protocol: undefined,
+      timeout: undefined,
+      method: undefined,
+      auth: undefined,
+      host: undefined,
+      path: undefined,
+      port: undefined
+    }
+  );
 
   if (!protocolVersions.includes(opts.protocolVersion)) {
@@ -494 +473 @@
   }
 
-  let parsedUrl;
-
-  if (address instanceof URL) {
+  var parsedUrl;
+
+  if (typeof address === 'object' && address.href !== undefined) {
     parsedUrl = address;
-    websocket._url = address.href;
+    websocket.url = address.href;
   } else {
-    parsedUrl = new URL(address);
-    websocket._url = address;
+    //
+    // The WHATWG URL constructor is not available on Node.js < 6.13.0
+    //
+    parsedUrl = url.URL ? new url.URL(address) : url.parse(address);
+    websocket.url = address;
   }
 
@@ -513 +495 @@
     parsedUrl.protocol === 'wss:' || parsedUrl.protocol === 'https:';
   const defaultPort = isSecure ? 443 : 80;
-  const key = randomBytes(16).toString('base64');
+  const key = crypto.randomBytes(16).toString('base64');
   const get = isSecure ? https.get : http.get;
-  let perMessageDeflate;
+  const path = parsedUrl.search
+    ? `${parsedUrl.pathname || '/'}${parsedUrl.search}`
+    : parsedUrl.pathname || '/';
+  var perMessageDeflate;
 
   opts.createConnection = isSecure ? tlsConnect : netConnect;
@@ -523 +508 @@
     ? parsedUrl.hostname.slice(1, -1)
     : parsedUrl.hostname;
-  opts.headers = {
-    'Sec-WebSocket-Version': opts.protocolVersion,
-    'Sec-WebSocket-Key': key,
-    Connection: 'Upgrade',
-    Upgrade: 'websocket',
-    ...opts.headers
-  };
-  opts.path = parsedUrl.pathname + parsedUrl.search;
+  opts.headers = Object.assign(
+    {
+      'Sec-WebSocket-Version': opts.protocolVersion,
+      'Sec-WebSocket-Key': key,
+      Connection: 'Upgrade',
+      Upgrade: 'websocket'
+    },
+    opts.headers
+  );
+  opts.path = path;
   opts.timeout = opts.handshakeTimeout;
 
@@ -539 +526 @@
       opts.maxPayload
     );
-    opts.headers['Sec-WebSocket-Extensions'] = format({
+    opts.headers['Sec-WebSocket-Extensions'] = extension.format({
       [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
     });
@@ -553 +540 @@
     }
   }
-  if (parsedUrl.username || parsedUrl.password) {
+  if (parsedUrl.auth) {
+    opts.auth = parsedUrl.auth;
+  } else if (parsedUrl.username || parsedUrl.password) {
     opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
   }
 
   if (isUnixSocket) {
-    const parts = opts.path.split(':');
+    const parts = path.split(':');
 
     opts.socketPath = parts[0];
@@ -564 +553 @@
   }
 
-  let req = (websocket._req = get(opts));
+  var req = (websocket._req = get(opts));
 
   if (opts.timeout) {
@@ -573 +562 @@
 
   req.on('error', (err) => {
-    if (req === null || req.aborted) return;
+    if (websocket._req.aborted) return;
 
     req = websocket._req = null;
-    websocket._readyState = WebSocket.CLOSING;
+    websocket.readyState = WebSocket.CLOSING;
     websocket.emit('error', err);
     websocket.emitClose();
@@ -598 +587 @@
       req.abort();
 
-      const addr = new URL(location, address);
+      const addr = url.URL
+        ? new url.URL(location, address)
+        : url.resolve(address, location);
 
       initAsClient(websocket, addr, protocols, options);
@@ -621 +612 @@
     req = websocket._req = null;
 
-    const digest = createHash('sha1')
+    const digest = crypto
+      .createHash('sha1')
       .update(key + GUID)
       .digest('base64');
@@ -632 +624 @@
     const serverProt = res.headers['sec-websocket-protocol'];
     const protList = (protocols || '').split(/, */);
-    let protError;
+    var protError;
 
     if (!protocols && serverProt) {
@@ -647 +639 @@
     }
 
-    if (serverProt) websocket._protocol = serverProt;
+    if (serverProt) websocket.protocol = serverProt;
 
     if (perMessageDeflate) {
       try {
-        const extensions = parse(res.headers['sec-websocket-extensions']);
+        const extensions = extension.parse(
+          res.headers['sec-websocket-extensions']
+        );
 
         if (extensions[PerMessageDeflate.extensionName]) {
           perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
-          websocket._extensions[PerMessageDeflate.extensionName] =
-            perMessageDeflate;
+          websocket._extensions[
+            PerMessageDeflate.extensionName
+          ] = perMessageDeflate;
         }
       } catch (err) {
@@ -680 +675 @@
  */
 function netConnect(options) {
-  options.path = options.socketPath;
+  //
+  // Override `options.path` only if `options` is a copy of the original options
+  // object. This is always true on Node.js >= 8 but not on Node.js 6 where
+  // `options.socketPath` might be `undefined` even if the `socketPath` option
+  // was originally set.
+  //
+  if (options.protocolVersion) options.path = options.socketPath;
   return net.connect(options);
 }
@@ -693 +694 @@
 function tlsConnect(options) {
   options.path = undefined;
-
-  if (!options.servername && options.servername !== '') {
-    options.servername = net.isIP(options.host) ? '' : options.host;
-  }
-
+  options.servername = options.servername || options.host;
   return tls.connect(options);
 }
@@ -711 +708 @@
  */
 function abortHandshake(websocket, stream, message) {
-  websocket._readyState = WebSocket.CLOSING;
+  websocket.readyState = WebSocket.CLOSING;
 
   const err = new Error(message);
@@ -718 +715 @@
   if (stream.setHeader) {
     stream.abort();
-
-    if (stream.socket && !stream.socket.destroyed) {
-      //
-      // On Node.js >= 14.3.0 `request.abort()` does not destroy the socket if
-      // called after the request completed. See
-      // https://github.com/websockets/ws/issues/1869.
-      //
-      stream.socket.destroy();
-    }
-
     stream.once('abort', websocket.emitClose.bind(websocket));
     websocket.emit('error', err);
@@ -738 +725 @@
 
 /**
- * Handle cases where the `ping()`, `pong()`, or `send()` methods are called
- * when the `readyState` attribute is `CLOSING` or `CLOSED`.
- *
- * @param {WebSocket} websocket The WebSocket instance
- * @param {*} [data] The data to send
- * @param {Function} [cb] Callback
- * @private
- */
-function sendAfterClose(websocket, data, cb) {
-  if (data) {
-    const length = toBuffer(data).length;
-
-    //
-    // The `_bufferedAmount` property is used only when the peer is a client and
-    // the opening handshake fails. Under these circumstances, in fact, the
-    // `setSocket()` method is not called, so the `_socket` and `_sender`
-    // properties are set to `null`.
-    //
-    if (websocket._socket) websocket._sender._bufferedBytes += length;
-    else websocket._bufferedAmount += length;
-  }
-
-  if (cb) {
-    const err = new Error(
-      `WebSocket is not open: readyState ${websocket.readyState} ` +
-        `(${readyStates[websocket.readyState]})`
-    );
-    cb(err);
-  }
-}
-
-/**
  * The listener of the `Receiver` `'conclude'` event.
  *
@@ -810 +765 @@
   websocket._socket.removeListener('data', socketOnData);
 
-  websocket._readyState = WebSocket.CLOSING;
+  websocket.readyState = WebSocket.CLOSING;
   websocket._closeCode = err[kStatusCode];
   websocket.emit('error', err);
@@ -869 +824 @@
   this.removeListener('end', socketOnEnd);
 
-  websocket._readyState = WebSocket.CLOSING;
+  websocket.readyState = WebSocket.CLOSING;
 
   //
@@ -920 +875 @@
   const websocket = this[kWebSocket];
 
-  websocket._readyState = WebSocket.CLOSING;
+  websocket.readyState = WebSocket.CLOSING;
   websocket._receiver.end();
   this.end();
@@ -936 +891 @@
   this.on('error', NOOP);
 
-  if (websocket) {
-    websocket._readyState = WebSocket.CLOSING;
-    this.destroy();
-  }
-}
+  websocket.readyState = WebSocket.CLOSING;
+  this.destroy();
+}