Buckets:
| const { webidl } = require('../fetch/webidl') | |
| const { URLSerializer } = require('../fetch/data-url') | |
| const { environmentSettingsObject } = require('../fetch/util') | |
| const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = require('./constants') | |
| const { | |
| kWebSocketURL, | |
| kReadyState, | |
| kController, | |
| kBinaryType, | |
| kResponse, | |
| kSentClose, | |
| kByteParser | |
| } = require('./symbols') | |
| const { | |
| isConnecting, | |
| isEstablished, | |
| isClosing, | |
| isValidSubprotocol, | |
| fireEvent | |
| } = require('./util') | |
| const { establishWebSocketConnection, closeWebSocketConnection } = require('./connection') | |
| const { ByteParser } = require('./receiver') | |
| const { kEnumerableProperty, isBlobLike } = require('../../core/util') | |
| const { getGlobalDispatcher } = require('../../global') | |
| const { types } = require('node:util') | |
| const { ErrorEvent, CloseEvent } = require('./events') | |
| const { SendQueue } = require('./sender') | |
| // https://websockets.spec.whatwg.org/#interface-definition | |
| class WebSocket extends EventTarget { | |
| #events = { | |
| open: null, | |
| error: null, | |
| close: null, | |
| message: null | |
| } | |
| #bufferedAmount = 0 | |
| #protocol = '' | |
| #extensions = '' | |
| /** @type {SendQueue} */ | |
| #sendQueue | |
| /** | |
| * @param {string} url | |
| * @param {string|string[]} protocols | |
| */ | |
| constructor (url, protocols = []) { | |
| super() | |
| webidl.util.markAsUncloneable(this) | |
| const prefix = 'WebSocket constructor' | |
| webidl.argumentLengthCheck(arguments, 1, prefix) | |
| const options = webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'](protocols, prefix, 'options') | |
| url = webidl.converters.USVString(url, prefix, 'url') | |
| protocols = options.protocols | |
| // 1. Let baseURL be this's relevant settings object's API base URL. | |
| const baseURL = environmentSettingsObject.settingsObject.baseUrl | |
| // 1. Let urlRecord be the result of applying the URL parser to url with baseURL. | |
| let urlRecord | |
| try { | |
| urlRecord = new URL(url, baseURL) | |
| } catch (e) { | |
| // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException. | |
| throw new DOMException(e, 'SyntaxError') | |
| } | |
| // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws". | |
| if (urlRecord.protocol === 'http:') { | |
| urlRecord.protocol = 'ws:' | |
| } else if (urlRecord.protocol === 'https:') { | |
| // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss". | |
| urlRecord.protocol = 'wss:' | |
| } | |
| // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException. | |
| if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') { | |
| throw new DOMException( | |
| `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`, | |
| 'SyntaxError' | |
| ) | |
| } | |
| // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError" | |
| // DOMException. | |
| if (urlRecord.hash || urlRecord.href.endsWith('#')) { | |
| throw new DOMException('Got fragment', 'SyntaxError') | |
| } | |
| // 8. If protocols is a string, set protocols to a sequence consisting | |
| // of just that string. | |
| if (typeof protocols === 'string') { | |
| protocols = [protocols] | |
| } | |
| // 9. If any of the values in protocols occur more than once or otherwise | |
| // fail to match the requirements for elements that comprise the value | |
| // of `Sec-WebSocket-Protocol` fields as defined by The WebSocket | |
| // protocol, then throw a "SyntaxError" DOMException. | |
| if (protocols.length !== new Set(protocols.map(p => p.toLowerCase())).size) { | |
| throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError') | |
| } | |
| if (protocols.length > 0 && !protocols.every(p => isValidSubprotocol(p))) { | |
| throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError') | |
| } | |
| // 10. Set this's url to urlRecord. | |
| this[kWebSocketURL] = new URL(urlRecord.href) | |
| // 11. Let client be this's relevant settings object. | |
| const client = environmentSettingsObject.settingsObject | |
| // 12. Run this step in parallel: | |
| // 1. Establish a WebSocket connection given urlRecord, protocols, | |
| // and client. | |
| this[kController] = establishWebSocketConnection( | |
| urlRecord, | |
| protocols, | |
| client, | |
| this, | |
| (response, extensions) => this.#onConnectionEstablished(response, extensions), | |
| options | |
| ) | |
| // Each WebSocket object has an associated ready state, which is a | |
| // number representing the state of the connection. Initially it must | |
| // be CONNECTING (0). | |
| this[kReadyState] = WebSocket.CONNECTING | |
| this[kSentClose] = sentCloseFrameState.NOT_SENT | |
| // The extensions attribute must initially return the empty string. | |
| // The protocol attribute must initially return the empty string. | |
| // Each WebSocket object has an associated binary type, which is a | |
| // BinaryType. Initially it must be "blob". | |
| this[kBinaryType] = 'blob' | |
| } | |
| /** | |
| * @see https://websockets.spec.whatwg.org/#dom-websocket-close | |
| * @param {number|undefined} code | |
| * @param {string|undefined} reason | |
| */ | |
| close (code = undefined, reason = undefined) { | |
| webidl.brandCheck(this, WebSocket) | |
| const prefix = 'WebSocket.close' | |
| if (code !== undefined) { | |
| code = webidl.converters['unsigned short'](code, prefix, 'code', { clamp: true }) | |
| } | |
| if (reason !== undefined) { | |
| reason = webidl.converters.USVString(reason, prefix, 'reason') | |
| } | |
| // 1. If code is present, but is neither an integer equal to 1000 nor an | |
| // integer in the range 3000 to 4999, inclusive, throw an | |
| // "InvalidAccessError" DOMException. | |
| if (code !== undefined) { | |
| if (code !== 1000 && (code < 3000 || code > 4999)) { | |
| throw new DOMException('invalid code', 'InvalidAccessError') | |
| } | |
| } | |
| let reasonByteLength = 0 | |
| // 2. If reason is present, then run these substeps: | |
| if (reason !== undefined) { | |
| // 1. Let reasonBytes be the result of encoding reason. | |
| // 2. If reasonBytes is longer than 123 bytes, then throw a | |
| // "SyntaxError" DOMException. | |
| reasonByteLength = Buffer.byteLength(reason) | |
| if (reasonByteLength > 123) { | |
| throw new DOMException( | |
| `Reason must be less than 123 bytes; received ${reasonByteLength}`, | |
| 'SyntaxError' | |
| ) | |
| } | |
| } | |
| // 3. Run the first matching steps from the following list: | |
| closeWebSocketConnection(this, code, reason, reasonByteLength) | |
| } | |
| /** | |
| * @see https://websockets.spec.whatwg.org/#dom-websocket-send | |
| * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data | |
| */ | |
| send (data) { | |
| webidl.brandCheck(this, WebSocket) | |
| const prefix = 'WebSocket.send' | |
| webidl.argumentLengthCheck(arguments, 1, prefix) | |
| data = webidl.converters.WebSocketSendData(data, prefix, 'data') | |
| // 1. If this's ready state is CONNECTING, then throw an | |
| // "InvalidStateError" DOMException. | |
| if (isConnecting(this)) { | |
| throw new DOMException('Sent before connected.', 'InvalidStateError') | |
| } | |
| // 2. Run the appropriate set of steps from the following list: | |
| // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1 | |
| // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2 | |
| if (!isEstablished(this) || isClosing(this)) { | |
| return | |
| } | |
| // If data is a string | |
| if (typeof data === 'string') { | |
| // If the WebSocket connection is established and the WebSocket | |
| // closing handshake has not yet started, then the user agent | |
| // must send a WebSocket Message comprised of the data argument | |
| // using a text frame opcode; if the data cannot be sent, e.g. | |
| // because it would need to be buffered but the buffer is full, | |
| // the user agent must flag the WebSocket as full and then close | |
| // the WebSocket connection. Any invocation of this method with a | |
| // string argument that does not throw an exception must increase | |
| // the bufferedAmount attribute by the number of bytes needed to | |
| // express the argument as UTF-8. | |
| const length = Buffer.byteLength(data) | |
| this.#bufferedAmount += length | |
| this.#sendQueue.add(data, () => { | |
| this.#bufferedAmount -= length | |
| }, sendHints.string) | |
| } else if (types.isArrayBuffer(data)) { | |
| // If the WebSocket connection is established, and the WebSocket | |
| // closing handshake has not yet started, then the user agent must | |
| // send a WebSocket Message comprised of data using a binary frame | |
| // opcode; if the data cannot be sent, e.g. because it would need | |
| // to be buffered but the buffer is full, the user agent must flag | |
| // the WebSocket as full and then close the WebSocket connection. | |
| // The data to be sent is the data stored in the buffer described | |
| // by the ArrayBuffer object. Any invocation of this method with an | |
| // ArrayBuffer argument that does not throw an exception must | |
| // increase the bufferedAmount attribute by the length of the | |
| // ArrayBuffer in bytes. | |
| this.#bufferedAmount += data.byteLength | |
| this.#sendQueue.add(data, () => { | |
| this.#bufferedAmount -= data.byteLength | |
| }, sendHints.arrayBuffer) | |
| } else if (ArrayBuffer.isView(data)) { | |
| // If the WebSocket connection is established, and the WebSocket | |
| // closing handshake has not yet started, then the user agent must | |
| // send a WebSocket Message comprised of data using a binary frame | |
| // opcode; if the data cannot be sent, e.g. because it would need to | |
| // be buffered but the buffer is full, the user agent must flag the | |
| // WebSocket as full and then close the WebSocket connection. The | |
| // data to be sent is the data stored in the section of the buffer | |
| // described by the ArrayBuffer object that data references. Any | |
| // invocation of this method with this kind of argument that does | |
| // not throw an exception must increase the bufferedAmount attribute | |
| // by the length of data’s buffer in bytes. | |
| this.#bufferedAmount += data.byteLength | |
| this.#sendQueue.add(data, () => { | |
| this.#bufferedAmount -= data.byteLength | |
| }, sendHints.typedArray) | |
| } else if (isBlobLike(data)) { | |
| // If the WebSocket connection is established, and the WebSocket | |
| // closing handshake has not yet started, then the user agent must | |
| // send a WebSocket Message comprised of data using a binary frame | |
| // opcode; if the data cannot be sent, e.g. because it would need to | |
| // be buffered but the buffer is full, the user agent must flag the | |
| // WebSocket as full and then close the WebSocket connection. The data | |
| // to be sent is the raw data represented by the Blob object. Any | |
| // invocation of this method with a Blob argument that does not throw | |
| // an exception must increase the bufferedAmount attribute by the size | |
| // of the Blob object’s raw data, in bytes. | |
| this.#bufferedAmount += data.size | |
| this.#sendQueue.add(data, () => { | |
| this.#bufferedAmount -= data.size | |
| }, sendHints.blob) | |
| } | |
| } | |
| get readyState () { | |
| webidl.brandCheck(this, WebSocket) | |
| // The readyState getter steps are to return this's ready state. | |
| return this[kReadyState] | |
| } | |
| get bufferedAmount () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#bufferedAmount | |
| } | |
| get url () { | |
| webidl.brandCheck(this, WebSocket) | |
| // The url getter steps are to return this's url, serialized. | |
| return URLSerializer(this[kWebSocketURL]) | |
| } | |
| get extensions () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#extensions | |
| } | |
| get protocol () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#protocol | |
| } | |
| get onopen () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#events.open | |
| } | |
| set onopen (fn) { | |
| webidl.brandCheck(this, WebSocket) | |
| if (this.#events.open) { | |
| this.removeEventListener('open', this.#events.open) | |
| } | |
| if (typeof fn === 'function') { | |
| this.#events.open = fn | |
| this.addEventListener('open', fn) | |
| } else { | |
| this.#events.open = null | |
| } | |
| } | |
| get onerror () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#events.error | |
| } | |
| set onerror (fn) { | |
| webidl.brandCheck(this, WebSocket) | |
| if (this.#events.error) { | |
| this.removeEventListener('error', this.#events.error) | |
| } | |
| if (typeof fn === 'function') { | |
| this.#events.error = fn | |
| this.addEventListener('error', fn) | |
| } else { | |
| this.#events.error = null | |
| } | |
| } | |
| get onclose () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#events.close | |
| } | |
| set onclose (fn) { | |
| webidl.brandCheck(this, WebSocket) | |
| if (this.#events.close) { | |
| this.removeEventListener('close', this.#events.close) | |
| } | |
| if (typeof fn === 'function') { | |
| this.#events.close = fn | |
| this.addEventListener('close', fn) | |
| } else { | |
| this.#events.close = null | |
| } | |
| } | |
| get onmessage () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this.#events.message | |
| } | |
| set onmessage (fn) { | |
| webidl.brandCheck(this, WebSocket) | |
| if (this.#events.message) { | |
| this.removeEventListener('message', this.#events.message) | |
| } | |
| if (typeof fn === 'function') { | |
| this.#events.message = fn | |
| this.addEventListener('message', fn) | |
| } else { | |
| this.#events.message = null | |
| } | |
| } | |
| get binaryType () { | |
| webidl.brandCheck(this, WebSocket) | |
| return this[kBinaryType] | |
| } | |
| set binaryType (type) { | |
| webidl.brandCheck(this, WebSocket) | |
| if (type !== 'blob' && type !== 'arraybuffer') { | |
| this[kBinaryType] = 'blob' | |
| } else { | |
| this[kBinaryType] = type | |
| } | |
| } | |
| /** | |
| * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol | |
| */ | |
| #onConnectionEstablished (response, parsedExtensions) { | |
| // processResponse is called when the "response's header list has been received and initialized." | |
| // once this happens, the connection is open | |
| this[kResponse] = response | |
| const webSocketOptions = this[kController]?.dispatcher?.webSocketOptions | |
| const maxFragments = webSocketOptions?.maxFragments | |
| const maxPayloadSize = webSocketOptions?.maxPayloadSize | |
| const parser = new ByteParser(this, parsedExtensions, { | |
| maxFragments, | |
| maxPayloadSize | |
| }) | |
| parser.on('drain', onParserDrain) | |
| parser.on('error', onParserError.bind(this)) | |
| response.socket.ws = this | |
| this[kByteParser] = parser | |
| this.#sendQueue = new SendQueue(response.socket) | |
| // 1. Change the ready state to OPEN (1). | |
| this[kReadyState] = states.OPEN | |
| // 2. Change the extensions attribute’s value to the extensions in use, if | |
| // it is not the null value. | |
| // https://datatracker.ietf.org/doc/html/rfc6455#section-9.1 | |
| const extensions = response.headersList.get('sec-websocket-extensions') | |
| if (extensions !== null) { | |
| this.#extensions = extensions | |
| } | |
| // 3. Change the protocol attribute’s value to the subprotocol in use, if | |
| // it is not the null value. | |
| // https://datatracker.ietf.org/doc/html/rfc6455#section-1.9 | |
| const protocol = response.headersList.get('sec-websocket-protocol') | |
| if (protocol !== null) { | |
| this.#protocol = protocol | |
| } | |
| // 4. Fire an event named open at the WebSocket object. | |
| fireEvent('open', this) | |
| } | |
| } | |
| // https://websockets.spec.whatwg.org/#dom-websocket-connecting | |
| WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING | |
| // https://websockets.spec.whatwg.org/#dom-websocket-open | |
| WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN | |
| // https://websockets.spec.whatwg.org/#dom-websocket-closing | |
| WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING | |
| // https://websockets.spec.whatwg.org/#dom-websocket-closed | |
| WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED | |
| Object.defineProperties(WebSocket.prototype, { | |
| CONNECTING: staticPropertyDescriptors, | |
| OPEN: staticPropertyDescriptors, | |
| CLOSING: staticPropertyDescriptors, | |
| CLOSED: staticPropertyDescriptors, | |
| url: kEnumerableProperty, | |
| readyState: kEnumerableProperty, | |
| bufferedAmount: kEnumerableProperty, | |
| onopen: kEnumerableProperty, | |
| onerror: kEnumerableProperty, | |
| onclose: kEnumerableProperty, | |
| close: kEnumerableProperty, | |
| onmessage: kEnumerableProperty, | |
| binaryType: kEnumerableProperty, | |
| send: kEnumerableProperty, | |
| extensions: kEnumerableProperty, | |
| protocol: kEnumerableProperty, | |
| [Symbol.toStringTag]: { | |
| value: 'WebSocket', | |
| writable: false, | |
| enumerable: false, | |
| configurable: true | |
| } | |
| }) | |
| Object.defineProperties(WebSocket, { | |
| CONNECTING: staticPropertyDescriptors, | |
| OPEN: staticPropertyDescriptors, | |
| CLOSING: staticPropertyDescriptors, | |
| CLOSED: staticPropertyDescriptors | |
| }) | |
| webidl.converters['sequence<DOMString>'] = webidl.sequenceConverter( | |
| webidl.converters.DOMString | |
| ) | |
| webidl.converters['DOMString or sequence<DOMString>'] = function (V, prefix, argument) { | |
| if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) { | |
| return webidl.converters['sequence<DOMString>'](V) | |
| } | |
| return webidl.converters.DOMString(V, prefix, argument) | |
| } | |
| // This implements the proposal made in https://github.com/whatwg/websockets/issues/42 | |
| webidl.converters.WebSocketInit = webidl.dictionaryConverter([ | |
| { | |
| key: 'protocols', | |
| converter: webidl.converters['DOMString or sequence<DOMString>'], | |
| defaultValue: () => new Array(0) | |
| }, | |
| { | |
| key: 'dispatcher', | |
| converter: webidl.converters.any, | |
| defaultValue: () => getGlobalDispatcher() | |
| }, | |
| { | |
| key: 'headers', | |
| converter: webidl.nullableConverter(webidl.converters.HeadersInit) | |
| } | |
| ]) | |
| webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = function (V) { | |
| if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) { | |
| return webidl.converters.WebSocketInit(V) | |
| } | |
| return { protocols: webidl.converters['DOMString or sequence<DOMString>'](V) } | |
| } | |
| webidl.converters.WebSocketSendData = function (V) { | |
| if (webidl.util.Type(V) === 'Object') { | |
| if (isBlobLike(V)) { | |
| return webidl.converters.Blob(V, { strict: false }) | |
| } | |
| if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) { | |
| return webidl.converters.BufferSource(V) | |
| } | |
| } | |
| return webidl.converters.USVString(V) | |
| } | |
| function onParserDrain () { | |
| this.ws[kResponse].socket.resume() | |
| } | |
| function onParserError (err) { | |
| let message | |
| let code | |
| if (err instanceof CloseEvent) { | |
| message = err.reason | |
| code = err.code | |
| } else { | |
| message = err.message | |
| } | |
| fireEvent('error', this, () => new ErrorEvent('error', { error: err, message })) | |
| closeWebSocketConnection(this, code) | |
| } | |
| module.exports = { | |
| WebSocket | |
| } | |
Xet Storage Details
- Size:
- 18.7 kB
- Xet hash:
- 29316782098e90ccc9fd1152205f1112c8fb7ec540392aa415f5a786324e1ea8
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.