Index: node_modules/@stomp/stompjs/LICENSE =================================================================== --- node_modules/@stomp/stompjs/LICENSE (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/LICENSE (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2018-2020 Deepak Kumar + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. Index: node_modules/@stomp/stompjs/README.md =================================================================== --- node_modules/@stomp/stompjs/README.md (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/README.md (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,147 @@ +# STOMP.js + +[![Firefox, Chrome](https://github.com/stomp-js/stompjs/actions/workflows/linux.yml/badge.svg?branch=develop)](https://github.com/stomp-js/stompjs/actions/workflows/linux.yml) +[![Safari, Edge](https://github.com/stomp-js/stompjs/actions/workflows/osx.yml/badge.svg?branch=develop)](https://github.com/stomp-js/stompjs/actions/workflows/osx.yml) +[![NodeJS Test](https://github.com/stomp-js/stompjs/actions/workflows/node-js.yml/badge.svg?branch=develop)](https://github.com/stomp-js/stompjs/actions/workflows/node-js.yml) +[![API docs refresh](https://github.com/stomp-js/stompjs/actions/workflows/docs-refresh.yml/badge.svg?branch=develop)](https://github.com/stomp-js/stompjs/actions/workflows/docs-refresh.yml) + +This library provides a STOMP over WebSocket client for Web browser and node.js applications. + +Please visit https://stomp-js.github.io/ for guides, FAQs and API docs. + +# Introduction + +This library allows you to connect to a STOMP broker over WebSocket. This library +supports complete STOMP specifications including all current protocol variants. Most +popular messaging brokers support STOMP and STOMP over WebSockets out-of-the-box +or using plugins. + +## Features + +- Simple API to interact with the Stomp protocol +- Support for v1.2, v1.1 and v1.0 of the Stomp protocol +- Support for fallback options in case of WebSocket unavailable +- Browser and Node.js support +- Option to use STOMP over TCP +- Binary payload support + +## Usage + +### Browser + +```html + + + + + + + +``` + +### NodeJS + +```bash +$ npm install @stomp/stompjs ws +``` + +```javascript +import { Client } from '@stomp/stompjs'; + +import { WebSocket } from 'ws'; +Object.assign(global, { WebSocket }); + +const client = new Client({ + brokerURL: 'ws://localhost:15674/ws', + onConnect: () => { + client.subscribe('/topic/test01', message => + console.log(`Received: ${message.body}`) + ); + client.publish({ destination: '/topic/test01', body: 'First Message' }); + }, +}); + +client.activate(); +``` + +## Further information + +The API documentation is hosted as GitHub pages for the StompJS family of libraries. +You may head straight to the https://stomp-js.github.io/api-docs/latest/ + +This library comes with detailed usage instructions. Please find it at +[Usage instructions](https://stomp-js.github.io/guide/stompjs/using-stompjs-v5.html). +Check out other guides at https://stomp-js.github.io/. + +There is quite detailed API documentation, +you should start at https://stomp-js.github.io/api-docs/latest/classes/Client.html. + +## Upgrading + +if you were using an older version of this library, you would need to make changes +to your code. Head to +[Upgrading](https://stomp-js.github.io/#upgrading). + +## Usage with RxJS + +https://github.com/stomp-js/rx-stomp is based on this library and exposes the entire functionality +offered by this library as RxJS Observables. + +## TypeScript definitions + +The npm package includes TypeScript definitions, so there is no need to install it separately. + +## Change-log + +Please visit [Change Log](Change-log.md). + +## Contributing + +If you want to understand the code, develop, or contribute. Please visit +[How to contribute](Contribute.md). + +## Authors + +- [Jeff Mesnil](http://jmesnil.net/) +- [Jeff Lindsay](http://github.com/progrium) +- [Vanessa Williams](http://github.com/fridgebuzz) +- [Deepak Kumar](https://github.com/kum-deepak) +- [Astha Deep](https://github.com/astha183) +- [Dillon Sellars](https://github.com/dillon-sellars) +- [Jimi Charalampidis](https://github.com/jimic) +- [Raul](https://github.com/rulonder) +- [Dimitar Georgiev](https://github.com/iMitaka) +- [Genadi](https://github.com/genadis) +- [Bobohuochai](https://github.com/bobohuochai) +- [Sailai](https://github.com/sailai) + +## License + +[License](LICENSE) - Apache-2.0 Index: node_modules/@stomp/stompjs/bundles/package.json =================================================================== --- node_modules/@stomp/stompjs/bundles/package.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/bundles/package.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,6 @@ +{ + "name": "spec", + "version": "1.0.0", + "description": "Just for running specs with commonjs modules", + "type": "commonjs" +} Index: node_modules/@stomp/stompjs/bundles/stomp.umd.js =================================================================== --- node_modules/@stomp/stompjs/bundles/stomp.umd.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/bundles/stomp.umd.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1879 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : + typeof define === 'function' && define.amd ? define(['exports'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.StompJs = {})); +})(this, (function (exports) { 'use strict'; + + /** + * Some byte values, used as per STOMP specifications. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ + const BYTE = { + // LINEFEED byte (octet 10) + LF: '\x0A', + // NULL byte (octet 0) + NULL: '\x00', + }; + + /** + * Frame class represents a STOMP frame. + * + * @internal + */ + class FrameImpl { + /** + * Frame constructor. `command`, `headers` and `body` are available as properties. + * + * @internal + */ + constructor(params) { + const { command, headers, body, binaryBody, escapeHeaderValues, skipContentLengthHeader, } = params; + this.command = command; + this.headers = Object.assign({}, headers || {}); + if (binaryBody) { + this._binaryBody = binaryBody; + this.isBinaryBody = true; + } + else { + this._body = body || ''; + this.isBinaryBody = false; + } + this.escapeHeaderValues = escapeHeaderValues || false; + this.skipContentLengthHeader = skipContentLengthHeader || false; + } + /** + * body of the frame + */ + get body() { + if (!this._body && this.isBinaryBody) { + this._body = new TextDecoder().decode(this._binaryBody); + } + return this._body || ''; + } + /** + * body as Uint8Array + */ + get binaryBody() { + if (!this._binaryBody && !this.isBinaryBody) { + this._binaryBody = new TextEncoder().encode(this._body); + } + // At this stage it will definitely have a valid value + return this._binaryBody; + } + /** + * deserialize a STOMP Frame from raw data. + * + * @internal + */ + static fromRawFrame(rawFrame, escapeHeaderValues) { + const headers = {}; + const trim = (str) => str.replace(/^\s+|\s+$/g, ''); + // In case of repeated headers, as per standards, first value need to be used + for (const header of rawFrame.headers.reverse()) { + header.indexOf(':'); + const key = trim(header[0]); + let value = trim(header[1]); + if (escapeHeaderValues && + rawFrame.command !== 'CONNECT' && + rawFrame.command !== 'CONNECTED') { + value = FrameImpl.hdrValueUnEscape(value); + } + headers[key] = value; + } + return new FrameImpl({ + command: rawFrame.command, + headers, + binaryBody: rawFrame.binaryBody, + escapeHeaderValues, + }); + } + /** + * @internal + */ + toString() { + return this.serializeCmdAndHeaders(); + } + /** + * serialize this Frame in a format suitable to be passed to WebSocket. + * If the body is string the output will be string. + * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer. + * + * @internal + */ + serialize() { + const cmdAndHeaders = this.serializeCmdAndHeaders(); + if (this.isBinaryBody) { + return FrameImpl.toUnit8Array(cmdAndHeaders, this._binaryBody).buffer; + } + else { + return cmdAndHeaders + this._body + BYTE.NULL; + } + } + serializeCmdAndHeaders() { + const lines = [this.command]; + if (this.skipContentLengthHeader) { + delete this.headers['content-length']; + } + for (const name of Object.keys(this.headers || {})) { + const value = this.headers[name]; + if (this.escapeHeaderValues && + this.command !== 'CONNECT' && + this.command !== 'CONNECTED') { + lines.push(`${name}:${FrameImpl.hdrValueEscape(`${value}`)}`); + } + else { + lines.push(`${name}:${value}`); + } + } + if (this.isBinaryBody || + (!this.isBodyEmpty() && !this.skipContentLengthHeader)) { + lines.push(`content-length:${this.bodyLength()}`); + } + return lines.join(BYTE.LF) + BYTE.LF + BYTE.LF; + } + isBodyEmpty() { + return this.bodyLength() === 0; + } + bodyLength() { + const binaryBody = this.binaryBody; + return binaryBody ? binaryBody.length : 0; + } + /** + * Compute the size of a UTF-8 string by counting its number of bytes + * (and not the number of characters composing the string) + */ + static sizeOfUTF8(s) { + return s ? new TextEncoder().encode(s).length : 0; + } + static toUnit8Array(cmdAndHeaders, binaryBody) { + const uint8CmdAndHeaders = new TextEncoder().encode(cmdAndHeaders); + const nullTerminator = new Uint8Array([0]); + const uint8Frame = new Uint8Array(uint8CmdAndHeaders.length + binaryBody.length + nullTerminator.length); + uint8Frame.set(uint8CmdAndHeaders); + uint8Frame.set(binaryBody, uint8CmdAndHeaders.length); + uint8Frame.set(nullTerminator, uint8CmdAndHeaders.length + binaryBody.length); + return uint8Frame; + } + /** + * Serialize a STOMP frame as per STOMP standards, suitable to be sent to the STOMP broker. + * + * @internal + */ + static marshall(params) { + const frame = new FrameImpl(params); + return frame.serialize(); + } + /** + * Escape header values + */ + static hdrValueEscape(str) { + return str + .replace(/\\/g, '\\\\') + .replace(/\r/g, '\\r') + .replace(/\n/g, '\\n') + .replace(/:/g, '\\c'); + } + /** + * UnEscape header values + */ + static hdrValueUnEscape(str) { + return str + .replace(/\\r/g, '\r') + .replace(/\\n/g, '\n') + .replace(/\\c/g, ':') + .replace(/\\\\/g, '\\'); + } + } + + /** + * @internal + */ + const NULL = 0; + /** + * @internal + */ + const LF = 10; + /** + * @internal + */ + const CR = 13; + /** + * @internal + */ + const COLON = 58; + /** + * This is an evented, rec descent parser. + * A stream of Octets can be passed and whenever it recognizes + * a complete Frame or an incoming ping it will invoke the registered callbacks. + * + * All incoming Octets are fed into _onByte function. + * Depending on current state the _onByte function keeps changing. + * Depending on the state it keeps accumulating into _token and _results. + * State is indicated by current value of _onByte, all states are named as _collect. + * + * STOMP standards https://stomp.github.io/stomp-specification-1.2.html + * imply that all lengths are considered in bytes (instead of string lengths). + * So, before actual parsing, if the incoming data is String it is converted to Octets. + * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body. + * + * There is no peek function on the incoming data. + * When a state change occurs based on an Octet without consuming the Octet, + * the Octet, after state change, is fed again (_reinjectByte). + * This became possible as the state change can be determined by inspecting just one Octet. + * + * There are two modes to collect the body, if content-length header is there then it by counting Octets + * otherwise it is determined by NULL terminator. + * + * Following the standards, the command and headers are converted to Strings + * and the body is returned as Octets. + * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header. + * + * This parser does not use Regular Expressions as that can only operate on Strings. + * + * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or + * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk + * is pushed. + * + * Typically the higher level function will convert headers to Hash, handle unescaping of header values + * (which is protocol version specific), and convert body to text. + * + * Check the parser.spec.js to understand cases that this parser is supposed to handle. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ + class Parser { + constructor(onFrame, onIncomingPing) { + this.onFrame = onFrame; + this.onIncomingPing = onIncomingPing; + this._encoder = new TextEncoder(); + this._decoder = new TextDecoder(); + this._token = []; + this._initState(); + } + parseChunk(segment, appendMissingNULLonIncoming = false) { + let chunk; + if (typeof segment === 'string') { + chunk = this._encoder.encode(segment); + } + else { + chunk = new Uint8Array(segment); + } + // See https://github.com/stomp-js/stompjs/issues/89 + // Remove when underlying issue is fixed. + // + // Send a NULL byte, if the last byte of a Text frame was not NULL.F + if (appendMissingNULLonIncoming && chunk[chunk.length - 1] !== 0) { + const chunkWithNull = new Uint8Array(chunk.length + 1); + chunkWithNull.set(chunk, 0); + chunkWithNull[chunk.length] = 0; + chunk = chunkWithNull; + } + // tslint:disable-next-line:prefer-for-of + for (let i = 0; i < chunk.length; i++) { + const byte = chunk[i]; + this._onByte(byte); + } + } + // The following implements a simple Rec Descent Parser. + // The grammar is simple and just one byte tells what should be the next state + _collectFrame(byte) { + if (byte === NULL) { + // Ignore + return; + } + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + // Incoming Ping + this.onIncomingPing(); + return; + } + this._onByte = this._collectCommand; + this._reinjectByte(byte); + } + _collectCommand(byte) { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._results.command = this._consumeTokenAsUTF8(); + this._onByte = this._collectHeaders; + return; + } + this._consumeByte(byte); + } + _collectHeaders(byte) { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._setupCollectBody(); + return; + } + this._onByte = this._collectHeaderKey; + this._reinjectByte(byte); + } + _reinjectByte(byte) { + this._onByte(byte); + } + _collectHeaderKey(byte) { + if (byte === COLON) { + this._headerKey = this._consumeTokenAsUTF8(); + this._onByte = this._collectHeaderValue; + return; + } + this._consumeByte(byte); + } + _collectHeaderValue(byte) { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._results.headers.push([ + this._headerKey, + this._consumeTokenAsUTF8(), + ]); + this._headerKey = undefined; + this._onByte = this._collectHeaders; + return; + } + this._consumeByte(byte); + } + _setupCollectBody() { + const contentLengthHeader = this._results.headers.filter((header) => { + return header[0] === 'content-length'; + })[0]; + if (contentLengthHeader) { + this._bodyBytesRemaining = parseInt(contentLengthHeader[1], 10); + this._onByte = this._collectBodyFixedSize; + } + else { + this._onByte = this._collectBodyNullTerminated; + } + } + _collectBodyNullTerminated(byte) { + if (byte === NULL) { + this._retrievedBody(); + return; + } + this._consumeByte(byte); + } + _collectBodyFixedSize(byte) { + // It is post decrement, so that we discard the trailing NULL octet + if (this._bodyBytesRemaining-- === 0) { + this._retrievedBody(); + return; + } + this._consumeByte(byte); + } + _retrievedBody() { + this._results.binaryBody = this._consumeTokenAsRaw(); + try { + this.onFrame(this._results); + } + catch (e) { + console.log(`Ignoring an exception thrown by a frame handler. Original exception: `, e); + } + this._initState(); + } + // Rec Descent Parser helpers + _consumeByte(byte) { + this._token.push(byte); + } + _consumeTokenAsUTF8() { + return this._decoder.decode(this._consumeTokenAsRaw()); + } + _consumeTokenAsRaw() { + const rawResult = new Uint8Array(this._token); + this._token = []; + return rawResult; + } + _initState() { + this._results = { + command: undefined, + headers: [], + binaryBody: undefined, + }; + this._token = []; + this._headerKey = undefined; + this._onByte = this._collectFrame; + } + } + + /** + * Possible states for the IStompSocket + */ + exports.StompSocketState = void 0; + (function (StompSocketState) { + StompSocketState[StompSocketState["CONNECTING"] = 0] = "CONNECTING"; + StompSocketState[StompSocketState["OPEN"] = 1] = "OPEN"; + StompSocketState[StompSocketState["CLOSING"] = 2] = "CLOSING"; + StompSocketState[StompSocketState["CLOSED"] = 3] = "CLOSED"; + })(exports.StompSocketState = exports.StompSocketState || (exports.StompSocketState = {})); + /** + * Possible activation state + */ + exports.ActivationState = void 0; + (function (ActivationState) { + ActivationState[ActivationState["ACTIVE"] = 0] = "ACTIVE"; + ActivationState[ActivationState["DEACTIVATING"] = 1] = "DEACTIVATING"; + ActivationState[ActivationState["INACTIVE"] = 2] = "INACTIVE"; + })(exports.ActivationState = exports.ActivationState || (exports.ActivationState = {})); + + /** + * Supported STOMP versions + * + * Part of `@stomp/stompjs`. + */ + class Versions { + /** + * Takes an array of versions, typical elements '1.2', '1.1', or '1.0' + * + * You will be creating an instance of this class if you want to override + * supported versions to be declared during STOMP handshake. + */ + constructor(versions) { + this.versions = versions; + } + /** + * Used as part of CONNECT STOMP Frame + */ + supportedVersions() { + return this.versions.join(','); + } + /** + * Used while creating a WebSocket + */ + protocolVersions() { + return this.versions.map(x => `v${x.replace('.', '')}.stomp`); + } + } + /** + * Indicates protocol version 1.0 + */ + Versions.V1_0 = '1.0'; + /** + * Indicates protocol version 1.1 + */ + Versions.V1_1 = '1.1'; + /** + * Indicates protocol version 1.2 + */ + Versions.V1_2 = '1.2'; + /** + * @internal + */ + Versions.default = new Versions([ + Versions.V1_2, + Versions.V1_1, + Versions.V1_0, + ]); + + /** + * @internal + */ + function augmentWebsocket(webSocket, debug) { + webSocket.terminate = function () { + const noOp = () => { }; + // set all callbacks to no op + this.onerror = noOp; + this.onmessage = noOp; + this.onopen = noOp; + const ts = new Date(); + const id = Math.random().toString().substring(2, 8); // A simulated id + const origOnClose = this.onclose; + // Track delay in actual closure of the socket + this.onclose = closeEvent => { + const delay = new Date().getTime() - ts.getTime(); + debug(`Discarded socket (#${id}) closed after ${delay}ms, with code/reason: ${closeEvent.code}/${closeEvent.reason}`); + }; + this.close(); + origOnClose?.call(webSocket, { + code: 4001, + reason: `Quick discarding socket (#${id}) without waiting for the shutdown sequence.`, + wasClean: false, + }); + }; + } + + /** + * The STOMP protocol handler + * + * Part of `@stomp/stompjs`. + * + * @internal + */ + class StompHandler { + constructor(_client, _webSocket, config) { + this._client = _client; + this._webSocket = _webSocket; + this._connected = false; + this._serverFrameHandlers = { + // [CONNECTED Frame](https://stomp.github.com/stomp-specification-1.2.html#CONNECTED_Frame) + CONNECTED: frame => { + this.debug(`connected to server ${frame.headers.server}`); + this._connected = true; + this._connectedVersion = frame.headers.version; + // STOMP version 1.2 needs header values to be escaped + if (this._connectedVersion === Versions.V1_2) { + this._escapeHeaderValues = true; + } + this._setupHeartbeat(frame.headers); + this.onConnect(frame); + }, + // [MESSAGE Frame](https://stomp.github.com/stomp-specification-1.2.html#MESSAGE) + MESSAGE: frame => { + // the callback is registered when the client calls + // `subscribe()`. + // If there is no registered subscription for the received message, + // the default `onUnhandledMessage` callback is used that the client can set. + // This is useful for subscriptions that are automatically created + // on the browser side (e.g. [RabbitMQ's temporary + // queues](https://www.rabbitmq.com/stomp.html)). + const subscription = frame.headers.subscription; + const onReceive = this._subscriptions[subscription] || this.onUnhandledMessage; + // bless the frame to be a Message + const message = frame; + const client = this; + const messageId = this._connectedVersion === Versions.V1_2 + ? message.headers.ack + : message.headers['message-id']; + // add `ack()` and `nack()` methods directly to the returned frame + // so that a simple call to `message.ack()` can acknowledge the message. + message.ack = (headers = {}) => { + return client.ack(messageId, subscription, headers); + }; + message.nack = (headers = {}) => { + return client.nack(messageId, subscription, headers); + }; + onReceive(message); + }, + // [RECEIPT Frame](https://stomp.github.com/stomp-specification-1.2.html#RECEIPT) + RECEIPT: frame => { + const callback = this._receiptWatchers[frame.headers['receipt-id']]; + if (callback) { + callback(frame); + // Server will acknowledge only once, remove the callback + delete this._receiptWatchers[frame.headers['receipt-id']]; + } + else { + this.onUnhandledReceipt(frame); + } + }, + // [ERROR Frame](https://stomp.github.com/stomp-specification-1.2.html#ERROR) + ERROR: frame => { + this.onStompError(frame); + }, + }; + // used to index subscribers + this._counter = 0; + // subscription callbacks indexed by subscriber's ID + this._subscriptions = {}; + // receipt-watchers indexed by receipts-ids + this._receiptWatchers = {}; + this._partialData = ''; + this._escapeHeaderValues = false; + this._lastServerActivityTS = Date.now(); + this.debug = config.debug; + this.stompVersions = config.stompVersions; + this.connectHeaders = config.connectHeaders; + this.disconnectHeaders = config.disconnectHeaders; + this.heartbeatIncoming = config.heartbeatIncoming; + this.heartbeatOutgoing = config.heartbeatOutgoing; + this.splitLargeFrames = config.splitLargeFrames; + this.maxWebSocketChunkSize = config.maxWebSocketChunkSize; + this.forceBinaryWSFrames = config.forceBinaryWSFrames; + this.logRawCommunication = config.logRawCommunication; + this.appendMissingNULLonIncoming = config.appendMissingNULLonIncoming; + this.discardWebsocketOnCommFailure = config.discardWebsocketOnCommFailure; + this.onConnect = config.onConnect; + this.onDisconnect = config.onDisconnect; + this.onStompError = config.onStompError; + this.onWebSocketClose = config.onWebSocketClose; + this.onWebSocketError = config.onWebSocketError; + this.onUnhandledMessage = config.onUnhandledMessage; + this.onUnhandledReceipt = config.onUnhandledReceipt; + this.onUnhandledFrame = config.onUnhandledFrame; + } + get connectedVersion() { + return this._connectedVersion; + } + get connected() { + return this._connected; + } + start() { + const parser = new Parser( + // On Frame + rawFrame => { + const frame = FrameImpl.fromRawFrame(rawFrame, this._escapeHeaderValues); + // if this.logRawCommunication is set, the rawChunk is logged at this._webSocket.onmessage + if (!this.logRawCommunication) { + this.debug(`<<< ${frame}`); + } + const serverFrameHandler = this._serverFrameHandlers[frame.command] || this.onUnhandledFrame; + serverFrameHandler(frame); + }, + // On Incoming Ping + () => { + this.debug('<<< PONG'); + }); + this._webSocket.onmessage = (evt) => { + this.debug('Received data'); + this._lastServerActivityTS = Date.now(); + if (this.logRawCommunication) { + const rawChunkAsString = evt.data instanceof ArrayBuffer + ? new TextDecoder().decode(evt.data) + : evt.data; + this.debug(`<<< ${rawChunkAsString}`); + } + parser.parseChunk(evt.data, this.appendMissingNULLonIncoming); + }; + this._webSocket.onclose = (closeEvent) => { + this.debug(`Connection closed to ${this._webSocket.url}`); + this._cleanUp(); + this.onWebSocketClose(closeEvent); + }; + this._webSocket.onerror = (errorEvent) => { + this.onWebSocketError(errorEvent); + }; + this._webSocket.onopen = () => { + // Clone before updating + const connectHeaders = Object.assign({}, this.connectHeaders); + this.debug('Web Socket Opened...'); + connectHeaders['accept-version'] = this.stompVersions.supportedVersions(); + connectHeaders['heart-beat'] = [ + this.heartbeatOutgoing, + this.heartbeatIncoming, + ].join(','); + this._transmit({ command: 'CONNECT', headers: connectHeaders }); + }; + } + _setupHeartbeat(headers) { + if (headers.version !== Versions.V1_1 && + headers.version !== Versions.V1_2) { + return; + } + // It is valid for the server to not send this header + // https://stomp.github.io/stomp-specification-1.2.html#Heart-beating + if (!headers['heart-beat']) { + return; + } + // heart-beat header received from the server looks like: + // + // heart-beat: sx, sy + const [serverOutgoing, serverIncoming] = headers['heart-beat'] + .split(',') + .map((v) => parseInt(v, 10)); + if (this.heartbeatOutgoing !== 0 && serverIncoming !== 0) { + const ttl = Math.max(this.heartbeatOutgoing, serverIncoming); + this.debug(`send PING every ${ttl}ms`); + this._pinger = setInterval(() => { + if (this._webSocket.readyState === exports.StompSocketState.OPEN) { + this._webSocket.send(BYTE.LF); + this.debug('>>> PING'); + } + }, ttl); + } + if (this.heartbeatIncoming !== 0 && serverOutgoing !== 0) { + const ttl = Math.max(this.heartbeatIncoming, serverOutgoing); + this.debug(`check PONG every ${ttl}ms`); + this._ponger = setInterval(() => { + const delta = Date.now() - this._lastServerActivityTS; + // We wait twice the TTL to be flexible on window's setInterval calls + if (delta > ttl * 2) { + this.debug(`did not receive server activity for the last ${delta}ms`); + this._closeOrDiscardWebsocket(); + } + }, ttl); + } + } + _closeOrDiscardWebsocket() { + if (this.discardWebsocketOnCommFailure) { + this.debug('Discarding websocket, the underlying socket may linger for a while'); + this.discardWebsocket(); + } + else { + this.debug('Issuing close on the websocket'); + this._closeWebsocket(); + } + } + forceDisconnect() { + if (this._webSocket) { + if (this._webSocket.readyState === exports.StompSocketState.CONNECTING || + this._webSocket.readyState === exports.StompSocketState.OPEN) { + this._closeOrDiscardWebsocket(); + } + } + } + _closeWebsocket() { + this._webSocket.onmessage = () => { }; // ignore messages + this._webSocket.close(); + } + discardWebsocket() { + if (typeof this._webSocket.terminate !== 'function') { + augmentWebsocket(this._webSocket, (msg) => this.debug(msg)); + } + // @ts-ignore - this method will be there at this stage + this._webSocket.terminate(); + } + _transmit(params) { + const { command, headers, body, binaryBody, skipContentLengthHeader } = params; + const frame = new FrameImpl({ + command, + headers, + body, + binaryBody, + escapeHeaderValues: this._escapeHeaderValues, + skipContentLengthHeader, + }); + let rawChunk = frame.serialize(); + if (this.logRawCommunication) { + this.debug(`>>> ${rawChunk}`); + } + else { + this.debug(`>>> ${frame}`); + } + if (this.forceBinaryWSFrames && typeof rawChunk === 'string') { + rawChunk = new TextEncoder().encode(rawChunk); + } + if (typeof rawChunk !== 'string' || !this.splitLargeFrames) { + this._webSocket.send(rawChunk); + } + else { + let out = rawChunk; + while (out.length > 0) { + const chunk = out.substring(0, this.maxWebSocketChunkSize); + out = out.substring(this.maxWebSocketChunkSize); + this._webSocket.send(chunk); + this.debug(`chunk sent = ${chunk.length}, remaining = ${out.length}`); + } + } + } + dispose() { + if (this.connected) { + try { + // clone before updating + const disconnectHeaders = Object.assign({}, this.disconnectHeaders); + if (!disconnectHeaders.receipt) { + disconnectHeaders.receipt = `close-${this._counter++}`; + } + this.watchForReceipt(disconnectHeaders.receipt, frame => { + this._closeWebsocket(); + this._cleanUp(); + this.onDisconnect(frame); + }); + this._transmit({ command: 'DISCONNECT', headers: disconnectHeaders }); + } + catch (error) { + this.debug(`Ignoring error during disconnect ${error}`); + } + } + else { + if (this._webSocket.readyState === exports.StompSocketState.CONNECTING || + this._webSocket.readyState === exports.StompSocketState.OPEN) { + this._closeWebsocket(); + } + } + } + _cleanUp() { + this._connected = false; + if (this._pinger) { + clearInterval(this._pinger); + this._pinger = undefined; + } + if (this._ponger) { + clearInterval(this._ponger); + this._ponger = undefined; + } + } + publish(params) { + const { destination, headers, body, binaryBody, skipContentLengthHeader } = params; + const hdrs = Object.assign({ destination }, headers); + this._transmit({ + command: 'SEND', + headers: hdrs, + body, + binaryBody, + skipContentLengthHeader, + }); + } + watchForReceipt(receiptId, callback) { + this._receiptWatchers[receiptId] = callback; + } + subscribe(destination, callback, headers = {}) { + headers = Object.assign({}, headers); + if (!headers.id) { + headers.id = `sub-${this._counter++}`; + } + headers.destination = destination; + this._subscriptions[headers.id] = callback; + this._transmit({ command: 'SUBSCRIBE', headers }); + const client = this; + return { + id: headers.id, + unsubscribe(hdrs) { + return client.unsubscribe(headers.id, hdrs); + }, + }; + } + unsubscribe(id, headers = {}) { + headers = Object.assign({}, headers); + delete this._subscriptions[id]; + headers.id = id; + this._transmit({ command: 'UNSUBSCRIBE', headers }); + } + begin(transactionId) { + const txId = transactionId || `tx-${this._counter++}`; + this._transmit({ + command: 'BEGIN', + headers: { + transaction: txId, + }, + }); + const client = this; + return { + id: txId, + commit() { + client.commit(txId); + }, + abort() { + client.abort(txId); + }, + }; + } + commit(transactionId) { + this._transmit({ + command: 'COMMIT', + headers: { + transaction: transactionId, + }, + }); + } + abort(transactionId) { + this._transmit({ + command: 'ABORT', + headers: { + transaction: transactionId, + }, + }); + } + ack(messageId, subscriptionId, headers = {}) { + headers = Object.assign({}, headers); + if (this._connectedVersion === Versions.V1_2) { + headers.id = messageId; + } + else { + headers['message-id'] = messageId; + } + headers.subscription = subscriptionId; + this._transmit({ command: 'ACK', headers }); + } + nack(messageId, subscriptionId, headers = {}) { + headers = Object.assign({}, headers); + if (this._connectedVersion === Versions.V1_2) { + headers.id = messageId; + } + else { + headers['message-id'] = messageId; + } + headers.subscription = subscriptionId; + return this._transmit({ command: 'NACK', headers }); + } + } + + /** + * STOMP Client Class. + * + * Part of `@stomp/stompjs`. + */ + class Client { + /** + * Create an instance. + */ + constructor(conf = {}) { + /** + * STOMP versions to attempt during STOMP handshake. By default, versions `1.2`, `1.1`, and `1.0` are attempted. + * + * Example: + * ```javascript + * // Try only versions 1.1 and 1.0 + * client.stompVersions = new Versions(['1.1', '1.0']) + * ``` + */ + this.stompVersions = Versions.default; + /** + * Will retry if Stomp connection is not established in specified milliseconds. + * Default 0, which switches off automatic reconnection. + */ + this.connectionTimeout = 0; + /** + * automatically reconnect with delay in milliseconds, set to 0 to disable. + */ + this.reconnectDelay = 5000; + /** + * Incoming heartbeat interval in milliseconds. Set to 0 to disable. + */ + this.heartbeatIncoming = 10000; + /** + * Outgoing heartbeat interval in milliseconds. Set to 0 to disable. + */ + this.heartbeatOutgoing = 10000; + /** + * This switches on a non-standard behavior while sending WebSocket packets. + * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}. + * Only Java Spring brokers seem to support this mode. + * + * WebSockets, by itself, split large (text) packets, + * so it is not needed with a truly compliant STOMP/WebSocket broker. + * Setting it for such a broker will cause large messages to fail. + * + * `false` by default. + * + * Binary frames are never split. + */ + this.splitLargeFrames = false; + /** + * See [splitLargeFrames]{@link Client#splitLargeFrames}. + * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`. + */ + this.maxWebSocketChunkSize = 8 * 1024; + /** + * Usually the + * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters} + * is automatically decided by type of the payload. + * Default is `false`, which should work with all compliant brokers. + * + * Set this flag to force binary frames. + */ + this.forceBinaryWSFrames = false; + /** + * A bug in ReactNative chops a string on occurrence of a NULL. + * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}. + * This makes incoming WebSocket messages invalid STOMP packets. + * Setting this flag attempts to reverse the damage by appending a NULL. + * If the broker splits a large message into multiple WebSocket messages, + * this flag will cause data loss and abnormal termination of connection. + * + * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library. + */ + this.appendMissingNULLonIncoming = false; + /** + * Browsers do not immediately close WebSockets when `.close` is issued. + * This may cause reconnection to take a significantly long time in case + * of some types of failures. + * In case of incoming heartbeat failure, this experimental flag instructs + * the library to discard the socket immediately + * (even before it is actually closed). + */ + this.discardWebsocketOnCommFailure = false; + /** + * Activation state. + * + * It will usually be ACTIVE or INACTIVE. + * When deactivating, it may go from ACTIVE to INACTIVE without entering DEACTIVATING. + */ + this.state = exports.ActivationState.INACTIVE; + // No op callbacks + const noOp = () => { }; + this.debug = noOp; + this.beforeConnect = noOp; + this.onConnect = noOp; + this.onDisconnect = noOp; + this.onUnhandledMessage = noOp; + this.onUnhandledReceipt = noOp; + this.onUnhandledFrame = noOp; + this.onStompError = noOp; + this.onWebSocketClose = noOp; + this.onWebSocketError = noOp; + this.logRawCommunication = false; + this.onChangeState = noOp; + // These parameters would typically get proper values before connect is called + this.connectHeaders = {}; + this._disconnectHeaders = {}; + // Apply configuration + this.configure(conf); + } + /** + * Underlying WebSocket instance, READONLY. + */ + get webSocket() { + return this._stompHandler?._webSocket; + } + /** + * Disconnection headers. + */ + get disconnectHeaders() { + return this._disconnectHeaders; + } + set disconnectHeaders(value) { + this._disconnectHeaders = value; + if (this._stompHandler) { + this._stompHandler.disconnectHeaders = this._disconnectHeaders; + } + } + /** + * `true` if there is an active connection to STOMP Broker + */ + get connected() { + return !!this._stompHandler && this._stompHandler.connected; + } + /** + * version of STOMP protocol negotiated with the server, READONLY + */ + get connectedVersion() { + return this._stompHandler ? this._stompHandler.connectedVersion : undefined; + } + /** + * if the client is active (connected or going to reconnect) + */ + get active() { + return this.state === exports.ActivationState.ACTIVE; + } + _changeState(state) { + this.state = state; + this.onChangeState(state); + } + /** + * Update configuration. + */ + configure(conf) { + // bulk assign all properties to this + Object.assign(this, conf); + } + /** + * Initiate the connection with the broker. + * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay}, + * it will keep trying to reconnect. + * + * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts. + */ + activate() { + const _activate = () => { + if (this.active) { + this.debug('Already ACTIVE, ignoring request to activate'); + return; + } + this._changeState(exports.ActivationState.ACTIVE); + this._connect(); + }; + // if it is deactivating, wait for it to complete before activating. + if (this.state === exports.ActivationState.DEACTIVATING) { + this.debug('Waiting for deactivation to finish before activating'); + this.deactivate().then(() => { + _activate(); + }); + } + else { + _activate(); + } + } + async _connect() { + await this.beforeConnect(); + if (this._stompHandler) { + this.debug('There is already a stompHandler, skipping the call to connect'); + return; + } + if (!this.active) { + this.debug('Client has been marked inactive, will not attempt to connect'); + return; + } + // setup connection watcher + if (this.connectionTimeout > 0) { + // clear first + if (this._connectionWatcher) { + clearTimeout(this._connectionWatcher); + } + this._connectionWatcher = setTimeout(() => { + if (this.connected) { + return; + } + // Connection not established, close the underlying socket + // a reconnection will be attempted + this.debug(`Connection not established in ${this.connectionTimeout}ms, closing socket`); + this.forceDisconnect(); + }, this.connectionTimeout); + } + this.debug('Opening Web Socket...'); + // Get the actual WebSocket (or a similar object) + const webSocket = this._createWebSocket(); + this._stompHandler = new StompHandler(this, webSocket, { + debug: this.debug, + stompVersions: this.stompVersions, + connectHeaders: this.connectHeaders, + disconnectHeaders: this._disconnectHeaders, + heartbeatIncoming: this.heartbeatIncoming, + heartbeatOutgoing: this.heartbeatOutgoing, + splitLargeFrames: this.splitLargeFrames, + maxWebSocketChunkSize: this.maxWebSocketChunkSize, + forceBinaryWSFrames: this.forceBinaryWSFrames, + logRawCommunication: this.logRawCommunication, + appendMissingNULLonIncoming: this.appendMissingNULLonIncoming, + discardWebsocketOnCommFailure: this.discardWebsocketOnCommFailure, + onConnect: frame => { + // Successfully connected, stop the connection watcher + if (this._connectionWatcher) { + clearTimeout(this._connectionWatcher); + this._connectionWatcher = undefined; + } + if (!this.active) { + this.debug('STOMP got connected while deactivate was issued, will disconnect now'); + this._disposeStompHandler(); + return; + } + this.onConnect(frame); + }, + onDisconnect: frame => { + this.onDisconnect(frame); + }, + onStompError: frame => { + this.onStompError(frame); + }, + onWebSocketClose: evt => { + this._stompHandler = undefined; // a new one will be created in case of a reconnect + if (this.state === exports.ActivationState.DEACTIVATING) { + // Mark deactivation complete + this._changeState(exports.ActivationState.INACTIVE); + } + // The callback is called before attempting to reconnect, this would allow the client + // to be `deactivated` in the callback. + this.onWebSocketClose(evt); + if (this.active) { + this._schedule_reconnect(); + } + }, + onWebSocketError: evt => { + this.onWebSocketError(evt); + }, + onUnhandledMessage: message => { + this.onUnhandledMessage(message); + }, + onUnhandledReceipt: frame => { + this.onUnhandledReceipt(frame); + }, + onUnhandledFrame: frame => { + this.onUnhandledFrame(frame); + }, + }); + this._stompHandler.start(); + } + _createWebSocket() { + let webSocket; + if (this.webSocketFactory) { + webSocket = this.webSocketFactory(); + } + else if (this.brokerURL) { + webSocket = new WebSocket(this.brokerURL, this.stompVersions.protocolVersions()); + } + else { + throw new Error('Either brokerURL or webSocketFactory must be provided'); + } + webSocket.binaryType = 'arraybuffer'; + return webSocket; + } + _schedule_reconnect() { + if (this.reconnectDelay > 0) { + this.debug(`STOMP: scheduling reconnection in ${this.reconnectDelay}ms`); + this._reconnector = setTimeout(() => { + this._connect(); + }, this.reconnectDelay); + } + } + /** + * Disconnect if connected and stop auto reconnect loop. + * Appropriate callbacks will be invoked if there is an underlying STOMP connection. + * + * This call is async. It will resolve immediately if there is no underlying active websocket, + * otherwise, it will resolve after the underlying websocket is properly disposed of. + * + * It is not an error to invoke this method more than once. + * Each of those would resolve on completion of deactivation. + * + * To reactivate, you can call [Client#activate]{@link Client#activate}. + * + * Experimental: pass `force: true` to immediately discard the underlying connection. + * This mode will skip both the STOMP and the Websocket shutdown sequences. + * In some cases, browsers take a long time in the Websocket shutdown + * if the underlying connection had gone stale. + * Using this mode can speed up. + * When this mode is used, the actual Websocket may linger for a while + * and the broker may not realize that the connection is no longer in use. + * + * It is possible to invoke this method initially without the `force` option + * and subsequently, say after a wait, with the `force` option. + */ + async deactivate(options = {}) { + const force = options.force || false; + const needToDispose = this.active; + let retPromise; + if (this.state === exports.ActivationState.INACTIVE) { + this.debug(`Already INACTIVE, nothing more to do`); + return Promise.resolve(); + } + this._changeState(exports.ActivationState.DEACTIVATING); + // Clear if a reconnection was scheduled + if (this._reconnector) { + clearTimeout(this._reconnector); + this._reconnector = undefined; + } + if (this._stompHandler && + // @ts-ignore - if there is a _stompHandler, there is the webSocket + this.webSocket.readyState !== exports.StompSocketState.CLOSED) { + const origOnWebSocketClose = this._stompHandler.onWebSocketClose; + // we need to wait for the underlying websocket to close + retPromise = new Promise((resolve, reject) => { + // @ts-ignore - there is a _stompHandler + this._stompHandler.onWebSocketClose = evt => { + origOnWebSocketClose(evt); + resolve(); + }; + }); + } + else { + // indicate that auto reconnect loop should terminate + this._changeState(exports.ActivationState.INACTIVE); + return Promise.resolve(); + } + if (force) { + this._stompHandler?.discardWebsocket(); + } + else if (needToDispose) { + this._disposeStompHandler(); + } + return retPromise; + } + /** + * Force disconnect if there is an active connection by directly closing the underlying WebSocket. + * This is different from a normal disconnect where a DISCONNECT sequence is carried out with the broker. + * After forcing disconnect, automatic reconnect will be attempted. + * To stop further reconnects call [Client#deactivate]{@link Client#deactivate} as well. + */ + forceDisconnect() { + if (this._stompHandler) { + this._stompHandler.forceDisconnect(); + } + } + _disposeStompHandler() { + // Dispose STOMP Handler + if (this._stompHandler) { + this._stompHandler.dispose(); + } + } + /** + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. + * + * STOMP protocol specifies and suggests some headers and also allows broker-specific headers. + * + * `body` must be String. + * You will need to covert the payload to string in case it is not string (e.g. JSON). + * + * To send a binary message body, use `binaryBody` parameter. It should be a + * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array). + * Sometimes brokers may not support binary frames out of the box. + * Please check your broker documentation. + * + * `content-length` header is automatically added to the STOMP Frame sent to the broker. + * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added. + * For binary messages, `content-length` header is always added. + * + * Caution: The broker will, most likely, report an error and disconnect + * if the message body has NULL octet(s) and `content-length` header is missing. + * + * ```javascript + * client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"}); + * + * // Only destination is mandatory parameter + * client.publish({destination: "/queue/test", body: "Hello, STOMP"}); + * + * // Skip content-length header in the frame to the broker + * client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true}); + * + * var binaryData = generateBinaryData(); // This need to be of type Uint8Array + * // setting content-type header is not mandatory, however a good practice + * client.publish({destination: '/topic/special', binaryBody: binaryData, + * headers: {'content-type': 'application/octet-stream'}}); + * ``` + */ + publish(params) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.publish(params); + } + _checkConnection() { + if (!this.connected) { + throw new TypeError('There is no underlying STOMP connection'); + } + } + /** + * STOMP brokers may carry out operation asynchronously and allow requesting for acknowledgement. + * To request an acknowledgement, a `receipt` header needs to be sent with the actual request. + * The value (say receipt-id) for this header needs to be unique for each use. + * Typically, a sequence, a UUID, a random number or a combination may be used. + * + * A complaint broker will send a RECEIPT frame when an operation has actually been completed. + * The operation needs to be matched based on the value of the receipt-id. + * + * This method allows watching for a receipt and invoking the callback + * when the corresponding receipt has been received. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + * + * Example: + * ```javascript + * // Subscribing with acknowledgement + * let receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * + * client.subscribe(TEST.destination, onMessage, {receipt: receiptId}); + * + * + * // Publishing with acknowledgement + * receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg}); + * ``` + */ + watchForReceipt(receiptId, callback) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.watchForReceipt(receiptId, callback); + } + /** + * Subscribe to a STOMP Broker location. The callback will be invoked for each + * received message with the {@link IMessage} as argument. + * + * Note: The library will generate a unique ID if there is none provided in the headers. + * To use your own ID, pass it using the `headers` argument. + * + * ```javascript + * callback = function(message) { + * // called when the client receives a STOMP message from the server + * if (message.body) { + * alert("got message with body " + message.body) + * } else { + * alert("got empty message"); + * } + * }); + * + * var subscription = client.subscribe("/queue/test", callback); + * + * // Explicit subscription id + * var mySubId = 'my-subscription-id-001'; + * var subscription = client.subscribe(destination, callback, { id: mySubId }); + * ``` + */ + subscribe(destination, callback, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + return this._stompHandler.subscribe(destination, callback, headers); + } + /** + * It is preferable to unsubscribe from a subscription by calling + * `unsubscribe()` directly on {@link StompSubscription} returned by `client.subscribe()`: + * + * ```javascript + * var subscription = client.subscribe(destination, onmessage); + * // ... + * subscription.unsubscribe(); + * ``` + * + * See: https://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame + */ + unsubscribe(id, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.unsubscribe(id, headers); + } + /** + * Start a transaction, the returned {@link ITransaction} has methods - [commit]{@link ITransaction#commit} + * and [abort]{@link ITransaction#abort}. + * + * `transactionId` is optional, if not passed the library will generate it internally. + */ + begin(transactionId) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + return this._stompHandler.begin(transactionId); + } + /** + * Commit a transaction. + * + * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.commit(); + * ``` + */ + commit(transactionId) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.commit(transactionId); + } + /** + * Abort a transaction. + * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.abort(); + * ``` + */ + abort(transactionId) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.abort(transactionId); + } + /** + * ACK a message. It is preferable to acknowledge a message by calling [ack]{@link IMessage#ack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // acknowledge it + * message.ack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + ack(messageId, subscriptionId, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.ack(messageId, subscriptionId, headers); + } + /** + * NACK a message. It is preferable to acknowledge a message by calling [nack]{@link IMessage#nack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // an error occurs, nack it + * message.nack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + nack(messageId, subscriptionId, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.nack(messageId, subscriptionId, headers); + } + } + + /** + * Configuration options for STOMP Client, each key corresponds to + * field by the same name in {@link Client}. This can be passed to + * the constructor of {@link Client} or to [Client#configure]{@link Client#configure}. + * + * Part of `@stomp/stompjs`. + */ + class StompConfig { + } + + /** + * STOMP headers. Many functions calls will accept headers as parameters. + * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}. + * + * `key` and `value` must be valid strings. + * In addition, `key` must not contain `CR`, `LF`, or `:`. + * + * Part of `@stomp/stompjs`. + */ + class StompHeaders { + } + + /** + * Part of `@stomp/stompjs`. + * + * @internal + */ + class HeartbeatInfo { + constructor(client) { + this.client = client; + } + get outgoing() { + return this.client.heartbeatOutgoing; + } + set outgoing(value) { + this.client.heartbeatOutgoing = value; + } + get incoming() { + return this.client.heartbeatIncoming; + } + set incoming(value) { + this.client.heartbeatIncoming = value; + } + } + + /** + * Available for backward compatibility, please shift to using {@link Client}. + * + * **Deprecated** + * + * Part of `@stomp/stompjs`. + * + * To upgrade, please follow the [Upgrade Guide](https://stomp-js.github.io/guide/stompjs/upgrading-stompjs.html) + */ + class CompatClient extends Client { + /** + * Available for backward compatibility, please shift to using {@link Client} + * and [Client#webSocketFactory]{@link Client#webSocketFactory}. + * + * **Deprecated** + * + * @internal + */ + constructor(webSocketFactory) { + super(); + /** + * It is no op now. No longer needed. Large packets work out of the box. + */ + this.maxWebSocketFrameSize = 16 * 1024; + this._heartbeatInfo = new HeartbeatInfo(this); + this.reconnect_delay = 0; + this.webSocketFactory = webSocketFactory; + // Default from previous version + this.debug = (...message) => { + console.log(...message); + }; + } + _parseConnect(...args) { + let closeEventCallback; + let connectCallback; + let errorCallback; + let headers = {}; + if (args.length < 2) { + throw new Error('Connect requires at least 2 arguments'); + } + if (typeof args[1] === 'function') { + [headers, connectCallback, errorCallback, closeEventCallback] = args; + } + else { + switch (args.length) { + case 6: + [ + headers.login, + headers.passcode, + connectCallback, + errorCallback, + closeEventCallback, + headers.host, + ] = args; + break; + default: + [ + headers.login, + headers.passcode, + connectCallback, + errorCallback, + closeEventCallback, + ] = args; + } + } + return [headers, connectCallback, errorCallback, closeEventCallback]; + } + /** + * Available for backward compatibility, please shift to using [Client#activate]{@link Client#activate}. + * + * **Deprecated** + * + * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the + * version with headers to pass your broker specific options. + * + * overloads: + * - connect(headers, connectCallback) + * - connect(headers, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback) + * - connect(login, passcode, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host) + * + * params: + * - headers, see [Client#connectHeaders]{@link Client#connectHeaders} + * - connectCallback, see [Client#onConnect]{@link Client#onConnect} + * - errorCallback, see [Client#onStompError]{@link Client#onStompError} + * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose} + * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + connect(...args) { + const out = this._parseConnect(...args); + if (out[0]) { + this.connectHeaders = out[0]; + } + if (out[1]) { + this.onConnect = out[1]; + } + if (out[2]) { + this.onStompError = out[2]; + } + if (out[3]) { + this.onWebSocketClose = out[3]; + } + super.activate(); + } + /** + * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}. + * + * **Deprecated** + * + * See: + * [Client#onDisconnect]{@link Client#onDisconnect}, and + * [Client#disconnectHeaders]{@link Client#disconnectHeaders} + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + disconnect(disconnectCallback, headers = {}) { + if (disconnectCallback) { + this.onDisconnect = disconnectCallback; + } + this.disconnectHeaders = headers; + super.deactivate(); + } + /** + * Available for backward compatibility, use [Client#publish]{@link Client#publish}. + * + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. The headers will, typically, be available to the subscriber. + * However, there may be special purpose headers corresponding to your STOMP broker. + * + * **Deprecated**, use [Client#publish]{@link Client#publish} + * + * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON) + * + * ```javascript + * client.send("/queue/test", {priority: 9}, "Hello, STOMP"); + * + * // If you want to send a message with a body, you must also pass the headers argument. + * client.send("/queue/test", {}, "Hello, STOMP"); + * ``` + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + send(destination, headers = {}, body = '') { + headers = Object.assign({}, headers); + const skipContentLengthHeader = headers['content-length'] === false; + if (skipContentLengthHeader) { + delete headers['content-length']; + } + this.publish({ + destination, + headers: headers, + body, + skipContentLengthHeader, + }); + } + /** + * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}. + * + * **Deprecated** + */ + set reconnect_delay(value) { + this.reconnectDelay = value; + } + /** + * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}. + * + * **Deprecated** + */ + get ws() { + return this.webSocket; + } + /** + * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}. + * + * **Deprecated** + */ + get version() { + return this.connectedVersion; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + get onreceive() { + return this.onUnhandledMessage; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + set onreceive(value) { + this.onUnhandledMessage = value; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. + * + * **Deprecated** + */ + get onreceipt() { + return this.onUnhandledReceipt; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * + * **Deprecated** + */ + set onreceipt(value) { + this.onUnhandledReceipt = value; + } + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + get heartbeat() { + return this._heartbeatInfo; + } + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + set heartbeat(value) { + this.heartbeatIncoming = value.incoming; + this.heartbeatOutgoing = value.outgoing; + } + } + + /** + * STOMP Class, acts like a factory to create {@link Client}. + * + * Part of `@stomp/stompjs`. + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client}. + */ + class Stomp { + /** + * This method creates a WebSocket client that is connected to + * the STOMP server located at the url. + * + * ```javascript + * var url = "ws://localhost:61614/stomp"; + * var client = Stomp.client(url); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#brokerURL]{@link Client#brokerURL}. + */ + static client(url, protocols) { + // This is a hack to allow another implementation than the standard + // HTML5 WebSocket class. + // + // It is possible to use another class by calling + // + // Stomp.WebSocketClass = MozWebSocket + // + // *prior* to call `Stomp.client()`. + // + // This hack is deprecated and `Stomp.over()` method should be used + // instead. + // See remarks on the function Stomp.over + if (protocols == null) { + protocols = Versions.default.protocolVersions(); + } + const wsFn = () => { + const klass = Stomp.WebSocketClass || WebSocket; + return new klass(url, protocols); + }; + return new CompatClient(wsFn); + } + /** + * This method is an alternative to [Stomp#client]{@link Stomp#client} to let the user + * specify the WebSocket to use (either a standard HTML5 WebSocket or + * a similar object). + * + * In order to support reconnection, the function Client._connect should be callable more than once. + * While reconnecting + * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function + * alternatively allows passing a function that should return a new instance of the underlying socket. + * + * ```javascript + * var client = Stomp.over(function(){ + * return new WebSocket('ws://localhost:15674/ws') + * }); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + static over(ws) { + let wsFn; + if (typeof ws === 'function') { + wsFn = ws; + } + else { + console.warn('Stomp.over did not receive a factory, auto reconnect will not work. ' + + 'Please see https://stomp-js.github.io/api-docs/latest/classes/Stomp.html#over'); + wsFn = () => ws; + } + return new CompatClient(wsFn); + } + } + /** + * In case you need to use a non standard class for WebSocket. + * + * For example when using within NodeJS environment: + * + * ```javascript + * StompJs = require('../../esm5/'); + * Stomp = StompJs.Stomp; + * Stomp.WebSocketClass = require('websocket').w3cwebsocket; + * ``` + * + * **Deprecated** + * + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + // tslint:disable-next-line:variable-name + Stomp.WebSocketClass = null; + + exports.Client = Client; + exports.CompatClient = CompatClient; + exports.FrameImpl = FrameImpl; + exports.Parser = Parser; + exports.Stomp = Stomp; + exports.StompConfig = StompConfig; + exports.StompHeaders = StompHeaders; + exports.Versions = Versions; + +})); +//# sourceMappingURL=stomp.umd.js.map Index: node_modules/@stomp/stompjs/bundles/stomp.umd.js.map =================================================================== --- node_modules/@stomp/stompjs/bundles/stomp.umd.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/bundles/stomp.umd.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"stomp.umd.js","sources":["../src/byte.ts","../src/frame-impl.ts","../src/parser.ts","../src/types.ts","../src/versions.ts","../src/augment-websocket.ts","../src/stomp-handler.ts","../src/client.ts","../src/stomp-config.ts","../src/stomp-headers.ts","../src/compatibility/heartbeat-info.ts","../src/compatibility/compat-client.ts","../src/compatibility/stomp.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null,null],"names":["StompSocketState","ActivationState"],"mappings":";;;;;;IAAA;;;;;;IAMG;IACI,MAAM,IAAI,GAAG;;IAElB,IAAA,EAAE,EAAE,MAAM;;IAEV,IAAA,IAAI,EAAE,MAAM;KACb;;ICPD;;;;IAIG;UACU,SAAS,CAAA;IA0CpB;;;;IAIG;IACH,IAAA,WAAA,CAAY,MAOX,EAAA;IACC,QAAA,MAAM,EACJ,OAAO,EACP,OAAO,EACP,IAAI,EACJ,UAAU,EACV,kBAAkB,EAClB,uBAAuB,GACxB,GAAG,MAAM,CAAC;IACX,QAAA,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACvB,QAAA,IAAI,CAAC,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,IAAI,EAAE,CAAC,CAAC;IAEzD,QAAA,IAAI,UAAU,EAAE;IACd,YAAA,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAC9B,YAAA,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IAC1B,SAAA;IAAM,aAAA;IACL,YAAA,IAAI,CAAC,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC;IACxB,YAAA,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;IAC3B,SAAA;IACD,QAAA,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,IAAI,KAAK,CAAC;IACtD,QAAA,IAAI,CAAC,uBAAuB,GAAG,uBAAuB,IAAI,KAAK,CAAC;SACjE;IA3DD;;IAEG;IACH,IAAA,IAAI,IAAI,GAAA;YACN,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,YAAY,EAAE;IACpC,YAAA,IAAI,CAAC,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IACzD,SAAA;IACD,QAAA,OAAO,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;SACzB;IAGD;;IAEG;IACH,IAAA,IAAI,UAAU,GAAA;YACZ,IAAI,CAAC,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE;IAC3C,YAAA,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzD,SAAA;;YAED,OAAO,IAAI,CAAC,WAAyB,CAAC;SACvC;IAyCD;;;;IAIG;IACI,IAAA,OAAO,YAAY,CACxB,QAAuB,EACvB,kBAA2B,EAAA;YAE3B,MAAM,OAAO,GAAiB,EAAE,CAAC;IACjC,QAAA,MAAM,IAAI,GAAG,CAAC,GAAW,KAAa,GAAG,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,CAAC,CAAC;;YAGpE,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE;gBACnC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;gBAEhC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5B,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAE5B,YAAA,IACE,kBAAkB;oBAClB,QAAQ,CAAC,OAAO,KAAK,SAAS;IAC9B,gBAAA,QAAQ,CAAC,OAAO,KAAK,WAAW,EAChC;IACA,gBAAA,KAAK,GAAG,SAAS,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAC3C,aAAA;IAED,YAAA,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;IACtB,SAAA;YAED,OAAO,IAAI,SAAS,CAAC;gBACnB,OAAO,EAAE,QAAQ,CAAC,OAAiB;gBACnC,OAAO;gBACP,UAAU,EAAE,QAAQ,CAAC,UAAU;gBAC/B,kBAAkB;IACnB,SAAA,CAAC,CAAC;SACJ;IAED;;IAEG;QACI,QAAQ,GAAA;IACb,QAAA,OAAO,IAAI,CAAC,sBAAsB,EAAE,CAAC;SACtC;IAED;;;;;;IAMG;QACI,SAAS,GAAA;IACd,QAAA,MAAM,aAAa,GAAG,IAAI,CAAC,sBAAsB,EAAE,CAAC;YAEpD,IAAI,IAAI,CAAC,YAAY,EAAE;IACrB,YAAA,OAAO,SAAS,CAAC,YAAY,CAC3B,aAAa,EACb,IAAI,CAAC,WAAyB,CAC/B,CAAC,MAAM,CAAC;IACV,SAAA;IAAM,aAAA;gBACL,OAAO,aAAa,GAAG,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC;IAC/C,SAAA;SACF;QAEO,sBAAsB,GAAA;IAC5B,QAAA,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YAC7B,IAAI,IAAI,CAAC,uBAAuB,EAAE;IAChC,YAAA,OAAO,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC;IACvC,SAAA;IAED,QAAA,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,EAAE;gBAClD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gBACjC,IACE,IAAI,CAAC,kBAAkB;oBACvB,IAAI,CAAC,OAAO,KAAK,SAAS;IAC1B,gBAAA,IAAI,CAAC,OAAO,KAAK,WAAW,EAC5B;IACA,gBAAA,KAAK,CAAC,IAAI,CAAC,CAAG,EAAA,IAAI,IAAI,SAAS,CAAC,cAAc,CAAC,GAAG,KAAK,CAAA,CAAE,CAAC,CAAA,CAAE,CAAC,CAAC;IAC/D,aAAA;IAAM,iBAAA;oBACL,KAAK,CAAC,IAAI,CAAC,CAAA,EAAG,IAAI,CAAI,CAAA,EAAA,KAAK,CAAE,CAAA,CAAC,CAAC;IAChC,aAAA;IACF,SAAA;YACD,IACE,IAAI,CAAC,YAAY;iBAChB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,uBAAuB,CAAC,EACtD;gBACA,KAAK,CAAC,IAAI,CAAC,CAAkB,eAAA,EAAA,IAAI,CAAC,UAAU,EAAE,CAAE,CAAA,CAAC,CAAC;IACnD,SAAA;IACD,QAAA,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;SAChD;QAEO,WAAW,GAAA;IACjB,QAAA,OAAO,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;SAChC;QAEO,UAAU,GAAA;IAChB,QAAA,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;YACnC,OAAO,UAAU,GAAG,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;SAC3C;IAED;;;IAGG;QACK,OAAO,UAAU,CAAC,CAAS,EAAA;IACjC,QAAA,OAAO,CAAC,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;SACnD;IAEO,IAAA,OAAO,YAAY,CACzB,aAAqB,EACrB,UAAsB,EAAA;YAEtB,MAAM,kBAAkB,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;YACnE,MAAM,cAAc,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,QAAA,MAAM,UAAU,GAAG,IAAI,UAAU,CAC/B,kBAAkB,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM,CACtE,CAAC;IAEF,QAAA,UAAU,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;YACnC,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;IACtD,QAAA,UAAU,CAAC,GAAG,CACZ,cAAc,EACd,kBAAkB,CAAC,MAAM,GAAG,UAAU,CAAC,MAAM,CAC9C,CAAC;IAEF,QAAA,OAAO,UAAU,CAAC;SACnB;IACD;;;;IAIG;QACI,OAAO,QAAQ,CAAC,MAOtB,EAAA;IACC,QAAA,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC,MAAM,CAAC,CAAC;IACpC,QAAA,OAAO,KAAK,CAAC,SAAS,EAAE,CAAC;SAC1B;IAED;;IAEG;QACK,OAAO,cAAc,CAAC,GAAW,EAAA;IACvC,QAAA,OAAO,GAAG;IACP,aAAA,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC;IACtB,aAAA,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC;IACrB,aAAA,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC;IACrB,aAAA,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SACzB;IAED;;IAEG;QACK,OAAO,gBAAgB,CAAC,GAAW,EAAA;IACzC,QAAA,OAAO,GAAG;IACP,aAAA,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC;IACrB,aAAA,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC;IACrB,aAAA,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC;IACpB,aAAA,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;SAC3B;IACF;;IC3PD;;IAEG;IACH,MAAM,IAAI,GAAG,CAAC,CAAC;IACf;;IAEG;IACH,MAAM,EAAE,GAAG,EAAE,CAAC;IACd;;IAEG;IACH,MAAM,EAAE,GAAG,EAAE,CAAC;IACd;;IAEG;IACH,MAAM,KAAK,GAAG,EAAE,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyCG;UACU,MAAM,CAAA;QAcjB,WACS,CAAA,OAA0C,EAC1C,cAA0B,EAAA;YAD1B,IAAO,CAAA,OAAA,GAAP,OAAO,CAAmC;YAC1C,IAAc,CAAA,cAAA,GAAd,cAAc,CAAY;IAflB,QAAA,IAAA,CAAA,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAC;IAC7B,QAAA,IAAA,CAAA,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAC;YAKtC,IAAM,CAAA,MAAA,GAAa,EAAE,CAAC;YAW5B,IAAI,CAAC,UAAU,EAAE,CAAC;SACnB;IAEM,IAAA,UAAU,CACf,OAA6B,EAC7B,2BAAA,GAAuC,KAAK,EAAA;IAE5C,QAAA,IAAI,KAAiB,CAAC;IAEtB,QAAA,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE;gBAC/B,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvC,SAAA;IAAM,aAAA;IACL,YAAA,KAAK,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;IACjC,SAAA;;;;;IAMD,QAAA,IAAI,2BAA2B,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,EAAE;gBAChE,MAAM,aAAa,GAAG,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACvD,YAAA,aAAa,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAC5B,YAAA,aAAa,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAChC,KAAK,GAAG,aAAa,CAAC;IACvB,SAAA;;IAGD,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;IACrC,YAAA,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACtB,YAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACpB,SAAA;SACF;;;IAKO,IAAA,aAAa,CAAC,IAAY,EAAA;YAChC,IAAI,IAAI,KAAK,IAAI,EAAE;;gBAEjB,OAAO;IACR,SAAA;YACD,IAAI,IAAI,KAAK,EAAE,EAAE;;gBAEf,OAAO;IACR,SAAA;YACD,IAAI,IAAI,KAAK,EAAE,EAAE;;gBAEf,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,OAAO;IACR,SAAA;IAED,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC;IACpC,QAAA,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;SAC1B;IAEO,IAAA,eAAe,CAAC,IAAY,EAAA;YAClC,IAAI,IAAI,KAAK,EAAE,EAAE;;gBAEf,OAAO;IACR,SAAA;YACD,IAAI,IAAI,KAAK,EAAE,EAAE;gBACf,IAAI,CAAC,QAAQ,CAAC,OAAO,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACnD,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC;gBACpC,OAAO;IACR,SAAA;IAED,QAAA,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACzB;IAEO,IAAA,eAAe,CAAC,IAAY,EAAA;YAClC,IAAI,IAAI,KAAK,EAAE,EAAE;;gBAEf,OAAO;IACR,SAAA;YACD,IAAI,IAAI,KAAK,EAAE,EAAE;gBACf,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACzB,OAAO;IACR,SAAA;IACD,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC;IACtC,QAAA,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;SAC1B;IAEO,IAAA,aAAa,CAAC,IAAY,EAAA;IAChC,QAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SACpB;IAEO,IAAA,iBAAiB,CAAC,IAAY,EAAA;YACpC,IAAI,IAAI,KAAK,KAAK,EAAE;IAClB,YAAA,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7C,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC;gBACxC,OAAO;IACR,SAAA;IACD,QAAA,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACzB;IAEO,IAAA,mBAAmB,CAAC,IAAY,EAAA;YACtC,IAAI,IAAI,KAAK,EAAE,EAAE;;gBAEf,OAAO;IACR,SAAA;YACD,IAAI,IAAI,KAAK,EAAE,EAAE;IACf,YAAA,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC;IACzB,gBAAA,IAAI,CAAC,UAAoB;oBACzB,IAAI,CAAC,mBAAmB,EAAE;IAC3B,aAAA,CAAC,CAAC;IACH,YAAA,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAC5B,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,eAAe,CAAC;gBACpC,OAAO;IACR,SAAA;IACD,QAAA,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACzB;QAEO,iBAAiB,GAAA;IACvB,QAAA,MAAM,mBAAmB,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CACtD,CAAC,MAAwB,KAAI;IAC3B,YAAA,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,gBAAgB,CAAC;IACxC,SAAC,CACF,CAAC,CAAC,CAAC,CAAC;IAEL,QAAA,IAAI,mBAAmB,EAAE;IACvB,YAAA,IAAI,CAAC,mBAAmB,GAAG,QAAQ,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAChE,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,qBAAqB,CAAC;IAC3C,SAAA;IAAM,aAAA;IACL,YAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,0BAA0B,CAAC;IAChD,SAAA;SACF;IAEO,IAAA,0BAA0B,CAAC,IAAY,EAAA;YAC7C,IAAI,IAAI,KAAK,IAAI,EAAE;gBACjB,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,OAAO;IACR,SAAA;IACD,QAAA,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACzB;IAEO,IAAA,qBAAqB,CAAC,IAAY,EAAA;;IAExC,QAAA,IAAK,IAAI,CAAC,mBAA8B,EAAE,KAAK,CAAC,EAAE;gBAChD,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,OAAO;IACR,SAAA;IACD,QAAA,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;SACzB;QAEO,cAAc,GAAA;YACpB,IAAI,CAAC,QAAQ,CAAC,UAAU,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAErD,IAAI;IACF,YAAA,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC7B,SAAA;IAAC,QAAA,OAAO,CAAC,EAAE;IACV,YAAA,OAAO,CAAC,GAAG,CACT,uEAAuE,EACvE,CAAC,CACF,CAAC;IACH,SAAA;YAED,IAAI,CAAC,UAAU,EAAE,CAAC;SACnB;;IAIO,IAAA,YAAY,CAAC,IAAY,EAAA;IAC/B,QAAA,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;SACxB;QAEO,mBAAmB,GAAA;YACzB,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC;SACxD;QAEO,kBAAkB,GAAA;YACxB,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC9C,QAAA,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACjB,QAAA,OAAO,SAAS,CAAC;SAClB;QAEO,UAAU,GAAA;YAChB,IAAI,CAAC,QAAQ,GAAG;IACd,YAAA,OAAO,EAAE,SAAS;IAClB,YAAA,OAAO,EAAE,EAAE;IACX,YAAA,UAAU,EAAE,SAAS;aACtB,CAAC;IAEF,QAAA,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;IACjB,QAAA,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;IAE5B,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC;SACnC;IACF;;IC9HD;;IAEG;AACSA,sCAKX;IALD,CAAA,UAAY,gBAAgB,EAAA;IAC1B,IAAA,gBAAA,CAAA,gBAAA,CAAA,YAAA,CAAA,GAAA,CAAA,CAAA,GAAA,YAAU,CAAA;IACV,IAAA,gBAAA,CAAA,gBAAA,CAAA,MAAA,CAAA,GAAA,CAAA,CAAA,GAAA,MAAI,CAAA;IACJ,IAAA,gBAAA,CAAA,gBAAA,CAAA,SAAA,CAAA,GAAA,CAAA,CAAA,GAAA,SAAO,CAAA;IACP,IAAA,gBAAA,CAAA,gBAAA,CAAA,QAAA,CAAA,GAAA,CAAA,CAAA,GAAA,QAAM,CAAA;IACR,CAAC,EALWA,wBAAgB,GAAhBA,wBAAgB,KAAhBA,wBAAgB,GAK3B,EAAA,CAAA,CAAA,CAAA;IAED;;IAEG;AACSC,qCAIX;IAJD,CAAA,UAAY,eAAe,EAAA;IACzB,IAAA,eAAA,CAAA,eAAA,CAAA,QAAA,CAAA,GAAA,CAAA,CAAA,GAAA,QAAM,CAAA;IACN,IAAA,eAAA,CAAA,eAAA,CAAA,cAAA,CAAA,GAAA,CAAA,CAAA,GAAA,cAAY,CAAA;IACZ,IAAA,eAAA,CAAA,eAAA,CAAA,UAAA,CAAA,GAAA,CAAA,CAAA,GAAA,UAAQ,CAAA;IACV,CAAC,EAJWA,uBAAe,GAAfA,uBAAe,KAAfA,uBAAe,GAI1B,EAAA,CAAA,CAAA;;IC7JD;;;;IAIG;UACU,QAAQ,CAAA;IAuBnB;;;;;IAKG;IACH,IAAA,WAAA,CAAmB,QAAkB,EAAA;YAAlB,IAAQ,CAAA,QAAA,GAAR,QAAQ,CAAU;SAAI;IAEzC;;IAEG;QACI,iBAAiB,GAAA;YACtB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;SAChC;IAED;;IAEG;QACI,gBAAgB,GAAA;YACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,CAAQ,MAAA,CAAA,CAAC,CAAC;SAC/D;;IA1CD;;IAEG;IACW,QAAI,CAAA,IAAA,GAAG,KAAK,CAAC;IAC3B;;IAEG;IACW,QAAI,CAAA,IAAA,GAAG,KAAK,CAAC;IAC3B;;IAEG;IACW,QAAI,CAAA,IAAA,GAAG,KAAK,CAAC;IAE3B;;IAEG;IACW,QAAO,CAAA,OAAA,GAAG,IAAI,QAAQ,CAAC;IACnC,IAAA,QAAQ,CAAC,IAAI;IACb,IAAA,QAAQ,CAAC,IAAI;IACb,IAAA,QAAQ,CAAC,IAAI;IACd,CAAA,CAAC;;ICxBJ;;IAEG;IACa,SAAA,gBAAgB,CAC9B,SAAuB,EACvB,KAA4B,EAAA;QAE5B,SAAS,CAAC,SAAS,GAAG,YAAA;IACpB,QAAA,MAAM,IAAI,GAAG,MAAK,GAAG,CAAC;;IAGtB,QAAA,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACpB,QAAA,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACtB,QAAA,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;IAEnB,QAAA,MAAM,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;IACtB,QAAA,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAEpD,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;;IAGjC,QAAA,IAAI,CAAC,OAAO,GAAG,UAAU,IAAG;IAC1B,YAAA,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;IAClD,YAAA,KAAK,CACH,CAAA,mBAAA,EAAsB,EAAE,CAAA,gBAAA,EAAmB,KAAK,CAAyB,sBAAA,EAAA,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,MAAM,CAAA,CAAE,CAChH,CAAC;IACJ,SAAC,CAAC;YAEF,IAAI,CAAC,KAAK,EAAE,CAAC;IAEb,QAAA,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE;IAC3B,YAAA,IAAI,EAAE,IAAI;gBACV,MAAM,EAAE,CAA6B,0BAAA,EAAA,EAAE,CAA8C,4CAAA,CAAA;IACrF,YAAA,QAAQ,EAAE,KAAK;IAChB,SAAA,CAAC,CAAC;IACL,KAAC,CAAC;IACJ;;ICfA;;;;;;IAMG;UACU,YAAY,CAAA;IA6DvB,IAAA,WAAA,CACU,OAAe,EAChB,UAAwB,EAC/B,MAA4B,EAAA;YAFpB,IAAO,CAAA,OAAA,GAAP,OAAO,CAAQ;YAChB,IAAU,CAAA,UAAA,GAAV,UAAU,CAAc;YAbzB,IAAU,CAAA,UAAA,GAAY,KAAK,CAAC;IAuHnB,QAAA,IAAA,CAAA,oBAAoB,GAEjC;;gBAEF,SAAS,EAAE,KAAK,IAAG;oBACjB,IAAI,CAAC,KAAK,CAAC,CAAuB,oBAAA,EAAA,KAAK,CAAC,OAAO,CAAC,MAAM,CAAE,CAAA,CAAC,CAAC;IAC1D,gBAAA,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;oBACvB,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;;IAE/C,gBAAA,IAAI,IAAI,CAAC,iBAAiB,KAAK,QAAQ,CAAC,IAAI,EAAE;IAC5C,oBAAA,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC;IACjC,iBAAA;IAED,gBAAA,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACpC,gBAAA,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;iBACvB;;gBAGD,OAAO,EAAE,KAAK,IAAG;;;;;;;;IAQf,gBAAA,MAAM,YAAY,GAAG,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC;IAChD,gBAAA,MAAM,SAAS,GACb,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,kBAAkB,CAAC;;oBAG/D,MAAM,OAAO,GAAG,KAAiB,CAAC;oBAElC,MAAM,MAAM,GAAG,IAAI,CAAC;oBACpB,MAAM,SAAS,GACb,IAAI,CAAC,iBAAiB,KAAK,QAAQ,CAAC,IAAI;IACtC,sBAAE,OAAO,CAAC,OAAO,CAAC,GAAG;IACrB,sBAAE,OAAO,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;;;IAIpC,gBAAA,OAAO,CAAC,GAAG,GAAG,CAAC,OAAwB,GAAA,EAAE,KAAU;wBACjD,OAAO,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACtD,iBAAC,CAAC;IACF,gBAAA,OAAO,CAAC,IAAI,GAAG,CAAC,OAAwB,GAAA,EAAE,KAAU;wBAClD,OAAO,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;IACvD,iBAAC,CAAC;oBACF,SAAS,CAAC,OAAO,CAAC,CAAC;iBACpB;;gBAGD,OAAO,EAAE,KAAK,IAAG;IACf,gBAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;IACpE,gBAAA,IAAI,QAAQ,EAAE;wBACZ,QAAQ,CAAC,KAAK,CAAC,CAAC;;wBAEhB,OAAO,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC;IAC3D,iBAAA;IAAM,qBAAA;IACL,oBAAA,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;IAChC,iBAAA;iBACF;;gBAGD,KAAK,EAAE,KAAK,IAAG;IACb,gBAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;iBAC1B;aACF,CAAC;;IAxKA,QAAA,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC;;IAGlB,QAAA,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;;IAGzB,QAAA,IAAI,CAAC,gBAAgB,GAAG,EAAE,CAAC;IAE3B,QAAA,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;IAEvB,QAAA,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IAEjC,QAAA,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAExC,QAAA,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;IAC1B,QAAA,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;IAC1C,QAAA,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;IAC5C,QAAA,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAClD,QAAA,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAClD,QAAA,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;IAClD,QAAA,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;IAChD,QAAA,IAAI,CAAC,qBAAqB,GAAG,MAAM,CAAC,qBAAqB,CAAC;IAC1D,QAAA,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,CAAC;IACtD,QAAA,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,mBAAmB,CAAC;IACtD,QAAA,IAAI,CAAC,2BAA2B,GAAG,MAAM,CAAC,2BAA2B,CAAC;IACtE,QAAA,IAAI,CAAC,6BAA6B,GAAG,MAAM,CAAC,6BAA6B,CAAC;IAC1E,QAAA,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;IAClC,QAAA,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;IACxC,QAAA,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;IACxC,QAAA,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;IAChD,QAAA,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;IAChD,QAAA,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC;IACpD,QAAA,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,kBAAkB,CAAC;IACpD,QAAA,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB,CAAC;SACjD;IA5DD,IAAA,IAAI,gBAAgB,GAAA;YAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;SAC/B;IAGD,IAAA,IAAI,SAAS,GAAA;YACX,OAAO,IAAI,CAAC,UAAU,CAAC;SACxB;QAuDM,KAAK,GAAA;YACV,MAAM,MAAM,GAAG,IAAI,MAAM;;IAEvB,QAAA,QAAQ,IAAG;IACT,YAAA,MAAM,KAAK,GAAG,SAAS,CAAC,YAAY,CAClC,QAAQ,EACR,IAAI,CAAC,mBAAmB,CACzB,CAAC;;IAGF,YAAA,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE;IAC7B,gBAAA,IAAI,CAAC,KAAK,CAAC,OAAO,KAAK,CAAA,CAAE,CAAC,CAAC;IAC5B,aAAA;IAED,YAAA,MAAM,kBAAkB,GACtB,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,IAAI,CAAC,gBAAgB,CAAC;gBACpE,kBAAkB,CAAC,KAAK,CAAC,CAAC;aAC3B;;IAED,QAAA,MAAK;IACH,YAAA,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACzB,SAAC,CACF,CAAC;YAEF,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,CAAC,GAA6B,KAAI;IAC5D,YAAA,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IAC5B,YAAA,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBAExC,IAAI,IAAI,CAAC,mBAAmB,EAAE;IAC5B,gBAAA,MAAM,gBAAgB,GACpB,GAAG,CAAC,IAAI,YAAY,WAAW;0BAC3B,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC;IACpC,sBAAE,GAAG,CAAC,IAAI,CAAC;IACf,gBAAA,IAAI,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAA,CAAE,CAAC,CAAC;IACvC,aAAA;gBAED,MAAM,CAAC,UAAU,CACf,GAAG,CAAC,IAA4B,EAChC,IAAI,CAAC,2BAA2B,CACjC,CAAC;IACJ,SAAC,CAAC;YAEF,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,UAAU,KAAU;gBAC7C,IAAI,CAAC,KAAK,CAAC,CAAwB,qBAAA,EAAA,IAAI,CAAC,UAAU,CAAC,GAAG,CAAE,CAAA,CAAC,CAAC;gBAC1D,IAAI,CAAC,QAAQ,EAAE,CAAC;IAChB,YAAA,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACpC,SAAC,CAAC;YAEF,IAAI,CAAC,UAAU,CAAC,OAAO,GAAG,CAAC,UAAU,KAAU;IAC7C,YAAA,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;IACpC,SAAC,CAAC;IAEF,QAAA,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,MAAK;;IAE5B,YAAA,MAAM,cAAc,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAEvE,YAAA,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,CAAC;gBACnC,cAAc,CAAC,gBAAgB,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;gBAC1E,cAAc,CAAC,YAAY,CAAC,GAAG;IAC7B,gBAAA,IAAI,CAAC,iBAAiB;IACtB,gBAAA,IAAI,CAAC,iBAAiB;IACvB,aAAA,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACZ,YAAA,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;IAClE,SAAC,CAAC;SACH;IAsEO,IAAA,eAAe,CAAC,OAAqB,EAAA;IAC3C,QAAA,IACE,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,IAAI;IACjC,YAAA,OAAO,CAAC,OAAO,KAAK,QAAQ,CAAC,IAAI,EACjC;gBACA,OAAO;IACR,SAAA;;;IAID,QAAA,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE;gBAC1B,OAAO;IACR,SAAA;;;;YAKD,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC;iBAC3D,KAAK,CAAC,GAAG,CAAC;IACV,aAAA,GAAG,CAAC,CAAC,CAAS,KAAK,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YAEvC,IAAI,IAAI,CAAC,iBAAiB,KAAK,CAAC,IAAI,cAAc,KAAK,CAAC,EAAE;IACxD,YAAA,MAAM,GAAG,GAAW,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;IACrE,YAAA,IAAI,CAAC,KAAK,CAAC,mBAAmB,GAAG,CAAA,EAAA,CAAI,CAAC,CAAC;IACvC,YAAA,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,MAAK;oBAC9B,IAAI,IAAI,CAAC,UAAU,CAAC,UAAU,KAAKD,wBAAgB,CAAC,IAAI,EAAE;wBACxD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC9B,oBAAA,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IACxB,iBAAA;iBACF,EAAE,GAAG,CAAC,CAAC;IACT,SAAA;YAED,IAAI,IAAI,CAAC,iBAAiB,KAAK,CAAC,IAAI,cAAc,KAAK,CAAC,EAAE;IACxD,YAAA,MAAM,GAAG,GAAW,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;IACrE,YAAA,IAAI,CAAC,KAAK,CAAC,oBAAoB,GAAG,CAAA,EAAA,CAAI,CAAC,CAAC;IACxC,YAAA,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC,MAAK;oBAC9B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,qBAAqB,CAAC;;IAEtD,gBAAA,IAAI,KAAK,GAAG,GAAG,GAAG,CAAC,EAAE;IACnB,oBAAA,IAAI,CAAC,KAAK,CAAC,gDAAgD,KAAK,CAAA,EAAA,CAAI,CAAC,CAAC;wBACtE,IAAI,CAAC,wBAAwB,EAAE,CAAC;IACjC,iBAAA;iBACF,EAAE,GAAG,CAAC,CAAC;IACT,SAAA;SACF;QAEO,wBAAwB,GAAA;YAC9B,IAAI,IAAI,CAAC,6BAA6B,EAAE;IACtC,YAAA,IAAI,CAAC,KAAK,CACR,oEAAoE,CACrE,CAAC;gBACF,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACzB,SAAA;IAAM,aAAA;IACL,YAAA,IAAI,CAAC,KAAK,CAAC,gCAAgC,CAAC,CAAC;gBAC7C,IAAI,CAAC,eAAe,EAAE,CAAC;IACxB,SAAA;SACF;QAEM,eAAe,GAAA;YACpB,IAAI,IAAI,CAAC,UAAU,EAAE;gBACnB,IACE,IAAI,CAAC,UAAU,CAAC,UAAU,KAAKA,wBAAgB,CAAC,UAAU;oBAC1D,IAAI,CAAC,UAAU,CAAC,UAAU,KAAKA,wBAAgB,CAAC,IAAI,EACpD;oBACA,IAAI,CAAC,wBAAwB,EAAE,CAAC;IACjC,aAAA;IACF,SAAA;SACF;QAEM,eAAe,GAAA;YACpB,IAAI,CAAC,UAAU,CAAC,SAAS,GAAG,MAAO,GAAC,CAAC;IACrC,QAAA,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;SACzB;QAEM,gBAAgB,GAAA;YACrB,IAAI,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,KAAK,UAAU,EAAE;IACnD,YAAA,gBAAgB,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,GAAW,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC;IACrE,SAAA;;IAGD,QAAA,IAAI,CAAC,UAAU,CAAC,SAAS,EAAE,CAAC;SAC7B;IAEO,IAAA,SAAS,CAAC,MAMjB,EAAA;IACC,QAAA,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,uBAAuB,EAAE,GACnE,MAAM,CAAC;IACT,QAAA,MAAM,KAAK,GAAG,IAAI,SAAS,CAAC;gBAC1B,OAAO;gBACP,OAAO;gBACP,IAAI;gBACJ,UAAU;gBACV,kBAAkB,EAAE,IAAI,CAAC,mBAAmB;gBAC5C,uBAAuB;IACxB,SAAA,CAAC,CAAC;IAEH,QAAA,IAAI,QAAQ,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;YAEjC,IAAI,IAAI,CAAC,mBAAmB,EAAE;IAC5B,YAAA,IAAI,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAA,CAAE,CAAC,CAAC;IAC/B,SAAA;IAAM,aAAA;IACL,YAAA,IAAI,CAAC,KAAK,CAAC,OAAO,KAAK,CAAA,CAAE,CAAC,CAAC;IAC5B,SAAA;YAED,IAAI,IAAI,CAAC,mBAAmB,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE;gBAC5D,QAAQ,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC/C,SAAA;YAED,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;IAC1D,YAAA,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChC,SAAA;IAAM,aAAA;gBACL,IAAI,GAAG,GAAG,QAAkB,CAAC;IAC7B,YAAA,OAAO,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE;IACrB,gBAAA,MAAM,KAAK,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,qBAAqB,CAAC,CAAC;oBAC3D,GAAG,GAAG,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;IAChD,gBAAA,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,gBAAA,IAAI,CAAC,KAAK,CAAC,CAAA,aAAA,EAAgB,KAAK,CAAC,MAAM,CAAA,cAAA,EAAiB,GAAG,CAAC,MAAM,CAAA,CAAE,CAAC,CAAC;IACvE,aAAA;IACF,SAAA;SACF;QAEM,OAAO,GAAA;YACZ,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,IAAI;;IAEF,gBAAA,MAAM,iBAAiB,GAAI,MAAc,CAAC,MAAM,CAC9C,EAAE,EACF,IAAI,CAAC,iBAAiB,CACvB,CAAC;IAEF,gBAAA,IAAI,CAAC,iBAAiB,CAAC,OAAO,EAAE;wBAC9B,iBAAiB,CAAC,OAAO,GAAG,CAAA,MAAA,EAAS,IAAI,CAAC,QAAQ,EAAE,CAAA,CAAE,CAAC;IACxD,iBAAA;oBACD,IAAI,CAAC,eAAe,CAAC,iBAAiB,CAAC,OAAO,EAAE,KAAK,IAAG;wBACtD,IAAI,CAAC,eAAe,EAAE,CAAC;wBACvB,IAAI,CAAC,QAAQ,EAAE,CAAC;IAChB,oBAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;IAC3B,iBAAC,CAAC,CAAC;IACH,gBAAA,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,iBAAiB,EAAE,CAAC,CAAC;IACvE,aAAA;IAAC,YAAA,OAAO,KAAK,EAAE;IACd,gBAAA,IAAI,CAAC,KAAK,CAAC,oCAAoC,KAAK,CAAA,CAAE,CAAC,CAAC;IACzD,aAAA;IACF,SAAA;IAAM,aAAA;gBACL,IACE,IAAI,CAAC,UAAU,CAAC,UAAU,KAAKA,wBAAgB,CAAC,UAAU;oBAC1D,IAAI,CAAC,UAAU,CAAC,UAAU,KAAKA,wBAAgB,CAAC,IAAI,EACpD;oBACA,IAAI,CAAC,eAAe,EAAE,CAAC;IACxB,aAAA;IACF,SAAA;SACF;QAEO,QAAQ,GAAA;IACd,QAAA,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;YAExB,IAAI,IAAI,CAAC,OAAO,EAAE;IAChB,YAAA,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5B,YAAA,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;IAC1B,SAAA;YACD,IAAI,IAAI,CAAC,OAAO,EAAE;IAChB,YAAA,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC5B,YAAA,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;IAC1B,SAAA;SACF;IAEM,IAAA,OAAO,CAAC,MAAsB,EAAA;IACnC,QAAA,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,uBAAuB,EAAE,GACvE,MAAM,CAAC;IACT,QAAA,MAAM,IAAI,GAAkB,MAAc,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,EAAE,OAAO,CAAC,CAAC;YAC5E,IAAI,CAAC,SAAS,CAAC;IACb,YAAA,OAAO,EAAE,MAAM;IACf,YAAA,OAAO,EAAE,IAAI;gBACb,IAAI;gBACJ,UAAU;gBACV,uBAAuB;IACxB,SAAA,CAAC,CAAC;SACJ;QAEM,eAAe,CAAC,SAAiB,EAAE,QAA2B,EAAA;IACnE,QAAA,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC;SAC7C;IAEM,IAAA,SAAS,CACd,WAAmB,EACnB,QAA6B,EAC7B,UAAwB,EAAE,EAAA;YAE1B,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAE9C,QAAA,IAAI,CAAC,OAAO,CAAC,EAAE,EAAE;gBACf,OAAO,CAAC,EAAE,GAAG,CAAA,IAAA,EAAO,IAAI,CAAC,QAAQ,EAAE,CAAA,CAAE,CAAC;IACvC,SAAA;IACD,QAAA,OAAO,CAAC,WAAW,GAAG,WAAW,CAAC;YAClC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC;YAC3C,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,CAAC;YAClD,MAAM,MAAM,GAAG,IAAI,CAAC;YACpB,OAAO;gBACL,EAAE,EAAE,OAAO,CAAC,EAAE;IAEd,YAAA,WAAW,CAAC,IAAI,EAAA;oBACd,OAAO,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC;iBAC7C;aACF,CAAC;SACH;IAEM,IAAA,WAAW,CAAC,EAAU,EAAE,OAAA,GAAwB,EAAE,EAAA;YACvD,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAE9C,QAAA,OAAO,IAAI,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC;IAC/B,QAAA,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC;YAChB,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC,CAAC;SACrD;IAEM,IAAA,KAAK,CAAC,aAAqB,EAAA;YAChC,MAAM,IAAI,GAAG,aAAa,IAAI,CAAA,GAAA,EAAM,IAAI,CAAC,QAAQ,EAAE,CAAA,CAAE,CAAC;YACtD,IAAI,CAAC,SAAS,CAAC;IACb,YAAA,OAAO,EAAE,OAAO;IAChB,YAAA,OAAO,EAAE;IACP,gBAAA,WAAW,EAAE,IAAI;IAClB,aAAA;IACF,SAAA,CAAC,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC;YACpB,OAAO;IACL,YAAA,EAAE,EAAE,IAAI;gBACR,MAAM,GAAA;IACJ,gBAAA,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;iBACrB;gBACD,KAAK,GAAA;IACH,gBAAA,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;iBACpB;aACF,CAAC;SACH;IAEM,IAAA,MAAM,CAAC,aAAqB,EAAA;YACjC,IAAI,CAAC,SAAS,CAAC;IACb,YAAA,OAAO,EAAE,QAAQ;IACjB,YAAA,OAAO,EAAE;IACP,gBAAA,WAAW,EAAE,aAAa;IAC3B,aAAA;IACF,SAAA,CAAC,CAAC;SACJ;IAEM,IAAA,KAAK,CAAC,aAAqB,EAAA;YAChC,IAAI,CAAC,SAAS,CAAC;IACb,YAAA,OAAO,EAAE,OAAO;IAChB,YAAA,OAAO,EAAE;IACP,gBAAA,WAAW,EAAE,aAAa;IAC3B,aAAA;IACF,SAAA,CAAC,CAAC;SACJ;IAEM,IAAA,GAAG,CACR,SAAiB,EACjB,cAAsB,EACtB,UAAwB,EAAE,EAAA;YAE1B,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAE9C,QAAA,IAAI,IAAI,CAAC,iBAAiB,KAAK,QAAQ,CAAC,IAAI,EAAE;IAC5C,YAAA,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IACxB,SAAA;IAAM,aAAA;IACL,YAAA,OAAO,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC;IACnC,SAAA;IACD,QAAA,OAAO,CAAC,YAAY,GAAG,cAAc,CAAC;YACtC,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC;SAC7C;IAEM,IAAA,IAAI,CACT,SAAiB,EACjB,cAAsB,EACtB,UAAwB,EAAE,EAAA;YAE1B,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAE9C,QAAA,IAAI,IAAI,CAAC,iBAAiB,KAAK,QAAQ,CAAC,IAAI,EAAE;IAC5C,YAAA,OAAO,CAAC,EAAE,GAAG,SAAS,CAAC;IACxB,SAAA;IAAM,aAAA;IACL,YAAA,OAAO,CAAC,YAAY,CAAC,GAAG,SAAS,CAAC;IACnC,SAAA;IACD,QAAA,OAAO,CAAC,YAAY,GAAG,cAAc,CAAC;IACtC,QAAA,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC;SACrD;IACF;;IChhBD;;;;IAIG;UACU,MAAM,CAAA;IAyTjB;;IAEG;IACH,IAAA,WAAA,CAAY,OAAoB,EAAE,EAAA;IA/SlC;;;;;;;;IAQG;IACI,QAAA,IAAA,CAAA,aAAa,GAAG,QAAQ,CAAC,OAAO,CAAC;IAyBxC;;;IAGG;YACI,IAAiB,CAAA,iBAAA,GAAW,CAAC,CAAC;IAKrC;;IAEG;YACI,IAAc,CAAA,cAAA,GAAW,IAAI,CAAC;IAErC;;IAEG;YACI,IAAiB,CAAA,iBAAA,GAAW,KAAK,CAAC;IAEzC;;IAEG;YACI,IAAiB,CAAA,iBAAA,GAAW,KAAK,CAAC;IAEzC;;;;;;;;;;;;IAYG;YACI,IAAgB,CAAA,gBAAA,GAAY,KAAK,CAAC;IAEzC;;;IAGG;IACI,QAAA,IAAA,CAAA,qBAAqB,GAAW,CAAC,GAAG,IAAI,CAAC;IAEhD;;;;;;;IAOG;YACI,IAAmB,CAAA,mBAAA,GAAY,KAAK,CAAC;IAE5C;;;;;;;;;IASG;YACI,IAA2B,CAAA,2BAAA,GAAY,KAAK,CAAC;IAyJpD;;;;;;;IAOG;YACI,IAA6B,CAAA,6BAAA,GAAY,KAAK,CAAC;IA8BtD;;;;;IAKG;IACI,QAAA,IAAA,CAAA,KAAK,GAAoBC,uBAAe,CAAC,QAAQ,CAAC;;IASvD,QAAA,MAAM,IAAI,GAAG,MAAK,GAAG,CAAC;IACtB,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IAClB,QAAA,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;IAC1B,QAAA,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;IACtB,QAAA,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IACzB,QAAA,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAC/B,QAAA,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAC/B,QAAA,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC7B,QAAA,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;IACzB,QAAA,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC7B,QAAA,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;IAC7B,QAAA,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACjC,QAAA,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;;IAG1B,QAAA,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;IACzB,QAAA,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;;IAG7B,QAAA,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;SACtB;IAhOD;;IAEG;IACH,IAAA,IAAI,SAAS,GAAA;IACX,QAAA,OAAO,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC;SACvC;IASD;;IAEG;IACH,IAAA,IAAI,iBAAiB,GAAA;YACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;SAChC;QAED,IAAI,iBAAiB,CAAC,KAAmB,EAAA;IACvC,QAAA,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;YAChC,IAAI,IAAI,CAAC,aAAa,EAAE;gBACtB,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC;IAChE,SAAA;SACF;IA+BD;;IAEG;IACH,IAAA,IAAI,SAAS,GAAA;YACX,OAAO,CAAC,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;SAC7D;IAmGD;;IAEG;IACH,IAAA,IAAI,gBAAgB,GAAA;IAClB,QAAA,OAAO,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,SAAS,CAAC;SAC7E;IAID;;IAEG;IACH,IAAA,IAAI,MAAM,GAAA;IACR,QAAA,OAAO,IAAI,CAAC,KAAK,KAAKA,uBAAe,CAAC,MAAM,CAAC;SAC9C;IASO,IAAA,YAAY,CAAC,KAAsB,EAAA;IACzC,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACnB,QAAA,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;SAC3B;IAuCD;;IAEG;IACI,IAAA,SAAS,CAAC,IAAiB,EAAA;;IAE/B,QAAA,MAAc,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;SACpC;IAED;;;;;;IAMG;QACI,QAAQ,GAAA;YACb,MAAM,SAAS,GAAG,MAAK;gBACrB,IAAI,IAAI,CAAC,MAAM,EAAE;IACf,gBAAA,IAAI,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC;oBAC3D,OAAO;IACR,aAAA;IAED,YAAA,IAAI,CAAC,YAAY,CAACA,uBAAe,CAAC,MAAM,CAAC,CAAC;gBAE1C,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,SAAC,CAAC;;IAGF,QAAA,IAAI,IAAI,CAAC,KAAK,KAAKA,uBAAe,CAAC,YAAY,EAAE;IAC/C,YAAA,IAAI,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;IACnE,YAAA,IAAI,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,MAAK;IAC1B,gBAAA,SAAS,EAAE,CAAC;IACd,aAAC,CAAC,CAAC;IACJ,SAAA;IAAM,aAAA;IACL,YAAA,SAAS,EAAE,CAAC;IACb,SAAA;SACF;IAEO,IAAA,MAAM,QAAQ,GAAA;IACpB,QAAA,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YAE3B,IAAI,IAAI,CAAC,aAAa,EAAE;IACtB,YAAA,IAAI,CAAC,KAAK,CAAC,+DAA+D,CAAC,CAAC;gBAC5E,OAAO;IACR,SAAA;IAED,QAAA,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;IAChB,YAAA,IAAI,CAAC,KAAK,CACR,8DAA8D,CAC/D,CAAC;gBACF,OAAO;IACR,SAAA;;IAGD,QAAA,IAAI,IAAI,CAAC,iBAAiB,GAAG,CAAC,EAAE;;gBAE9B,IAAI,IAAI,CAAC,kBAAkB,EAAE;IAC3B,gBAAA,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IACvC,aAAA;IACD,YAAA,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC,MAAK;oBACxC,IAAI,IAAI,CAAC,SAAS,EAAE;wBAClB,OAAO;IACR,iBAAA;;;oBAGD,IAAI,CAAC,KAAK,CACR,CAAA,8BAAA,EAAiC,IAAI,CAAC,iBAAiB,CAAoB,kBAAA,CAAA,CAC5E,CAAC;oBACF,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,aAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC5B,SAAA;IAED,QAAA,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;;IAGpC,QAAA,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAE1C,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE;gBACrD,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,aAAa,EAAE,IAAI,CAAC,aAAa;gBACjC,cAAc,EAAE,IAAI,CAAC,cAAc;gBACnC,iBAAiB,EAAE,IAAI,CAAC,kBAAkB;gBAC1C,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACvC,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;gBACjD,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;gBAC7C,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;gBAC7C,2BAA2B,EAAE,IAAI,CAAC,2BAA2B;gBAC7D,6BAA6B,EAAE,IAAI,CAAC,6BAA6B;gBAEjE,SAAS,EAAE,KAAK,IAAG;;oBAEjB,IAAI,IAAI,CAAC,kBAAkB,EAAE;IAC3B,oBAAA,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;IACtC,oBAAA,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;IACrC,iBAAA;IAED,gBAAA,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;IAChB,oBAAA,IAAI,CAAC,KAAK,CACR,sEAAsE,CACvE,CAAC;wBACF,IAAI,CAAC,oBAAoB,EAAE,CAAC;wBAC5B,OAAO;IACR,iBAAA;IACD,gBAAA,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;iBACvB;gBACD,YAAY,EAAE,KAAK,IAAG;IACpB,gBAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;iBAC1B;gBACD,YAAY,EAAE,KAAK,IAAG;IACpB,gBAAA,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;iBAC1B;gBACD,gBAAgB,EAAE,GAAG,IAAG;IACtB,gBAAA,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;IAE/B,gBAAA,IAAI,IAAI,CAAC,KAAK,KAAKA,uBAAe,CAAC,YAAY,EAAE;;IAE/C,oBAAA,IAAI,CAAC,YAAY,CAACA,uBAAe,CAAC,QAAQ,CAAC,CAAC;IAC7C,iBAAA;;;IAID,gBAAA,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;oBAE3B,IAAI,IAAI,CAAC,MAAM,EAAE;wBACf,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC5B,iBAAA;iBACF;gBACD,gBAAgB,EAAE,GAAG,IAAG;IACtB,gBAAA,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;iBAC5B;gBACD,kBAAkB,EAAE,OAAO,IAAG;IAC5B,gBAAA,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;iBAClC;gBACD,kBAAkB,EAAE,KAAK,IAAG;IAC1B,gBAAA,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;iBAChC;gBACD,gBAAgB,EAAE,KAAK,IAAG;IACxB,gBAAA,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;iBAC9B;IACF,SAAA,CAAC,CAAC;IAEH,QAAA,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SAC5B;QAEO,gBAAgB,GAAA;IACtB,QAAA,IAAI,SAAuB,CAAC;YAE5B,IAAI,IAAI,CAAC,gBAAgB,EAAE;IACzB,YAAA,SAAS,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACrC,SAAA;iBAAM,IAAI,IAAI,CAAC,SAAS,EAAE;IACzB,YAAA,SAAS,GAAG,IAAI,SAAS,CACvB,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CACtC,CAAC;IACH,SAAA;IAAM,aAAA;IACL,YAAA,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC1E,SAAA;IACD,QAAA,SAAS,CAAC,UAAU,GAAG,aAAa,CAAC;IACrC,QAAA,OAAO,SAAS,CAAC;SAClB;QAEO,mBAAmB,GAAA;IACzB,QAAA,IAAI,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE;gBAC3B,IAAI,CAAC,KAAK,CAAC,CAAA,kCAAA,EAAqC,IAAI,CAAC,cAAc,CAAI,EAAA,CAAA,CAAC,CAAC;IAEzE,YAAA,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,MAAK;oBAClC,IAAI,CAAC,QAAQ,EAAE,CAAC;IAClB,aAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IACzB,SAAA;SACF;IAED;;;;;;;;;;;;;;;;;;;;;;IAsBG;IACI,IAAA,MAAM,UAAU,CAAC,OAAA,GAA+B,EAAE,EAAA;IACvD,QAAA,MAAM,KAAK,GAAY,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;IAC9C,QAAA,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC;IAClC,QAAA,IAAI,UAAyB,CAAC;IAE9B,QAAA,IAAI,IAAI,CAAC,KAAK,KAAKA,uBAAe,CAAC,QAAQ,EAAE;IAC3C,YAAA,IAAI,CAAC,KAAK,CAAC,CAAA,oCAAA,CAAsC,CAAC,CAAC;IACnD,YAAA,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC1B,SAAA;IAED,QAAA,IAAI,CAAC,YAAY,CAACA,uBAAe,CAAC,YAAY,CAAC,CAAC;;YAGhD,IAAI,IAAI,CAAC,YAAY,EAAE;IACrB,YAAA,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;IAChC,YAAA,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;IAC/B,SAAA;YAED,IACE,IAAI,CAAC,aAAa;;gBAElB,IAAI,CAAC,SAAS,CAAC,UAAU,KAAKD,wBAAgB,CAAC,MAAM,EACrD;IACA,YAAA,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC;;gBAEjE,UAAU,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,KAAI;;IAEjD,gBAAA,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,GAAG,IAAG;wBAC1C,oBAAoB,CAAC,GAAG,CAAC,CAAC;IAC1B,oBAAA,OAAO,EAAE,CAAC;IACZ,iBAAC,CAAC;IACJ,aAAC,CAAC,CAAC;IACJ,SAAA;IAAM,aAAA;;IAEL,YAAA,IAAI,CAAC,YAAY,CAACC,uBAAe,CAAC,QAAQ,CAAC,CAAC;IAC5C,YAAA,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;IAC1B,SAAA;IAED,QAAA,IAAI,KAAK,EAAE;IACT,YAAA,IAAI,CAAC,aAAa,EAAE,gBAAgB,EAAE,CAAC;IACxC,SAAA;IAAM,aAAA,IAAI,aAAa,EAAE;gBACxB,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC7B,SAAA;IAED,QAAA,OAAO,UAAU,CAAC;SACnB;IAED;;;;;IAKG;QACI,eAAe,GAAA;YACpB,IAAI,IAAI,CAAC,aAAa,EAAE;IACtB,YAAA,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;IACtC,SAAA;SACF;QAEO,oBAAoB,GAAA;;YAE1B,IAAI,IAAI,CAAC,aAAa,EAAE;IACtB,YAAA,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;IAC9B,SAAA;SACF;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmCG;IACI,IAAA,OAAO,CAAC,MAAsB,EAAA;YACnC,IAAI,CAAC,gBAAgB,EAAE,CAAC;;IAExB,QAAA,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;SACpC;QAEO,gBAAgB,GAAA;IACtB,QAAA,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;IACnB,YAAA,MAAM,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAC;IAChE,SAAA;SACF;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkCG;QACI,eAAe,CAAC,SAAiB,EAAE,QAA2B,EAAA;YACnE,IAAI,CAAC,gBAAgB,EAAE,CAAC;;YAExB,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;SACzD;IAED;;;;;;;;;;;;;;;;;;;;;;;IAuBG;IACI,IAAA,SAAS,CACd,WAAmB,EACnB,QAA6B,EAC7B,UAAwB,EAAE,EAAA;YAE1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;;IAExB,QAAA,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;SACrE;IAED;;;;;;;;;;;IAWG;IACI,IAAA,WAAW,CAAC,EAAU,EAAE,OAAA,GAAwB,EAAE,EAAA;YACvD,IAAI,CAAC,gBAAgB,EAAE,CAAC;;YAExB,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;SAC7C;IAED;;;;;IAKG;IACI,IAAA,KAAK,CAAC,aAAsB,EAAA;YACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;;YAExB,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SAChD;IAED;;;;;;;;;;;IAWG;IACI,IAAA,MAAM,CAAC,aAAqB,EAAA;YACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;;IAExB,QAAA,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;SAC1C;IAED;;;;;;;;;;IAUG;IACI,IAAA,KAAK,CAAC,aAAqB,EAAA;YAChC,IAAI,CAAC,gBAAgB,EAAE,CAAC;;IAExB,QAAA,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;SACzC;IAED;;;;;;;;;;;;IAYG;IACI,IAAA,GAAG,CACR,SAAiB,EACjB,cAAsB,EACtB,UAAwB,EAAE,EAAA;YAE1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;;YAExB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;SAC5D;IAED;;;;;;;;;;;;IAYG;IACI,IAAA,IAAI,CACT,SAAiB,EACjB,cAAsB,EACtB,UAAwB,EAAE,EAAA;YAE1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;;YAExB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;SAC7D;IACF;;ICv1BD;;;;;;IAMG;UACU,WAAW,CAAA;IAkIvB;;ICpJD;;;;;;;;IAQG;UACU,YAAY,CAAA;IAExB;;ICTD;;;;IAIG;UACU,aAAa,CAAA;IACxB,IAAA,WAAA,CAAoB,MAAoB,EAAA;YAApB,IAAM,CAAA,MAAA,GAAN,MAAM,CAAc;SAAI;IAE5C,IAAA,IAAI,QAAQ,GAAA;IACV,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;SACtC;QAED,IAAI,QAAQ,CAAC,KAAa,EAAA;IACxB,QAAA,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,KAAK,CAAC;SACvC;IAED,IAAA,IAAI,QAAQ,GAAA;IACV,QAAA,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;SACtC;QAED,IAAI,QAAQ,CAAC,KAAa,EAAA;IACxB,QAAA,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,KAAK,CAAC;SACvC;IACF;;ICpBD;;;;;;;;IAQG;IACG,MAAO,YAAa,SAAQ,MAAM,CAAA;IAMtC;;;;;;;IAOG;IACH,IAAA,WAAA,CAAY,gBAA2B,EAAA;IACrC,QAAA,KAAK,EAAE,CAAC;IAdV;;IAEG;IACI,QAAA,IAAA,CAAA,qBAAqB,GAAW,EAAE,GAAG,IAAI,CAAC;IAoOzC,QAAA,IAAA,CAAA,cAAc,GAAkB,IAAI,aAAa,CAAC,IAAI,CAAC,CAAC;IAxN9D,QAAA,IAAI,CAAC,eAAe,GAAG,CAAC,CAAC;IACzB,QAAA,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;;IAEzC,QAAA,IAAI,CAAC,KAAK,GAAG,CAAC,GAAG,OAAc,KAAI;IACjC,YAAA,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;IAC1B,SAAC,CAAC;SACH;QAEO,aAAa,CAAC,GAAG,IAAW,EAAA;IAClC,QAAA,IAAI,kBAAkB,CAAC;IACvB,QAAA,IAAI,eAAe,CAAC;IACpB,QAAA,IAAI,aAAa,CAAC;YAClB,IAAI,OAAO,GAAiB,EAAE,CAAC;IAC/B,QAAA,IAAI,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE;IACnB,YAAA,MAAM,IAAI,KAAK,CAAC,uCAAuC,CAAC,CAAC;IAC1D,SAAA;IACD,QAAA,IAAI,OAAO,IAAI,CAAC,CAAC,CAAC,KAAK,UAAU,EAAE;gBACjC,CAAC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,kBAAkB,CAAC,GAAG,IAAI,CAAC;IACtE,SAAA;IAAM,aAAA;gBACL,QAAQ,IAAI,CAAC,MAAM;IACjB,gBAAA,KAAK,CAAC;IACJ,oBAAA;IACE,wBAAA,OAAO,CAAC,KAAK;IACb,wBAAA,OAAO,CAAC,QAAQ;4BAChB,eAAe;4BACf,aAAa;4BACb,kBAAkB;IAClB,wBAAA,OAAO,CAAC,IAAI;IACb,qBAAA,GAAG,IAAI,CAAC;wBACT,MAAM;IACR,gBAAA;IACE,oBAAA;IACE,wBAAA,OAAO,CAAC,KAAK;IACb,wBAAA,OAAO,CAAC,QAAQ;4BAChB,eAAe;4BACf,aAAa;4BACb,kBAAkB;IACnB,qBAAA,GAAG,IAAI,CAAC;IACZ,aAAA;IACF,SAAA;YAED,OAAO,CAAC,OAAO,EAAE,eAAe,EAAE,aAAa,EAAE,kBAAkB,CAAC,CAAC;SACtE;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;IA0BG;QACI,OAAO,CAAC,GAAG,IAAW,EAAA;YAC3B,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,CAAC;IAExC,QAAA,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE;IACV,YAAA,IAAI,CAAC,cAAc,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IAC9B,SAAA;IACD,QAAA,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE;IACV,YAAA,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACzB,SAAA;IACD,QAAA,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE;IACV,YAAA,IAAI,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IAC5B,SAAA;IACD,QAAA,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE;IACV,YAAA,IAAI,CAAC,gBAAgB,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IAChC,SAAA;YAED,KAAK,CAAC,QAAQ,EAAE,CAAC;SAClB;IAED;;;;;;;;;;IAUG;IACI,IAAA,UAAU,CACf,kBAAwB,EACxB,OAAA,GAAwB,EAAE,EAAA;IAE1B,QAAA,IAAI,kBAAkB,EAAE;IACtB,YAAA,IAAI,CAAC,YAAY,GAAG,kBAAkB,CAAC;IACxC,SAAA;IACD,QAAA,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC;YAEjC,KAAK,CAAC,UAAU,EAAE,CAAC;SACpB;IAED;;;;;;;;;;;;;;;;;;;IAmBG;IACI,IAAA,IAAI,CACT,WAAmB,EACnB,UAAkC,EAAE,EACpC,OAAe,EAAE,EAAA;YAEjB,OAAO,GAAI,MAAc,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;YAE9C,MAAM,uBAAuB,GAAG,OAAO,CAAC,gBAAgB,CAAC,KAAK,KAAK,CAAC;IACpE,QAAA,IAAI,uBAAuB,EAAE;IAC3B,YAAA,OAAO,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAClC,SAAA;YACD,IAAI,CAAC,OAAO,CAAC;gBACX,WAAW;IACX,YAAA,OAAO,EAAE,OAAuB;gBAChC,IAAI;gBACJ,uBAAuB;IACxB,SAAA,CAAC,CAAC;SACJ;IAED;;;;IAIG;QACH,IAAI,eAAe,CAAC,KAAa,EAAA;IAC/B,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;SAC7B;IAED;;;;IAIG;IACH,IAAA,IAAI,EAAE,GAAA;YACJ,OAAO,IAAI,CAAC,SAAS,CAAC;SACvB;IAED;;;;IAIG;IACH,IAAA,IAAI,OAAO,GAAA;YACT,OAAO,IAAI,CAAC,gBAAgB,CAAC;SAC9B;IAED;;;;IAIG;IACH,IAAA,IAAI,SAAS,GAAA;YACX,OAAO,IAAI,CAAC,kBAAkB,CAAC;SAChC;IAED;;;;IAIG;QACH,IAAI,SAAS,CAAC,KAA0B,EAAA;IACtC,QAAA,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;SACjC;IAED;;;;;IAKG;IACH,IAAA,IAAI,SAAS,GAAA;YACX,OAAO,IAAI,CAAC,kBAAkB,CAAC;SAChC;IAED;;;;IAIG;QACH,IAAI,SAAS,CAAC,KAAwB,EAAA;IACpC,QAAA,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;SACjC;IAID;;;;;IAKG;IACH,IAAA,IAAI,SAAS,GAAA;YACX,OAAO,IAAI,CAAC,cAAc,CAAC;SAC5B;IAED;;;;;IAKG;QACH,IAAI,SAAS,CAAC,KAA6C,EAAA;IACzD,QAAA,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,QAAQ,CAAC;IACxC,QAAA,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC,QAAQ,CAAC;SACzC;IACF;;IChQD;;;;;;;;IAQG;UACU,KAAK,CAAA;IAqBhB;;;;;;;;;;;;;IAaG;IACI,IAAA,OAAO,MAAM,CAAC,GAAW,EAAE,SAAoB,EAAA;;;;;;;;;;;;;YAcpD,IAAI,SAAS,IAAI,IAAI,EAAE;IACrB,YAAA,SAAS,GAAG,QAAQ,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;IACjD,SAAA;YACD,MAAM,IAAI,GAAG,MAAK;IAChB,YAAA,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,IAAI,SAAS,CAAC;IAChD,YAAA,OAAO,IAAI,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IACnC,SAAC,CAAC;IAEF,QAAA,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;SAC/B;IAED;;;;;;;;;;;;;;;;;;;;IAoBG;QACI,OAAO,IAAI,CAAC,EAAO,EAAA;IACxB,QAAA,IAAI,IAAe,CAAC;IAEpB,QAAA,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE;gBAC5B,IAAI,GAAG,EAAE,CAAC;IACX,SAAA;IAAM,aAAA;gBACL,OAAO,CAAC,IAAI,CACV,sEAAsE;IACpE,gBAAA,+EAA+E,CAClF,CAAC;IACF,YAAA,IAAI,GAAG,MAAM,EAAE,CAAC;IACjB,SAAA;IAED,QAAA,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;SAC/B;;IA9FD;;;;;;;;;;;;;;;;IAgBG;IACH;IACc,KAAc,CAAA,cAAA,GAAQ,IAAI;;;;;;;;;;;;;;;"} Index: node_modules/@stomp/stompjs/bundles/stomp.umd.min.js =================================================================== --- node_modules/@stomp/stompjs/bundles/stomp.umd.min.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/bundles/stomp.umd.min.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e="undefined"!=typeof globalThis?globalThis:e||self).StompJs={})}(this,(function(e){"use strict";const t="\n",s="\0";class n{constructor(e){const{command:t,headers:s,body:n,binaryBody:i,escapeHeaderValues:o,skipContentLengthHeader:c}=e;this.command=t,this.headers=Object.assign({},s||{}),i?(this._binaryBody=i,this.isBinaryBody=!0):(this._body=n||"",this.isBinaryBody=!1),this.escapeHeaderValues=o||!1,this.skipContentLengthHeader=c||!1}get body(){return!this._body&&this.isBinaryBody&&(this._body=(new TextDecoder).decode(this._binaryBody)),this._body||""}get binaryBody(){return this._binaryBody||this.isBinaryBody||(this._binaryBody=(new TextEncoder).encode(this._body)),this._binaryBody}static fromRawFrame(e,t){const s={},i=e=>e.replace(/^\s+|\s+$/g,"");for(const o of e.headers.reverse()){o.indexOf(":");const c=i(o[0]);let r=i(o[1]);t&&"CONNECT"!==e.command&&"CONNECTED"!==e.command&&(r=n.hdrValueUnEscape(r)),s[c]=r}return new n({command:e.command,headers:s,binaryBody:e.binaryBody,escapeHeaderValues:t})}toString(){return this.serializeCmdAndHeaders()}serialize(){const e=this.serializeCmdAndHeaders();return this.isBinaryBody?n.toUnit8Array(e,this._binaryBody).buffer:e+this._body+s}serializeCmdAndHeaders(){const e=[this.command];this.skipContentLengthHeader&&delete this.headers["content-length"];for(const t of Object.keys(this.headers||{})){const s=this.headers[t];this.escapeHeaderValues&&"CONNECT"!==this.command&&"CONNECTED"!==this.command?e.push(`${t}:${n.hdrValueEscape(`${s}`)}`):e.push(`${t}:${s}`)}return(this.isBinaryBody||!this.isBodyEmpty()&&!this.skipContentLengthHeader)&&e.push(`content-length:${this.bodyLength()}`),e.join(t)+t+t}isBodyEmpty(){return 0===this.bodyLength()}bodyLength(){const e=this.binaryBody;return e?e.length:0}static sizeOfUTF8(e){return e?(new TextEncoder).encode(e).length:0}static toUnit8Array(e,t){const s=(new TextEncoder).encode(e),n=new Uint8Array([0]),i=new Uint8Array(s.length+t.length+n.length);return i.set(s),i.set(t,s.length),i.set(n,s.length+t.length),i}static marshall(e){return new n(e).serialize()}static hdrValueEscape(e){return e.replace(/\\/g,"\\\\").replace(/\r/g,"\\r").replace(/\n/g,"\\n").replace(/:/g,"\\c")}static hdrValueUnEscape(e){return e.replace(/\\r/g,"\r").replace(/\\n/g,"\n").replace(/\\c/g,":").replace(/\\\\/g,"\\")}}class i{constructor(e,t){this.onFrame=e,this.onIncomingPing=t,this._encoder=new TextEncoder,this._decoder=new TextDecoder,this._token=[],this._initState()}parseChunk(e,t=!1){let s;if(s="string"==typeof e?this._encoder.encode(e):new Uint8Array(e),t&&0!==s[s.length-1]){const e=new Uint8Array(s.length+1);e.set(s,0),e[s.length]=0,s=e}for(let e=0;e"content-length"===e[0]))[0];e?(this._bodyBytesRemaining=parseInt(e[1],10),this._onByte=this._collectBodyFixedSize):this._onByte=this._collectBodyNullTerminated}_collectBodyNullTerminated(e){0!==e?this._consumeByte(e):this._retrievedBody()}_collectBodyFixedSize(e){0!=this._bodyBytesRemaining--?this._consumeByte(e):this._retrievedBody()}_retrievedBody(){this._results.binaryBody=this._consumeTokenAsRaw();try{this.onFrame(this._results)}catch(e){console.log("Ignoring an exception thrown by a frame handler. Original exception: ",e)}this._initState()}_consumeByte(e){this._token.push(e)}_consumeTokenAsUTF8(){return this._decoder.decode(this._consumeTokenAsRaw())}_consumeTokenAsRaw(){const e=new Uint8Array(this._token);return this._token=[],e}_initState(){this._results={command:void 0,headers:[],binaryBody:void 0},this._token=[],this._headerKey=void 0,this._onByte=this._collectFrame}}var o,c;e.StompSocketState=void 0,(o=e.StompSocketState=e.StompSocketState||(e.StompSocketState={}))[o.CONNECTING=0]="CONNECTING",o[o.OPEN=1]="OPEN",o[o.CLOSING=2]="CLOSING",o[o.CLOSED=3]="CLOSED",e.ActivationState=void 0,(c=e.ActivationState=e.ActivationState||(e.ActivationState={}))[c.ACTIVE=0]="ACTIVE",c[c.DEACTIVATING=1]="DEACTIVATING",c[c.INACTIVE=2]="INACTIVE";class r{constructor(e){this.versions=e}supportedVersions(){return this.versions.join(",")}protocolVersions(){return this.versions.map((e=>`v${e.replace(".","")}.stomp`))}}r.V1_0="1.0",r.V1_1="1.1",r.V1_2="1.2",r.default=new r([r.V1_2,r.V1_1,r.V1_0]);class a{constructor(e,t,s){this._client=e,this._webSocket=t,this._connected=!1,this._serverFrameHandlers={CONNECTED:e=>{this.debug(`connected to server ${e.headers.server}`),this._connected=!0,this._connectedVersion=e.headers.version,this._connectedVersion===r.V1_2&&(this._escapeHeaderValues=!0),this._setupHeartbeat(e.headers),this.onConnect(e)},MESSAGE:e=>{const t=e.headers.subscription,s=this._subscriptions[t]||this.onUnhandledMessage,n=e,i=this,o=this._connectedVersion===r.V1_2?n.headers.ack:n.headers["message-id"];n.ack=(e={})=>i.ack(o,t,e),n.nack=(e={})=>i.nack(o,t,e),s(n)},RECEIPT:e=>{const t=this._receiptWatchers[e.headers["receipt-id"]];t?(t(e),delete this._receiptWatchers[e.headers["receipt-id"]]):this.onUnhandledReceipt(e)},ERROR:e=>{this.onStompError(e)}},this._counter=0,this._subscriptions={},this._receiptWatchers={},this._partialData="",this._escapeHeaderValues=!1,this._lastServerActivityTS=Date.now(),this.debug=s.debug,this.stompVersions=s.stompVersions,this.connectHeaders=s.connectHeaders,this.disconnectHeaders=s.disconnectHeaders,this.heartbeatIncoming=s.heartbeatIncoming,this.heartbeatOutgoing=s.heartbeatOutgoing,this.splitLargeFrames=s.splitLargeFrames,this.maxWebSocketChunkSize=s.maxWebSocketChunkSize,this.forceBinaryWSFrames=s.forceBinaryWSFrames,this.logRawCommunication=s.logRawCommunication,this.appendMissingNULLonIncoming=s.appendMissingNULLonIncoming,this.discardWebsocketOnCommFailure=s.discardWebsocketOnCommFailure,this.onConnect=s.onConnect,this.onDisconnect=s.onDisconnect,this.onStompError=s.onStompError,this.onWebSocketClose=s.onWebSocketClose,this.onWebSocketError=s.onWebSocketError,this.onUnhandledMessage=s.onUnhandledMessage,this.onUnhandledReceipt=s.onUnhandledReceipt,this.onUnhandledFrame=s.onUnhandledFrame}get connectedVersion(){return this._connectedVersion}get connected(){return this._connected}start(){const e=new i((e=>{const t=n.fromRawFrame(e,this._escapeHeaderValues);this.logRawCommunication||this.debug(`<<< ${t}`);(this._serverFrameHandlers[t.command]||this.onUnhandledFrame)(t)}),(()=>{this.debug("<<< PONG")}));this._webSocket.onmessage=t=>{if(this.debug("Received data"),this._lastServerActivityTS=Date.now(),this.logRawCommunication){const e=t.data instanceof ArrayBuffer?(new TextDecoder).decode(t.data):t.data;this.debug(`<<< ${e}`)}e.parseChunk(t.data,this.appendMissingNULLonIncoming)},this._webSocket.onclose=e=>{this.debug(`Connection closed to ${this._webSocket.url}`),this._cleanUp(),this.onWebSocketClose(e)},this._webSocket.onerror=e=>{this.onWebSocketError(e)},this._webSocket.onopen=()=>{const e=Object.assign({},this.connectHeaders);this.debug("Web Socket Opened..."),e["accept-version"]=this.stompVersions.supportedVersions(),e["heart-beat"]=[this.heartbeatOutgoing,this.heartbeatIncoming].join(","),this._transmit({command:"CONNECT",headers:e})}}_setupHeartbeat(s){if(s.version!==r.V1_1&&s.version!==r.V1_2)return;if(!s["heart-beat"])return;const[n,i]=s["heart-beat"].split(",").map((e=>parseInt(e,10)));if(0!==this.heartbeatOutgoing&&0!==i){const s=Math.max(this.heartbeatOutgoing,i);this.debug(`send PING every ${s}ms`),this._pinger=setInterval((()=>{this._webSocket.readyState===e.StompSocketState.OPEN&&(this._webSocket.send(t),this.debug(">>> PING"))}),s)}if(0!==this.heartbeatIncoming&&0!==n){const e=Math.max(this.heartbeatIncoming,n);this.debug(`check PONG every ${e}ms`),this._ponger=setInterval((()=>{const t=Date.now()-this._lastServerActivityTS;t>2*e&&(this.debug(`did not receive server activity for the last ${t}ms`),this._closeOrDiscardWebsocket())}),e)}}_closeOrDiscardWebsocket(){this.discardWebsocketOnCommFailure?(this.debug("Discarding websocket, the underlying socket may linger for a while"),this.discardWebsocket()):(this.debug("Issuing close on the websocket"),this._closeWebsocket())}forceDisconnect(){this._webSocket&&(this._webSocket.readyState!==e.StompSocketState.CONNECTING&&this._webSocket.readyState!==e.StompSocketState.OPEN||this._closeOrDiscardWebsocket())}_closeWebsocket(){this._webSocket.onmessage=()=>{},this._webSocket.close()}discardWebsocket(){var e,t;"function"!=typeof this._webSocket.terminate&&(e=this._webSocket,t=e=>this.debug(e),e.terminate=function(){const s=()=>{};this.onerror=s,this.onmessage=s,this.onopen=s;const n=new Date,i=Math.random().toString().substring(2,8),o=this.onclose;this.onclose=e=>{const s=(new Date).getTime()-n.getTime();t(`Discarded socket (#${i}) closed after ${s}ms, with code/reason: ${e.code}/${e.reason}`)},this.close(),o?.call(e,{code:4001,reason:`Quick discarding socket (#${i}) without waiting for the shutdown sequence.`,wasClean:!1})}),this._webSocket.terminate()}_transmit(e){const{command:t,headers:s,body:i,binaryBody:o,skipContentLengthHeader:c}=e,r=new n({command:t,headers:s,body:i,binaryBody:o,escapeHeaderValues:this._escapeHeaderValues,skipContentLengthHeader:c});let a=r.serialize();if(this.logRawCommunication?this.debug(`>>> ${a}`):this.debug(`>>> ${r}`),this.forceBinaryWSFrames&&"string"==typeof a&&(a=(new TextEncoder).encode(a)),"string"==typeof a&&this.splitLargeFrames){let e=a;for(;e.length>0;){const t=e.substring(0,this.maxWebSocketChunkSize);e=e.substring(this.maxWebSocketChunkSize),this._webSocket.send(t),this.debug(`chunk sent = ${t.length}, remaining = ${e.length}`)}}else this._webSocket.send(a)}dispose(){if(this.connected)try{const e=Object.assign({},this.disconnectHeaders);e.receipt||(e.receipt="close-"+this._counter++),this.watchForReceipt(e.receipt,(e=>{this._closeWebsocket(),this._cleanUp(),this.onDisconnect(e)})),this._transmit({command:"DISCONNECT",headers:e})}catch(e){this.debug(`Ignoring error during disconnect ${e}`)}else this._webSocket.readyState!==e.StompSocketState.CONNECTING&&this._webSocket.readyState!==e.StompSocketState.OPEN||this._closeWebsocket()}_cleanUp(){this._connected=!1,this._pinger&&(clearInterval(this._pinger),this._pinger=void 0),this._ponger&&(clearInterval(this._ponger),this._ponger=void 0)}publish(e){const{destination:t,headers:s,body:n,binaryBody:i,skipContentLengthHeader:o}=e,c=Object.assign({destination:t},s);this._transmit({command:"SEND",headers:c,body:n,binaryBody:i,skipContentLengthHeader:o})}watchForReceipt(e,t){this._receiptWatchers[e]=t}subscribe(e,t,s={}){(s=Object.assign({},s)).id||(s.id="sub-"+this._counter++),s.destination=e,this._subscriptions[s.id]=t,this._transmit({command:"SUBSCRIBE",headers:s});const n=this;return{id:s.id,unsubscribe:e=>n.unsubscribe(s.id,e)}}unsubscribe(e,t={}){t=Object.assign({},t),delete this._subscriptions[e],t.id=e,this._transmit({command:"UNSUBSCRIBE",headers:t})}begin(e){const t=e||"tx-"+this._counter++;this._transmit({command:"BEGIN",headers:{transaction:t}});const s=this;return{id:t,commit(){s.commit(t)},abort(){s.abort(t)}}}commit(e){this._transmit({command:"COMMIT",headers:{transaction:e}})}abort(e){this._transmit({command:"ABORT",headers:{transaction:e}})}ack(e,t,s={}){s=Object.assign({},s),this._connectedVersion===r.V1_2?s.id=e:s["message-id"]=e,s.subscription=t,this._transmit({command:"ACK",headers:s})}nack(e,t,s={}){return s=Object.assign({},s),this._connectedVersion===r.V1_2?s.id=e:s["message-id"]=e,s.subscription=t,this._transmit({command:"NACK",headers:s})}}class h{constructor(t={}){this.stompVersions=r.default,this.connectionTimeout=0,this.reconnectDelay=5e3,this.heartbeatIncoming=1e4,this.heartbeatOutgoing=1e4,this.splitLargeFrames=!1,this.maxWebSocketChunkSize=8192,this.forceBinaryWSFrames=!1,this.appendMissingNULLonIncoming=!1,this.discardWebsocketOnCommFailure=!1,this.state=e.ActivationState.INACTIVE;const s=()=>{};this.debug=s,this.beforeConnect=s,this.onConnect=s,this.onDisconnect=s,this.onUnhandledMessage=s,this.onUnhandledReceipt=s,this.onUnhandledFrame=s,this.onStompError=s,this.onWebSocketClose=s,this.onWebSocketError=s,this.logRawCommunication=!1,this.onChangeState=s,this.connectHeaders={},this._disconnectHeaders={},this.configure(t)}get webSocket(){return this._stompHandler?._webSocket}get disconnectHeaders(){return this._disconnectHeaders}set disconnectHeaders(e){this._disconnectHeaders=e,this._stompHandler&&(this._stompHandler.disconnectHeaders=this._disconnectHeaders)}get connected(){return!!this._stompHandler&&this._stompHandler.connected}get connectedVersion(){return this._stompHandler?this._stompHandler.connectedVersion:void 0}get active(){return this.state===e.ActivationState.ACTIVE}_changeState(e){this.state=e,this.onChangeState(e)}configure(e){Object.assign(this,e)}activate(){const t=()=>{this.active?this.debug("Already ACTIVE, ignoring request to activate"):(this._changeState(e.ActivationState.ACTIVE),this._connect())};this.state===e.ActivationState.DEACTIVATING?(this.debug("Waiting for deactivation to finish before activating"),this.deactivate().then((()=>{t()}))):t()}async _connect(){if(await this.beforeConnect(),this._stompHandler)return void this.debug("There is already a stompHandler, skipping the call to connect");if(!this.active)return void this.debug("Client has been marked inactive, will not attempt to connect");this.connectionTimeout>0&&(this._connectionWatcher&&clearTimeout(this._connectionWatcher),this._connectionWatcher=setTimeout((()=>{this.connected||(this.debug(`Connection not established in ${this.connectionTimeout}ms, closing socket`),this.forceDisconnect())}),this.connectionTimeout)),this.debug("Opening Web Socket...");const t=this._createWebSocket();this._stompHandler=new a(this,t,{debug:this.debug,stompVersions:this.stompVersions,connectHeaders:this.connectHeaders,disconnectHeaders:this._disconnectHeaders,heartbeatIncoming:this.heartbeatIncoming,heartbeatOutgoing:this.heartbeatOutgoing,splitLargeFrames:this.splitLargeFrames,maxWebSocketChunkSize:this.maxWebSocketChunkSize,forceBinaryWSFrames:this.forceBinaryWSFrames,logRawCommunication:this.logRawCommunication,appendMissingNULLonIncoming:this.appendMissingNULLonIncoming,discardWebsocketOnCommFailure:this.discardWebsocketOnCommFailure,onConnect:e=>{if(this._connectionWatcher&&(clearTimeout(this._connectionWatcher),this._connectionWatcher=void 0),!this.active)return this.debug("STOMP got connected while deactivate was issued, will disconnect now"),void this._disposeStompHandler();this.onConnect(e)},onDisconnect:e=>{this.onDisconnect(e)},onStompError:e=>{this.onStompError(e)},onWebSocketClose:t=>{this._stompHandler=void 0,this.state===e.ActivationState.DEACTIVATING&&this._changeState(e.ActivationState.INACTIVE),this.onWebSocketClose(t),this.active&&this._schedule_reconnect()},onWebSocketError:e=>{this.onWebSocketError(e)},onUnhandledMessage:e=>{this.onUnhandledMessage(e)},onUnhandledReceipt:e=>{this.onUnhandledReceipt(e)},onUnhandledFrame:e=>{this.onUnhandledFrame(e)}}),this._stompHandler.start()}_createWebSocket(){let e;if(this.webSocketFactory)e=this.webSocketFactory();else{if(!this.brokerURL)throw new Error("Either brokerURL or webSocketFactory must be provided");e=new WebSocket(this.brokerURL,this.stompVersions.protocolVersions())}return e.binaryType="arraybuffer",e}_schedule_reconnect(){this.reconnectDelay>0&&(this.debug(`STOMP: scheduling reconnection in ${this.reconnectDelay}ms`),this._reconnector=setTimeout((()=>{this._connect()}),this.reconnectDelay))}async deactivate(t={}){const s=t.force||!1,n=this.active;let i;if(this.state===e.ActivationState.INACTIVE)return this.debug("Already INACTIVE, nothing more to do"),Promise.resolve();if(this._changeState(e.ActivationState.DEACTIVATING),this._reconnector&&(clearTimeout(this._reconnector),this._reconnector=void 0),!this._stompHandler||this.webSocket.readyState===e.StompSocketState.CLOSED)return this._changeState(e.ActivationState.INACTIVE),Promise.resolve();{const e=this._stompHandler.onWebSocketClose;i=new Promise(((t,s)=>{this._stompHandler.onWebSocketClose=s=>{e(s),t()}}))}return s?this._stompHandler?.discardWebsocket():n&&this._disposeStompHandler(),i}forceDisconnect(){this._stompHandler&&this._stompHandler.forceDisconnect()}_disposeStompHandler(){this._stompHandler&&this._stompHandler.dispose()}publish(e){this._checkConnection(),this._stompHandler.publish(e)}_checkConnection(){if(!this.connected)throw new TypeError("There is no underlying STOMP connection")}watchForReceipt(e,t){this._checkConnection(),this._stompHandler.watchForReceipt(e,t)}subscribe(e,t,s={}){return this._checkConnection(),this._stompHandler.subscribe(e,t,s)}unsubscribe(e,t={}){this._checkConnection(),this._stompHandler.unsubscribe(e,t)}begin(e){return this._checkConnection(),this._stompHandler.begin(e)}commit(e){this._checkConnection(),this._stompHandler.commit(e)}abort(e){this._checkConnection(),this._stompHandler.abort(e)}ack(e,t,s={}){this._checkConnection(),this._stompHandler.ack(e,t,s)}nack(e,t,s={}){this._checkConnection(),this._stompHandler.nack(e,t,s)}}class d{constructor(e){this.client=e}get outgoing(){return this.client.heartbeatOutgoing}set outgoing(e){this.client.heartbeatOutgoing=e}get incoming(){return this.client.heartbeatIncoming}set incoming(e){this.client.heartbeatIncoming=e}}class l extends h{constructor(e){super(),this.maxWebSocketFrameSize=16384,this._heartbeatInfo=new d(this),this.reconnect_delay=0,this.webSocketFactory=e,this.debug=(...e)=>{console.log(...e)}}_parseConnect(...e){let t,s,n,i={};if(e.length<2)throw new Error("Connect requires at least 2 arguments");if("function"==typeof e[1])[i,s,n,t]=e;else if(6===e.length)[i.login,i.passcode,s,n,t,i.host]=e;else[i.login,i.passcode,s,n,t]=e;return[i,s,n,t]}connect(...e){const t=this._parseConnect(...e);t[0]&&(this.connectHeaders=t[0]),t[1]&&(this.onConnect=t[1]),t[2]&&(this.onStompError=t[2]),t[3]&&(this.onWebSocketClose=t[3]),super.activate()}disconnect(e,t={}){e&&(this.onDisconnect=e),this.disconnectHeaders=t,super.deactivate()}send(e,t={},s=""){const n=!1===(t=Object.assign({},t))["content-length"];n&&delete t["content-length"],this.publish({destination:e,headers:t,body:s,skipContentLengthHeader:n})}set reconnect_delay(e){this.reconnectDelay=e}get ws(){return this.webSocket}get version(){return this.connectedVersion}get onreceive(){return this.onUnhandledMessage}set onreceive(e){this.onUnhandledMessage=e}get onreceipt(){return this.onUnhandledReceipt}set onreceipt(e){this.onUnhandledReceipt=e}get heartbeat(){return this._heartbeatInfo}set heartbeat(e){this.heartbeatIncoming=e.incoming,this.heartbeatOutgoing=e.outgoing}}class m{static client(e,t){null==t&&(t=r.default.protocolVersions());return new l((()=>new(m.WebSocketClass||WebSocket)(e,t)))}static over(e){let t;return"function"==typeof e?t=e:(console.warn("Stomp.over did not receive a factory, auto reconnect will not work. Please see https://stomp-js.github.io/api-docs/latest/classes/Stomp.html#over"),t=()=>e),new l(t)}}m.WebSocketClass=null,e.Client=h,e.CompatClient=l,e.FrameImpl=n,e.Parser=i,e.Stomp=m,e.StompConfig=class{},e.StompHeaders=class{},e.Versions=r})); Index: node_modules/@stomp/stompjs/esm6/augment-websocket.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/augment-websocket.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/augment-websocket.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,5 @@ +import { IStompSocket } from './types.js'; +/** + * @internal + */ +export declare function augmentWebsocket(webSocket: IStompSocket, debug: (msg: string) => void): void; Index: node_modules/@stomp/stompjs/esm6/augment-websocket.js =================================================================== --- node_modules/@stomp/stompjs/esm6/augment-websocket.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/augment-websocket.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,27 @@ +/** + * @internal + */ +export function augmentWebsocket(webSocket, debug) { + webSocket.terminate = function () { + const noOp = () => { }; + // set all callbacks to no op + this.onerror = noOp; + this.onmessage = noOp; + this.onopen = noOp; + const ts = new Date(); + const id = Math.random().toString().substring(2, 8); // A simulated id + const origOnClose = this.onclose; + // Track delay in actual closure of the socket + this.onclose = closeEvent => { + const delay = new Date().getTime() - ts.getTime(); + debug(`Discarded socket (#${id}) closed after ${delay}ms, with code/reason: ${closeEvent.code}/${closeEvent.reason}`); + }; + this.close(); + origOnClose?.call(webSocket, { + code: 4001, + reason: `Quick discarding socket (#${id}) without waiting for the shutdown sequence.`, + wasClean: false, + }); + }; +} +//# sourceMappingURL=augment-websocket.js.map Index: node_modules/@stomp/stompjs/esm6/augment-websocket.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/augment-websocket.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/augment-websocket.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"augment-websocket.js","sourceRoot":"","sources":["../src/augment-websocket.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAuB,EACvB,KAA4B;IAE5B,SAAS,CAAC,SAAS,GAAG;QACpB,MAAM,IAAI,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;QAEtB,6BAA6B;QAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QAEnB,MAAM,EAAE,GAAG,IAAI,IAAI,EAAE,CAAC;QACtB,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,iBAAiB;QAEtE,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC;QAEjC,8CAA8C;QAC9C,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,EAAE;YAC1B,MAAM,KAAK,GAAG,IAAI,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC;YAClD,KAAK,CACH,sBAAsB,EAAE,mBAAmB,KAAK,yBAAyB,UAAU,CAAC,IAAI,IAAI,UAAU,CAAC,MAAM,EAAE,CAChH,CAAC;QACJ,CAAC,CAAC;QAEF,IAAI,CAAC,KAAK,EAAE,CAAC;QAEb,WAAW,EAAE,IAAI,CAAC,SAAS,EAAE;YAC3B,IAAI,EAAE,IAAI;YACV,MAAM,EAAE,6BAA6B,EAAE,8CAA8C;YACrF,QAAQ,EAAE,KAAK;SAChB,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC"} Index: node_modules/@stomp/stompjs/esm6/byte.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/byte.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/byte.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,11 @@ +/** + * Some byte values, used as per STOMP specifications. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export declare const BYTE: { + LF: string; + NULL: string; +}; Index: node_modules/@stomp/stompjs/esm6/byte.js =================================================================== --- node_modules/@stomp/stompjs/esm6/byte.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/byte.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,14 @@ +/** + * Some byte values, used as per STOMP specifications. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export const BYTE = { + // LINEFEED byte (octet 10) + LF: '\x0A', + // NULL byte (octet 0) + NULL: '\x00', +}; +//# sourceMappingURL=byte.js.map Index: node_modules/@stomp/stompjs/esm6/byte.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/byte.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/byte.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"byte.js","sourceRoot":"","sources":["../src/byte.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,2BAA2B;IAC3B,EAAE,EAAE,MAAM;IACV,sBAAsB;IACtB,IAAI,EAAE,MAAM;CACb,CAAC"} Index: node_modules/@stomp/stompjs/esm6/client.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/client.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/client.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,495 @@ +import { ITransaction } from './i-transaction.js'; +import { StompConfig } from './stomp-config.js'; +import { StompHeaders } from './stomp-headers.js'; +import { StompSubscription } from './stomp-subscription.js'; +import { ActivationState, closeEventCallbackType, debugFnType, frameCallbackType, IPublishParams, IStompSocket, messageCallbackType, wsErrorCallbackType } from './types.js'; +import { Versions } from './versions.js'; +/** + * STOMP Client Class. + * + * Part of `@stomp/stompjs`. + */ +export declare class Client { + /** + * The URL for the STOMP broker to connect to. + * Typically like `"ws://broker.329broker.com:15674/ws"` or `"wss://broker.329broker.com:15674/ws"`. + * + * Only one of this or [Client#webSocketFactory]{@link Client#webSocketFactory} need to be set. + * If both are set, [Client#webSocketFactory]{@link Client#webSocketFactory} will be used. + * + * If your environment does not support WebSockets natively, please refer to + * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}. + */ + brokerURL: string | undefined; + /** + * STOMP versions to attempt during STOMP handshake. By default, versions `1.2`, `1.1`, and `1.0` are attempted. + * + * Example: + * ```javascript + * // Try only versions 1.1 and 1.0 + * client.stompVersions = new Versions(['1.1', '1.0']) + * ``` + */ + stompVersions: Versions; + /** + * This function should return a WebSocket or a similar (e.g. SockJS) object. + * If your environment does not support WebSockets natively, please refer to + * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}. + * If your STOMP Broker supports WebSockets, prefer setting [Client#brokerURL]{@link Client#brokerURL}. + * + * If both this and [Client#brokerURL]{@link Client#brokerURL} are set, this will be used. + * + * Example: + * ```javascript + * // use a WebSocket + * client.webSocketFactory= function () { + * return new WebSocket("wss://broker.329broker.com:15674/ws"); + * }; + * + * // Typical usage with SockJS + * client.webSocketFactory= function () { + * return new SockJS("http://broker.329broker.com/stomp"); + * }; + * ``` + */ + webSocketFactory: (() => IStompSocket) | undefined; + /** + * Will retry if Stomp connection is not established in specified milliseconds. + * Default 0, which switches off automatic reconnection. + */ + connectionTimeout: number; + private _connectionWatcher; + /** + * automatically reconnect with delay in milliseconds, set to 0 to disable. + */ + reconnectDelay: number; + /** + * Incoming heartbeat interval in milliseconds. Set to 0 to disable. + */ + heartbeatIncoming: number; + /** + * Outgoing heartbeat interval in milliseconds. Set to 0 to disable. + */ + heartbeatOutgoing: number; + /** + * This switches on a non-standard behavior while sending WebSocket packets. + * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}. + * Only Java Spring brokers seem to support this mode. + * + * WebSockets, by itself, split large (text) packets, + * so it is not needed with a truly compliant STOMP/WebSocket broker. + * Setting it for such a broker will cause large messages to fail. + * + * `false` by default. + * + * Binary frames are never split. + */ + splitLargeFrames: boolean; + /** + * See [splitLargeFrames]{@link Client#splitLargeFrames}. + * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`. + */ + maxWebSocketChunkSize: number; + /** + * Usually the + * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters} + * is automatically decided by type of the payload. + * Default is `false`, which should work with all compliant brokers. + * + * Set this flag to force binary frames. + */ + forceBinaryWSFrames: boolean; + /** + * A bug in ReactNative chops a string on occurrence of a NULL. + * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}. + * This makes incoming WebSocket messages invalid STOMP packets. + * Setting this flag attempts to reverse the damage by appending a NULL. + * If the broker splits a large message into multiple WebSocket messages, + * this flag will cause data loss and abnormal termination of connection. + * + * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library. + */ + appendMissingNULLonIncoming: boolean; + /** + * Underlying WebSocket instance, READONLY. + */ + get webSocket(): IStompSocket | undefined; + /** + * Connection headers, important keys - `login`, `passcode`, `host`. + * Though STOMP 1.2 standard marks these keys to be present, check your broker documentation for + * details specific to your broker. + */ + connectHeaders: StompHeaders; + /** + * Disconnection headers. + */ + get disconnectHeaders(): StompHeaders; + set disconnectHeaders(value: StompHeaders); + private _disconnectHeaders; + /** + * This function will be called for any unhandled messages. + * It is useful for receiving messages sent to RabbitMQ temporary queues. + * + * It can also get invoked with stray messages while the server is processing + * a request to [Client#unsubscribe]{@link Client#unsubscribe} + * from an endpoint. + * + * The actual {@link IMessage} will be passed as parameter to the callback. + */ + onUnhandledMessage: messageCallbackType; + /** + * STOMP brokers can be requested to notify when an operation is actually completed. + * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. See + * [Client#watchForReceipt]{@link Client#watchForReceipt} for examples. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + */ + onUnhandledReceipt: frameCallbackType; + /** + * Will be invoked if {@link IFrame} of an unknown type is received from the STOMP broker. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + */ + onUnhandledFrame: frameCallbackType; + /** + * `true` if there is an active connection to STOMP Broker + */ + get connected(): boolean; + /** + * Callback, invoked on before a connection to the STOMP broker. + * + * You can change options on the client, which will impact the immediate connecting. + * It is valid to call [Client#decativate]{@link Client#deactivate} in this callback. + * + * As of version 5.1, this callback can be + * [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function) + * (i.e., it can return a + * [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)). + * In that case, connect will be called only after the Promise is resolved. + * This can be used to reliably fetch credentials, access token etc. from some other service + * in an asynchronous way. + */ + beforeConnect: () => void | Promise; + /** + * Callback, invoked on every successful connection to the STOMP broker. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + * Sometimes clients will like to use headers from this frame. + */ + onConnect: frameCallbackType; + /** + * Callback, invoked on every successful disconnection from the STOMP broker. It will not be invoked if + * the STOMP broker disconnected due to an error. + * + * The actual Receipt {@link IFrame} acknowledging the DISCONNECT will be passed as parameter to the callback. + * + * The way STOMP protocol is designed, the connection may close/terminate without the client + * receiving the Receipt {@link IFrame} acknowledging the DISCONNECT. + * You might find [Client#onWebSocketClose]{@link Client#onWebSocketClose} more appropriate to watch + * STOMP broker disconnects. + */ + onDisconnect: frameCallbackType; + /** + * Callback, invoked on an ERROR frame received from the STOMP Broker. + * A compliant STOMP Broker will close the connection after this type of frame. + * Please check broker specific documentation for exact behavior. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + */ + onStompError: frameCallbackType; + /** + * Callback, invoked when underlying WebSocket is closed. + * + * Actual [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent} + * is passed as parameter to the callback. + */ + onWebSocketClose: closeEventCallbackType; + /** + * Callback, invoked when underlying WebSocket raises an error. + * + * Actual [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event} + * is passed as parameter to the callback. + */ + onWebSocketError: wsErrorCallbackType; + /** + * Set it to log the actual raw communication with the broker. + * When unset, it logs headers of the parsed frames. + * + * Changes effect from the next broker reconnect. + * + * **Caution: this assumes that frames only have valid UTF8 strings.** + */ + logRawCommunication: boolean; + /** + * By default, debug messages are discarded. To log to `console` following can be used: + * + * ```javascript + * client.debug = function(str) { + * console.log(str); + * }; + * ``` + * + * Currently this method does not support levels of log. Be aware that the + * output can be quite verbose + * and may contain sensitive information (like passwords, tokens etc.). + */ + debug: debugFnType; + /** + * Browsers do not immediately close WebSockets when `.close` is issued. + * This may cause reconnection to take a significantly long time in case + * of some types of failures. + * In case of incoming heartbeat failure, this experimental flag instructs + * the library to discard the socket immediately + * (even before it is actually closed). + */ + discardWebsocketOnCommFailure: boolean; + /** + * version of STOMP protocol negotiated with the server, READONLY + */ + get connectedVersion(): string | undefined; + private _stompHandler; + /** + * if the client is active (connected or going to reconnect) + */ + get active(): boolean; + /** + * It will be called on state change. + * + * When deactivating, it may go from ACTIVE to INACTIVE without entering DEACTIVATING. + */ + onChangeState: (state: ActivationState) => void; + private _changeState; + /** + * Activation state. + * + * It will usually be ACTIVE or INACTIVE. + * When deactivating, it may go from ACTIVE to INACTIVE without entering DEACTIVATING. + */ + state: ActivationState; + private _reconnector; + /** + * Create an instance. + */ + constructor(conf?: StompConfig); + /** + * Update configuration. + */ + configure(conf: StompConfig): void; + /** + * Initiate the connection with the broker. + * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay}, + * it will keep trying to reconnect. + * + * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts. + */ + activate(): void; + private _connect; + private _createWebSocket; + private _schedule_reconnect; + /** + * Disconnect if connected and stop auto reconnect loop. + * Appropriate callbacks will be invoked if there is an underlying STOMP connection. + * + * This call is async. It will resolve immediately if there is no underlying active websocket, + * otherwise, it will resolve after the underlying websocket is properly disposed of. + * + * It is not an error to invoke this method more than once. + * Each of those would resolve on completion of deactivation. + * + * To reactivate, you can call [Client#activate]{@link Client#activate}. + * + * Experimental: pass `force: true` to immediately discard the underlying connection. + * This mode will skip both the STOMP and the Websocket shutdown sequences. + * In some cases, browsers take a long time in the Websocket shutdown + * if the underlying connection had gone stale. + * Using this mode can speed up. + * When this mode is used, the actual Websocket may linger for a while + * and the broker may not realize that the connection is no longer in use. + * + * It is possible to invoke this method initially without the `force` option + * and subsequently, say after a wait, with the `force` option. + */ + deactivate(options?: { + force?: boolean; + }): Promise; + /** + * Force disconnect if there is an active connection by directly closing the underlying WebSocket. + * This is different from a normal disconnect where a DISCONNECT sequence is carried out with the broker. + * After forcing disconnect, automatic reconnect will be attempted. + * To stop further reconnects call [Client#deactivate]{@link Client#deactivate} as well. + */ + forceDisconnect(): void; + private _disposeStompHandler; + /** + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. + * + * STOMP protocol specifies and suggests some headers and also allows broker-specific headers. + * + * `body` must be String. + * You will need to covert the payload to string in case it is not string (e.g. JSON). + * + * To send a binary message body, use `binaryBody` parameter. It should be a + * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array). + * Sometimes brokers may not support binary frames out of the box. + * Please check your broker documentation. + * + * `content-length` header is automatically added to the STOMP Frame sent to the broker. + * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added. + * For binary messages, `content-length` header is always added. + * + * Caution: The broker will, most likely, report an error and disconnect + * if the message body has NULL octet(s) and `content-length` header is missing. + * + * ```javascript + * client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"}); + * + * // Only destination is mandatory parameter + * client.publish({destination: "/queue/test", body: "Hello, STOMP"}); + * + * // Skip content-length header in the frame to the broker + * client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true}); + * + * var binaryData = generateBinaryData(); // This need to be of type Uint8Array + * // setting content-type header is not mandatory, however a good practice + * client.publish({destination: '/topic/special', binaryBody: binaryData, + * headers: {'content-type': 'application/octet-stream'}}); + * ``` + */ + publish(params: IPublishParams): void; + private _checkConnection; + /** + * STOMP brokers may carry out operation asynchronously and allow requesting for acknowledgement. + * To request an acknowledgement, a `receipt` header needs to be sent with the actual request. + * The value (say receipt-id) for this header needs to be unique for each use. + * Typically, a sequence, a UUID, a random number or a combination may be used. + * + * A complaint broker will send a RECEIPT frame when an operation has actually been completed. + * The operation needs to be matched based on the value of the receipt-id. + * + * This method allows watching for a receipt and invoking the callback + * when the corresponding receipt has been received. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + * + * Example: + * ```javascript + * // Subscribing with acknowledgement + * let receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * + * client.subscribe(TEST.destination, onMessage, {receipt: receiptId}); + * + * + * // Publishing with acknowledgement + * receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg}); + * ``` + */ + watchForReceipt(receiptId: string, callback: frameCallbackType): void; + /** + * Subscribe to a STOMP Broker location. The callback will be invoked for each + * received message with the {@link IMessage} as argument. + * + * Note: The library will generate a unique ID if there is none provided in the headers. + * To use your own ID, pass it using the `headers` argument. + * + * ```javascript + * callback = function(message) { + * // called when the client receives a STOMP message from the server + * if (message.body) { + * alert("got message with body " + message.body) + * } else { + * alert("got empty message"); + * } + * }); + * + * var subscription = client.subscribe("/queue/test", callback); + * + * // Explicit subscription id + * var mySubId = 'my-subscription-id-001'; + * var subscription = client.subscribe(destination, callback, { id: mySubId }); + * ``` + */ + subscribe(destination: string, callback: messageCallbackType, headers?: StompHeaders): StompSubscription; + /** + * It is preferable to unsubscribe from a subscription by calling + * `unsubscribe()` directly on {@link StompSubscription} returned by `client.subscribe()`: + * + * ```javascript + * var subscription = client.subscribe(destination, onmessage); + * // ... + * subscription.unsubscribe(); + * ``` + * + * See: https://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame + */ + unsubscribe(id: string, headers?: StompHeaders): void; + /** + * Start a transaction, the returned {@link ITransaction} has methods - [commit]{@link ITransaction#commit} + * and [abort]{@link ITransaction#abort}. + * + * `transactionId` is optional, if not passed the library will generate it internally. + */ + begin(transactionId?: string): ITransaction; + /** + * Commit a transaction. + * + * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.commit(); + * ``` + */ + commit(transactionId: string): void; + /** + * Abort a transaction. + * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.abort(); + * ``` + */ + abort(transactionId: string): void; + /** + * ACK a message. It is preferable to acknowledge a message by calling [ack]{@link IMessage#ack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // acknowledge it + * message.ack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + ack(messageId: string, subscriptionId: string, headers?: StompHeaders): void; + /** + * NACK a message. It is preferable to acknowledge a message by calling [nack]{@link IMessage#nack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // an error occurs, nack it + * message.nack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + nack(messageId: string, subscriptionId: string, headers?: StompHeaders): void; +} Index: node_modules/@stomp/stompjs/esm6/client.js =================================================================== --- node_modules/@stomp/stompjs/esm6/client.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/client.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,594 @@ +import { StompHandler } from './stomp-handler.js'; +import { ActivationState, StompSocketState, } from './types.js'; +import { Versions } from './versions.js'; +/** + * STOMP Client Class. + * + * Part of `@stomp/stompjs`. + */ +export class Client { + /** + * Create an instance. + */ + constructor(conf = {}) { + /** + * STOMP versions to attempt during STOMP handshake. By default, versions `1.2`, `1.1`, and `1.0` are attempted. + * + * Example: + * ```javascript + * // Try only versions 1.1 and 1.0 + * client.stompVersions = new Versions(['1.1', '1.0']) + * ``` + */ + this.stompVersions = Versions.default; + /** + * Will retry if Stomp connection is not established in specified milliseconds. + * Default 0, which switches off automatic reconnection. + */ + this.connectionTimeout = 0; + /** + * automatically reconnect with delay in milliseconds, set to 0 to disable. + */ + this.reconnectDelay = 5000; + /** + * Incoming heartbeat interval in milliseconds. Set to 0 to disable. + */ + this.heartbeatIncoming = 10000; + /** + * Outgoing heartbeat interval in milliseconds. Set to 0 to disable. + */ + this.heartbeatOutgoing = 10000; + /** + * This switches on a non-standard behavior while sending WebSocket packets. + * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}. + * Only Java Spring brokers seem to support this mode. + * + * WebSockets, by itself, split large (text) packets, + * so it is not needed with a truly compliant STOMP/WebSocket broker. + * Setting it for such a broker will cause large messages to fail. + * + * `false` by default. + * + * Binary frames are never split. + */ + this.splitLargeFrames = false; + /** + * See [splitLargeFrames]{@link Client#splitLargeFrames}. + * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`. + */ + this.maxWebSocketChunkSize = 8 * 1024; + /** + * Usually the + * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters} + * is automatically decided by type of the payload. + * Default is `false`, which should work with all compliant brokers. + * + * Set this flag to force binary frames. + */ + this.forceBinaryWSFrames = false; + /** + * A bug in ReactNative chops a string on occurrence of a NULL. + * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}. + * This makes incoming WebSocket messages invalid STOMP packets. + * Setting this flag attempts to reverse the damage by appending a NULL. + * If the broker splits a large message into multiple WebSocket messages, + * this flag will cause data loss and abnormal termination of connection. + * + * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library. + */ + this.appendMissingNULLonIncoming = false; + /** + * Browsers do not immediately close WebSockets when `.close` is issued. + * This may cause reconnection to take a significantly long time in case + * of some types of failures. + * In case of incoming heartbeat failure, this experimental flag instructs + * the library to discard the socket immediately + * (even before it is actually closed). + */ + this.discardWebsocketOnCommFailure = false; + /** + * Activation state. + * + * It will usually be ACTIVE or INACTIVE. + * When deactivating, it may go from ACTIVE to INACTIVE without entering DEACTIVATING. + */ + this.state = ActivationState.INACTIVE; + // No op callbacks + const noOp = () => { }; + this.debug = noOp; + this.beforeConnect = noOp; + this.onConnect = noOp; + this.onDisconnect = noOp; + this.onUnhandledMessage = noOp; + this.onUnhandledReceipt = noOp; + this.onUnhandledFrame = noOp; + this.onStompError = noOp; + this.onWebSocketClose = noOp; + this.onWebSocketError = noOp; + this.logRawCommunication = false; + this.onChangeState = noOp; + // These parameters would typically get proper values before connect is called + this.connectHeaders = {}; + this._disconnectHeaders = {}; + // Apply configuration + this.configure(conf); + } + /** + * Underlying WebSocket instance, READONLY. + */ + get webSocket() { + return this._stompHandler?._webSocket; + } + /** + * Disconnection headers. + */ + get disconnectHeaders() { + return this._disconnectHeaders; + } + set disconnectHeaders(value) { + this._disconnectHeaders = value; + if (this._stompHandler) { + this._stompHandler.disconnectHeaders = this._disconnectHeaders; + } + } + /** + * `true` if there is an active connection to STOMP Broker + */ + get connected() { + return !!this._stompHandler && this._stompHandler.connected; + } + /** + * version of STOMP protocol negotiated with the server, READONLY + */ + get connectedVersion() { + return this._stompHandler ? this._stompHandler.connectedVersion : undefined; + } + /** + * if the client is active (connected or going to reconnect) + */ + get active() { + return this.state === ActivationState.ACTIVE; + } + _changeState(state) { + this.state = state; + this.onChangeState(state); + } + /** + * Update configuration. + */ + configure(conf) { + // bulk assign all properties to this + Object.assign(this, conf); + } + /** + * Initiate the connection with the broker. + * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay}, + * it will keep trying to reconnect. + * + * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts. + */ + activate() { + const _activate = () => { + if (this.active) { + this.debug('Already ACTIVE, ignoring request to activate'); + return; + } + this._changeState(ActivationState.ACTIVE); + this._connect(); + }; + // if it is deactivating, wait for it to complete before activating. + if (this.state === ActivationState.DEACTIVATING) { + this.debug('Waiting for deactivation to finish before activating'); + this.deactivate().then(() => { + _activate(); + }); + } + else { + _activate(); + } + } + async _connect() { + await this.beforeConnect(); + if (this._stompHandler) { + this.debug('There is already a stompHandler, skipping the call to connect'); + return; + } + if (!this.active) { + this.debug('Client has been marked inactive, will not attempt to connect'); + return; + } + // setup connection watcher + if (this.connectionTimeout > 0) { + // clear first + if (this._connectionWatcher) { + clearTimeout(this._connectionWatcher); + } + this._connectionWatcher = setTimeout(() => { + if (this.connected) { + return; + } + // Connection not established, close the underlying socket + // a reconnection will be attempted + this.debug(`Connection not established in ${this.connectionTimeout}ms, closing socket`); + this.forceDisconnect(); + }, this.connectionTimeout); + } + this.debug('Opening Web Socket...'); + // Get the actual WebSocket (or a similar object) + const webSocket = this._createWebSocket(); + this._stompHandler = new StompHandler(this, webSocket, { + debug: this.debug, + stompVersions: this.stompVersions, + connectHeaders: this.connectHeaders, + disconnectHeaders: this._disconnectHeaders, + heartbeatIncoming: this.heartbeatIncoming, + heartbeatOutgoing: this.heartbeatOutgoing, + splitLargeFrames: this.splitLargeFrames, + maxWebSocketChunkSize: this.maxWebSocketChunkSize, + forceBinaryWSFrames: this.forceBinaryWSFrames, + logRawCommunication: this.logRawCommunication, + appendMissingNULLonIncoming: this.appendMissingNULLonIncoming, + discardWebsocketOnCommFailure: this.discardWebsocketOnCommFailure, + onConnect: frame => { + // Successfully connected, stop the connection watcher + if (this._connectionWatcher) { + clearTimeout(this._connectionWatcher); + this._connectionWatcher = undefined; + } + if (!this.active) { + this.debug('STOMP got connected while deactivate was issued, will disconnect now'); + this._disposeStompHandler(); + return; + } + this.onConnect(frame); + }, + onDisconnect: frame => { + this.onDisconnect(frame); + }, + onStompError: frame => { + this.onStompError(frame); + }, + onWebSocketClose: evt => { + this._stompHandler = undefined; // a new one will be created in case of a reconnect + if (this.state === ActivationState.DEACTIVATING) { + // Mark deactivation complete + this._changeState(ActivationState.INACTIVE); + } + // The callback is called before attempting to reconnect, this would allow the client + // to be `deactivated` in the callback. + this.onWebSocketClose(evt); + if (this.active) { + this._schedule_reconnect(); + } + }, + onWebSocketError: evt => { + this.onWebSocketError(evt); + }, + onUnhandledMessage: message => { + this.onUnhandledMessage(message); + }, + onUnhandledReceipt: frame => { + this.onUnhandledReceipt(frame); + }, + onUnhandledFrame: frame => { + this.onUnhandledFrame(frame); + }, + }); + this._stompHandler.start(); + } + _createWebSocket() { + let webSocket; + if (this.webSocketFactory) { + webSocket = this.webSocketFactory(); + } + else if (this.brokerURL) { + webSocket = new WebSocket(this.brokerURL, this.stompVersions.protocolVersions()); + } + else { + throw new Error('Either brokerURL or webSocketFactory must be provided'); + } + webSocket.binaryType = 'arraybuffer'; + return webSocket; + } + _schedule_reconnect() { + if (this.reconnectDelay > 0) { + this.debug(`STOMP: scheduling reconnection in ${this.reconnectDelay}ms`); + this._reconnector = setTimeout(() => { + this._connect(); + }, this.reconnectDelay); + } + } + /** + * Disconnect if connected and stop auto reconnect loop. + * Appropriate callbacks will be invoked if there is an underlying STOMP connection. + * + * This call is async. It will resolve immediately if there is no underlying active websocket, + * otherwise, it will resolve after the underlying websocket is properly disposed of. + * + * It is not an error to invoke this method more than once. + * Each of those would resolve on completion of deactivation. + * + * To reactivate, you can call [Client#activate]{@link Client#activate}. + * + * Experimental: pass `force: true` to immediately discard the underlying connection. + * This mode will skip both the STOMP and the Websocket shutdown sequences. + * In some cases, browsers take a long time in the Websocket shutdown + * if the underlying connection had gone stale. + * Using this mode can speed up. + * When this mode is used, the actual Websocket may linger for a while + * and the broker may not realize that the connection is no longer in use. + * + * It is possible to invoke this method initially without the `force` option + * and subsequently, say after a wait, with the `force` option. + */ + async deactivate(options = {}) { + const force = options.force || false; + const needToDispose = this.active; + let retPromise; + if (this.state === ActivationState.INACTIVE) { + this.debug(`Already INACTIVE, nothing more to do`); + return Promise.resolve(); + } + this._changeState(ActivationState.DEACTIVATING); + // Clear if a reconnection was scheduled + if (this._reconnector) { + clearTimeout(this._reconnector); + this._reconnector = undefined; + } + if (this._stompHandler && + // @ts-ignore - if there is a _stompHandler, there is the webSocket + this.webSocket.readyState !== StompSocketState.CLOSED) { + const origOnWebSocketClose = this._stompHandler.onWebSocketClose; + // we need to wait for the underlying websocket to close + retPromise = new Promise((resolve, reject) => { + // @ts-ignore - there is a _stompHandler + this._stompHandler.onWebSocketClose = evt => { + origOnWebSocketClose(evt); + resolve(); + }; + }); + } + else { + // indicate that auto reconnect loop should terminate + this._changeState(ActivationState.INACTIVE); + return Promise.resolve(); + } + if (force) { + this._stompHandler?.discardWebsocket(); + } + else if (needToDispose) { + this._disposeStompHandler(); + } + return retPromise; + } + /** + * Force disconnect if there is an active connection by directly closing the underlying WebSocket. + * This is different from a normal disconnect where a DISCONNECT sequence is carried out with the broker. + * After forcing disconnect, automatic reconnect will be attempted. + * To stop further reconnects call [Client#deactivate]{@link Client#deactivate} as well. + */ + forceDisconnect() { + if (this._stompHandler) { + this._stompHandler.forceDisconnect(); + } + } + _disposeStompHandler() { + // Dispose STOMP Handler + if (this._stompHandler) { + this._stompHandler.dispose(); + } + } + /** + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. + * + * STOMP protocol specifies and suggests some headers and also allows broker-specific headers. + * + * `body` must be String. + * You will need to covert the payload to string in case it is not string (e.g. JSON). + * + * To send a binary message body, use `binaryBody` parameter. It should be a + * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array). + * Sometimes brokers may not support binary frames out of the box. + * Please check your broker documentation. + * + * `content-length` header is automatically added to the STOMP Frame sent to the broker. + * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added. + * For binary messages, `content-length` header is always added. + * + * Caution: The broker will, most likely, report an error and disconnect + * if the message body has NULL octet(s) and `content-length` header is missing. + * + * ```javascript + * client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"}); + * + * // Only destination is mandatory parameter + * client.publish({destination: "/queue/test", body: "Hello, STOMP"}); + * + * // Skip content-length header in the frame to the broker + * client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true}); + * + * var binaryData = generateBinaryData(); // This need to be of type Uint8Array + * // setting content-type header is not mandatory, however a good practice + * client.publish({destination: '/topic/special', binaryBody: binaryData, + * headers: {'content-type': 'application/octet-stream'}}); + * ``` + */ + publish(params) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.publish(params); + } + _checkConnection() { + if (!this.connected) { + throw new TypeError('There is no underlying STOMP connection'); + } + } + /** + * STOMP brokers may carry out operation asynchronously and allow requesting for acknowledgement. + * To request an acknowledgement, a `receipt` header needs to be sent with the actual request. + * The value (say receipt-id) for this header needs to be unique for each use. + * Typically, a sequence, a UUID, a random number or a combination may be used. + * + * A complaint broker will send a RECEIPT frame when an operation has actually been completed. + * The operation needs to be matched based on the value of the receipt-id. + * + * This method allows watching for a receipt and invoking the callback + * when the corresponding receipt has been received. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + * + * Example: + * ```javascript + * // Subscribing with acknowledgement + * let receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * + * client.subscribe(TEST.destination, onMessage, {receipt: receiptId}); + * + * + * // Publishing with acknowledgement + * receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg}); + * ``` + */ + watchForReceipt(receiptId, callback) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.watchForReceipt(receiptId, callback); + } + /** + * Subscribe to a STOMP Broker location. The callback will be invoked for each + * received message with the {@link IMessage} as argument. + * + * Note: The library will generate a unique ID if there is none provided in the headers. + * To use your own ID, pass it using the `headers` argument. + * + * ```javascript + * callback = function(message) { + * // called when the client receives a STOMP message from the server + * if (message.body) { + * alert("got message with body " + message.body) + * } else { + * alert("got empty message"); + * } + * }); + * + * var subscription = client.subscribe("/queue/test", callback); + * + * // Explicit subscription id + * var mySubId = 'my-subscription-id-001'; + * var subscription = client.subscribe(destination, callback, { id: mySubId }); + * ``` + */ + subscribe(destination, callback, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + return this._stompHandler.subscribe(destination, callback, headers); + } + /** + * It is preferable to unsubscribe from a subscription by calling + * `unsubscribe()` directly on {@link StompSubscription} returned by `client.subscribe()`: + * + * ```javascript + * var subscription = client.subscribe(destination, onmessage); + * // ... + * subscription.unsubscribe(); + * ``` + * + * See: https://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame + */ + unsubscribe(id, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.unsubscribe(id, headers); + } + /** + * Start a transaction, the returned {@link ITransaction} has methods - [commit]{@link ITransaction#commit} + * and [abort]{@link ITransaction#abort}. + * + * `transactionId` is optional, if not passed the library will generate it internally. + */ + begin(transactionId) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + return this._stompHandler.begin(transactionId); + } + /** + * Commit a transaction. + * + * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.commit(); + * ``` + */ + commit(transactionId) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.commit(transactionId); + } + /** + * Abort a transaction. + * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.abort(); + * ``` + */ + abort(transactionId) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.abort(transactionId); + } + /** + * ACK a message. It is preferable to acknowledge a message by calling [ack]{@link IMessage#ack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // acknowledge it + * message.ack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + ack(messageId, subscriptionId, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.ack(messageId, subscriptionId, headers); + } + /** + * NACK a message. It is preferable to acknowledge a message by calling [nack]{@link IMessage#nack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // an error occurs, nack it + * message.nack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + nack(messageId, subscriptionId, headers = {}) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.nack(messageId, subscriptionId, headers); + } +} +//# sourceMappingURL=client.js.map Index: node_modules/@stomp/stompjs/esm6/client.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/client.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/client.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EACL,eAAe,EAOf,gBAAgB,GAEjB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAUzC;;;;GAIG;AACH,MAAM,OAAO,MAAM;IAyTjB;;OAEG;IACH,YAAY,OAAoB,EAAE;QA/SlC;;;;;;;;WAQG;QACI,kBAAa,GAAG,QAAQ,CAAC,OAAO,CAAC;QAyBxC;;;WAGG;QACI,sBAAiB,GAAW,CAAC,CAAC;QAKrC;;WAEG;QACI,mBAAc,GAAW,IAAI,CAAC;QAErC;;WAEG;QACI,sBAAiB,GAAW,KAAK,CAAC;QAEzC;;WAEG;QACI,sBAAiB,GAAW,KAAK,CAAC;QAEzC;;;;;;;;;;;;WAYG;QACI,qBAAgB,GAAY,KAAK,CAAC;QAEzC;;;WAGG;QACI,0BAAqB,GAAW,CAAC,GAAG,IAAI,CAAC;QAEhD;;;;;;;WAOG;QACI,wBAAmB,GAAY,KAAK,CAAC;QAE5C;;;;;;;;;WASG;QACI,gCAA2B,GAAY,KAAK,CAAC;QAyJpD;;;;;;;WAOG;QACI,kCAA6B,GAAY,KAAK,CAAC;QA8BtD;;;;;WAKG;QACI,UAAK,GAAoB,eAAe,CAAC,QAAQ,CAAC;QAQvD,kBAAkB;QAClB,MAAM,IAAI,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAClB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAC1B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAC/B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QACzB,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;QAC7B,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;QACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAE1B,8EAA8E;QAC9E,IAAI,CAAC,cAAc,GAAG,EAAE,CAAC;QACzB,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAC;QAE7B,sBAAsB;QACtB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;IACvB,CAAC;IAhOD;;OAEG;IACH,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC;IACxC,CAAC;IASD;;OAEG;IACH,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IAED,IAAI,iBAAiB,CAAC,KAAmB;QACvC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAChC,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,iBAAiB,GAAG,IAAI,CAAC,kBAAkB,CAAC;SAChE;IACH,CAAC;IA+BD;;OAEG;IACH,IAAI,SAAS;QACX,OAAO,CAAC,CAAC,IAAI,CAAC,aAAa,IAAI,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;IAC9D,CAAC;IAmGD;;OAEG;IACH,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,CAAC,CAAC,SAAS,CAAC;IAC9E,CAAC;IAID;;OAEG;IACH,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,KAAK,KAAK,eAAe,CAAC,MAAM,CAAC;IAC/C,CAAC;IASO,YAAY,CAAC,KAAsB;QACzC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAuCD;;OAEG;IACI,SAAS,CAAC,IAAiB;QAChC,qCAAqC;QACpC,MAAc,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACI,QAAQ;QACb,MAAM,SAAS,GAAG,GAAG,EAAE;YACrB,IAAI,IAAI,CAAC,MAAM,EAAE;gBACf,IAAI,CAAC,KAAK,CAAC,8CAA8C,CAAC,CAAC;gBAC3D,OAAO;aACR;YAED,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;YAE1C,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC,CAAC;QAEF,oEAAoE;QACpE,IAAI,IAAI,CAAC,KAAK,KAAK,eAAe,CAAC,YAAY,EAAE;YAC/C,IAAI,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;YACnE,IAAI,CAAC,UAAU,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE;gBAC1B,SAAS,EAAE,CAAC;YACd,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,SAAS,EAAE,CAAC;SACb;IACH,CAAC;IAEO,KAAK,CAAC,QAAQ;QACpB,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;QAE3B,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,KAAK,CAAC,+DAA+D,CAAC,CAAC;YAC5E,OAAO;SACR;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,IAAI,CAAC,KAAK,CACR,8DAA8D,CAC/D,CAAC;YACF,OAAO;SACR;QAED,2BAA2B;QAC3B,IAAI,IAAI,CAAC,iBAAiB,GAAG,CAAC,EAAE;YAC9B,cAAc;YACd,IAAI,IAAI,CAAC,kBAAkB,EAAE;gBAC3B,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;aACvC;YACD,IAAI,CAAC,kBAAkB,GAAG,UAAU,CAAC,GAAG,EAAE;gBACxC,IAAI,IAAI,CAAC,SAAS,EAAE;oBAClB,OAAO;iBACR;gBACD,0DAA0D;gBAC1D,mCAAmC;gBACnC,IAAI,CAAC,KAAK,CACR,iCAAiC,IAAI,CAAC,iBAAiB,oBAAoB,CAC5E,CAAC;gBACF,IAAI,CAAC,eAAe,EAAE,CAAC;YACzB,CAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;SAC5B;QAED,IAAI,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC;QAEpC,iDAAiD;QACjD,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;QAE1C,IAAI,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,IAAI,EAAE,SAAS,EAAE;YACrD,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,iBAAiB,EAAE,IAAI,CAAC,kBAAkB;YAC1C,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;YACvC,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;YACjD,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;YAC7C,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;YAC7C,2BAA2B,EAAE,IAAI,CAAC,2BAA2B;YAC7D,6BAA6B,EAAE,IAAI,CAAC,6BAA6B;YAEjE,SAAS,EAAE,KAAK,CAAC,EAAE;gBACjB,sDAAsD;gBACtD,IAAI,IAAI,CAAC,kBAAkB,EAAE;oBAC3B,YAAY,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;oBACtC,IAAI,CAAC,kBAAkB,GAAG,SAAS,CAAC;iBACrC;gBAED,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;oBAChB,IAAI,CAAC,KAAK,CACR,sEAAsE,CACvE,CAAC;oBACF,IAAI,CAAC,oBAAoB,EAAE,CAAC;oBAC5B,OAAO;iBACR;gBACD,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;YACD,YAAY,EAAE,KAAK,CAAC,EAAE;gBACpB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAC3B,CAAC;YACD,YAAY,EAAE,KAAK,CAAC,EAAE;gBACpB,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC;YAC3B,CAAC;YACD,gBAAgB,EAAE,GAAG,CAAC,EAAE;gBACtB,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC,CAAC,mDAAmD;gBAEnF,IAAI,IAAI,CAAC,KAAK,KAAK,eAAe,CAAC,YAAY,EAAE;oBAC/C,6BAA6B;oBAC7B,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;iBAC7C;gBAED,qFAAqF;gBACrF,uCAAuC;gBACvC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;gBAE3B,IAAI,IAAI,CAAC,MAAM,EAAE;oBACf,IAAI,CAAC,mBAAmB,EAAE,CAAC;iBAC5B;YACH,CAAC;YACD,gBAAgB,EAAE,GAAG,CAAC,EAAE;gBACtB,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;YAC7B,CAAC;YACD,kBAAkB,EAAE,OAAO,CAAC,EAAE;gBAC5B,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC,CAAC;YACnC,CAAC;YACD,kBAAkB,EAAE,KAAK,CAAC,EAAE;gBAC1B,IAAI,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC;YACjC,CAAC;YACD,gBAAgB,EAAE,KAAK,CAAC,EAAE;gBACxB,IAAI,CAAC,gBAAgB,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IAC7B,CAAC;IAEO,gBAAgB;QACtB,IAAI,SAAuB,CAAC;QAE5B,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACzB,SAAS,GAAG,IAAI,CAAC,gBAAgB,EAAE,CAAC;SACrC;aAAM,IAAI,IAAI,CAAC,SAAS,EAAE;YACzB,SAAS,GAAG,IAAI,SAAS,CACvB,IAAI,CAAC,SAAS,EACd,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CACtC,CAAC;SACH;aAAM;YACL,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;SAC1E;QACD,SAAS,CAAC,UAAU,GAAG,aAAa,CAAC;QACrC,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,mBAAmB;QACzB,IAAI,IAAI,CAAC,cAAc,GAAG,CAAC,EAAE;YAC3B,IAAI,CAAC,KAAK,CAAC,qCAAqC,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC;YAEzE,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,GAAG,EAAE;gBAClC,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,CAAC,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;SACzB;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,KAAK,CAAC,UAAU,CAAC,UAA+B,EAAE;QACvD,MAAM,KAAK,GAAY,OAAO,CAAC,KAAK,IAAI,KAAK,CAAC;QAC9C,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC;QAClC,IAAI,UAAyB,CAAC;QAE9B,IAAI,IAAI,CAAC,KAAK,KAAK,eAAe,CAAC,QAAQ,EAAE;YAC3C,IAAI,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACnD,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;SAC1B;QAED,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC;QAEhD,wCAAwC;QACxC,IAAI,IAAI,CAAC,YAAY,EAAE;YACrB,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAChC,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;SAC/B;QAED,IACE,IAAI,CAAC,aAAa;YAClB,mEAAmE;YACnE,IAAI,CAAC,SAAS,CAAC,UAAU,KAAK,gBAAgB,CAAC,MAAM,EACrD;YACA,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC;YACjE,wDAAwD;YACxD,UAAU,GAAG,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;gBACjD,wCAAwC;gBACxC,IAAI,CAAC,aAAa,CAAC,gBAAgB,GAAG,GAAG,CAAC,EAAE;oBAC1C,oBAAoB,CAAC,GAAG,CAAC,CAAC;oBAC1B,OAAO,EAAE,CAAC;gBACZ,CAAC,CAAC;YACJ,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,qDAAqD;YACrD,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,QAAQ,CAAC,CAAC;YAC5C,OAAO,OAAO,CAAC,OAAO,EAAE,CAAC;SAC1B;QAED,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,aAAa,EAAE,gBAAgB,EAAE,CAAC;SACxC;aAAM,IAAI,aAAa,EAAE;YACxB,IAAI,CAAC,oBAAoB,EAAE,CAAC;SAC7B;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;;;;OAKG;IACI,eAAe;QACpB,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,eAAe,EAAE,CAAC;SACtC;IACH,CAAC;IAEO,oBAAoB;QAC1B,wBAAwB;QACxB,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;SAC9B;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACI,OAAO,CAAC,MAAsB;QACnC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;IAEO,gBAAgB;QACtB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,MAAM,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAC;SAChE;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACI,eAAe,CAAC,SAAiB,EAAE,QAA2B;QACnE,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC1D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACI,SAAS,CACd,WAAmB,EACnB,QAA6B,EAC7B,UAAwB,EAAE;QAE1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,WAAW,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IACtE,CAAC;IAED;;;;;;;;;;;OAWG;IACI,WAAW,CAAC,EAAU,EAAE,UAAwB,EAAE;QACvD,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;IAC9C,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,aAAsB;QACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,OAAO,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IACjD,CAAC;IAED;;;;;;;;;;;OAWG;IACI,MAAM,CAAC,aAAqB;QACjC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;OAUG;IACI,KAAK,CAAC,aAAqB;QAChC,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,GAAG,CACR,SAAiB,EACjB,cAAsB,EACtB,UAAwB,EAAE;QAE1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IAC7D,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,IAAI,CACT,SAAiB,EACjB,cAAsB,EACtB,UAAwB,EAAE;QAE1B,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,qFAAqF;QACrF,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,CAAC,CAAC;IAC9D,CAAC;CACF"} Index: node_modules/@stomp/stompjs/esm6/compatibility/compat-client.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/compat-client.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/compat-client.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,155 @@ +import { Client } from '../client.js'; +import { StompHeaders } from '../stomp-headers.js'; +import { frameCallbackType, messageCallbackType } from '../types.js'; +/** + * Available for backward compatibility, please shift to using {@link Client}. + * + * **Deprecated** + * + * Part of `@stomp/stompjs`. + * + * To upgrade, please follow the [Upgrade Guide](https://stomp-js.github.io/guide/stompjs/upgrading-stompjs.html) + */ +export declare class CompatClient extends Client { + /** + * It is no op now. No longer needed. Large packets work out of the box. + */ + maxWebSocketFrameSize: number; + /** + * Available for backward compatibility, please shift to using {@link Client} + * and [Client#webSocketFactory]{@link Client#webSocketFactory}. + * + * **Deprecated** + * + * @internal + */ + constructor(webSocketFactory: () => any); + private _parseConnect; + /** + * Available for backward compatibility, please shift to using [Client#activate]{@link Client#activate}. + * + * **Deprecated** + * + * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the + * version with headers to pass your broker specific options. + * + * overloads: + * - connect(headers, connectCallback) + * - connect(headers, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback) + * - connect(login, passcode, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host) + * + * params: + * - headers, see [Client#connectHeaders]{@link Client#connectHeaders} + * - connectCallback, see [Client#onConnect]{@link Client#onConnect} + * - errorCallback, see [Client#onStompError]{@link Client#onStompError} + * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose} + * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + connect(...args: any[]): void; + /** + * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}. + * + * **Deprecated** + * + * See: + * [Client#onDisconnect]{@link Client#onDisconnect}, and + * [Client#disconnectHeaders]{@link Client#disconnectHeaders} + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + disconnect(disconnectCallback?: any, headers?: StompHeaders): void; + /** + * Available for backward compatibility, use [Client#publish]{@link Client#publish}. + * + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. The headers will, typically, be available to the subscriber. + * However, there may be special purpose headers corresponding to your STOMP broker. + * + * **Deprecated**, use [Client#publish]{@link Client#publish} + * + * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON) + * + * ```javascript + * client.send("/queue/test", {priority: 9}, "Hello, STOMP"); + * + * // If you want to send a message with a body, you must also pass the headers argument. + * client.send("/queue/test", {}, "Hello, STOMP"); + * ``` + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + send(destination: string, headers?: { + [key: string]: any; + }, body?: string): void; + /** + * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}. + * + * **Deprecated** + */ + set reconnect_delay(value: number); + /** + * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}. + * + * **Deprecated** + */ + get ws(): any; + /** + * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}. + * + * **Deprecated** + */ + get version(): string | undefined; + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + get onreceive(): messageCallbackType; + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + set onreceive(value: messageCallbackType); + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. + * + * **Deprecated** + */ + get onreceipt(): frameCallbackType; + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * + * **Deprecated** + */ + set onreceipt(value: frameCallbackType); + private _heartbeatInfo; + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + get heartbeat(): { + incoming: number; + outgoing: number; + }; + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + set heartbeat(value: { + incoming: number; + outgoing: number; + }); +} Index: node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,241 @@ +import { Client } from '../client.js'; +import { HeartbeatInfo } from './heartbeat-info.js'; +/** + * Available for backward compatibility, please shift to using {@link Client}. + * + * **Deprecated** + * + * Part of `@stomp/stompjs`. + * + * To upgrade, please follow the [Upgrade Guide](https://stomp-js.github.io/guide/stompjs/upgrading-stompjs.html) + */ +export class CompatClient extends Client { + /** + * Available for backward compatibility, please shift to using {@link Client} + * and [Client#webSocketFactory]{@link Client#webSocketFactory}. + * + * **Deprecated** + * + * @internal + */ + constructor(webSocketFactory) { + super(); + /** + * It is no op now. No longer needed. Large packets work out of the box. + */ + this.maxWebSocketFrameSize = 16 * 1024; + this._heartbeatInfo = new HeartbeatInfo(this); + this.reconnect_delay = 0; + this.webSocketFactory = webSocketFactory; + // Default from previous version + this.debug = (...message) => { + console.log(...message); + }; + } + _parseConnect(...args) { + let closeEventCallback; + let connectCallback; + let errorCallback; + let headers = {}; + if (args.length < 2) { + throw new Error('Connect requires at least 2 arguments'); + } + if (typeof args[1] === 'function') { + [headers, connectCallback, errorCallback, closeEventCallback] = args; + } + else { + switch (args.length) { + case 6: + [ + headers.login, + headers.passcode, + connectCallback, + errorCallback, + closeEventCallback, + headers.host, + ] = args; + break; + default: + [ + headers.login, + headers.passcode, + connectCallback, + errorCallback, + closeEventCallback, + ] = args; + } + } + return [headers, connectCallback, errorCallback, closeEventCallback]; + } + /** + * Available for backward compatibility, please shift to using [Client#activate]{@link Client#activate}. + * + * **Deprecated** + * + * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the + * version with headers to pass your broker specific options. + * + * overloads: + * - connect(headers, connectCallback) + * - connect(headers, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback) + * - connect(login, passcode, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host) + * + * params: + * - headers, see [Client#connectHeaders]{@link Client#connectHeaders} + * - connectCallback, see [Client#onConnect]{@link Client#onConnect} + * - errorCallback, see [Client#onStompError]{@link Client#onStompError} + * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose} + * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + connect(...args) { + const out = this._parseConnect(...args); + if (out[0]) { + this.connectHeaders = out[0]; + } + if (out[1]) { + this.onConnect = out[1]; + } + if (out[2]) { + this.onStompError = out[2]; + } + if (out[3]) { + this.onWebSocketClose = out[3]; + } + super.activate(); + } + /** + * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}. + * + * **Deprecated** + * + * See: + * [Client#onDisconnect]{@link Client#onDisconnect}, and + * [Client#disconnectHeaders]{@link Client#disconnectHeaders} + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + disconnect(disconnectCallback, headers = {}) { + if (disconnectCallback) { + this.onDisconnect = disconnectCallback; + } + this.disconnectHeaders = headers; + super.deactivate(); + } + /** + * Available for backward compatibility, use [Client#publish]{@link Client#publish}. + * + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. The headers will, typically, be available to the subscriber. + * However, there may be special purpose headers corresponding to your STOMP broker. + * + * **Deprecated**, use [Client#publish]{@link Client#publish} + * + * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON) + * + * ```javascript + * client.send("/queue/test", {priority: 9}, "Hello, STOMP"); + * + * // If you want to send a message with a body, you must also pass the headers argument. + * client.send("/queue/test", {}, "Hello, STOMP"); + * ``` + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + send(destination, headers = {}, body = '') { + headers = Object.assign({}, headers); + const skipContentLengthHeader = headers['content-length'] === false; + if (skipContentLengthHeader) { + delete headers['content-length']; + } + this.publish({ + destination, + headers: headers, + body, + skipContentLengthHeader, + }); + } + /** + * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}. + * + * **Deprecated** + */ + set reconnect_delay(value) { + this.reconnectDelay = value; + } + /** + * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}. + * + * **Deprecated** + */ + get ws() { + return this.webSocket; + } + /** + * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}. + * + * **Deprecated** + */ + get version() { + return this.connectedVersion; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + get onreceive() { + return this.onUnhandledMessage; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + set onreceive(value) { + this.onUnhandledMessage = value; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. + * + * **Deprecated** + */ + get onreceipt() { + return this.onUnhandledReceipt; + } + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * + * **Deprecated** + */ + set onreceipt(value) { + this.onUnhandledReceipt = value; + } + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + get heartbeat() { + return this._heartbeatInfo; + } + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + set heartbeat(value) { + this.heartbeatIncoming = value.incoming; + this.heartbeatOutgoing = value.outgoing; + } +} +//# sourceMappingURL=compat-client.js.map Index: node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/compat-client.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"compat-client.js","sourceRoot":"","sources":["../../src/compatibility/compat-client.ts"],"names":[],"mappings":"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"} Index: node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,14 @@ +import { CompatClient } from './compat-client.js'; +/** + * Part of `@stomp/stompjs`. + * + * @internal + */ +export declare class HeartbeatInfo { + private client; + constructor(client: CompatClient); + get outgoing(): number; + set outgoing(value: number); + get incoming(): number; + set incoming(value: number); +} Index: node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,23 @@ +/** + * Part of `@stomp/stompjs`. + * + * @internal + */ +export class HeartbeatInfo { + constructor(client) { + this.client = client; + } + get outgoing() { + return this.client.heartbeatOutgoing; + } + set outgoing(value) { + this.client.heartbeatOutgoing = value; + } + get incoming() { + return this.client.heartbeatIncoming; + } + set incoming(value) { + this.client.heartbeatIncoming = value; + } +} +//# sourceMappingURL=heartbeat-info.js.map Index: node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/heartbeat-info.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"heartbeat-info.js","sourceRoot":"","sources":["../../src/compatibility/heartbeat-info.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,OAAO,aAAa;IACxB,YAAoB,MAAoB;QAApB,WAAM,GAAN,MAAM,CAAc;IAAG,CAAC;IAE5C,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;IACvC,CAAC;IAED,IAAI,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACxC,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,MAAM,CAAC,iBAAiB,CAAC;IACvC,CAAC;IAED,IAAI,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,MAAM,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACxC,CAAC;CACF"} Index: node_modules/@stomp/stompjs/esm6/compatibility/stomp.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/stomp.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/stomp.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,67 @@ +import { CompatClient } from './compat-client.js'; +/** + * STOMP Class, acts like a factory to create {@link Client}. + * + * Part of `@stomp/stompjs`. + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client}. + */ +export declare class Stomp { + /** + * In case you need to use a non standard class for WebSocket. + * + * For example when using within NodeJS environment: + * + * ```javascript + * StompJs = require('../../esm5/'); + * Stomp = StompJs.Stomp; + * Stomp.WebSocketClass = require('websocket').w3cwebsocket; + * ``` + * + * **Deprecated** + * + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + static WebSocketClass: any; + /** + * This method creates a WebSocket client that is connected to + * the STOMP server located at the url. + * + * ```javascript + * var url = "ws://localhost:61614/stomp"; + * var client = Stomp.client(url); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#brokerURL]{@link Client#brokerURL}. + */ + static client(url: string, protocols?: string[]): CompatClient; + /** + * This method is an alternative to [Stomp#client]{@link Stomp#client} to let the user + * specify the WebSocket to use (either a standard HTML5 WebSocket or + * a similar object). + * + * In order to support reconnection, the function Client._connect should be callable more than once. + * While reconnecting + * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function + * alternatively allows passing a function that should return a new instance of the underlying socket. + * + * ```javascript + * var client = Stomp.over(function(){ + * return new WebSocket('ws://localhost:15674/ws') + * }); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + static over(ws: any): CompatClient; +} Index: node_modules/@stomp/stompjs/esm6/compatibility/stomp.js =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/stomp.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/stomp.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,102 @@ +import { Versions } from '../versions.js'; +import { CompatClient } from './compat-client.js'; +/** + * STOMP Class, acts like a factory to create {@link Client}. + * + * Part of `@stomp/stompjs`. + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client}. + */ +export class Stomp { + /** + * This method creates a WebSocket client that is connected to + * the STOMP server located at the url. + * + * ```javascript + * var url = "ws://localhost:61614/stomp"; + * var client = Stomp.client(url); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#brokerURL]{@link Client#brokerURL}. + */ + static client(url, protocols) { + // This is a hack to allow another implementation than the standard + // HTML5 WebSocket class. + // + // It is possible to use another class by calling + // + // Stomp.WebSocketClass = MozWebSocket + // + // *prior* to call `Stomp.client()`. + // + // This hack is deprecated and `Stomp.over()` method should be used + // instead. + // See remarks on the function Stomp.over + if (protocols == null) { + protocols = Versions.default.protocolVersions(); + } + const wsFn = () => { + const klass = Stomp.WebSocketClass || WebSocket; + return new klass(url, protocols); + }; + return new CompatClient(wsFn); + } + /** + * This method is an alternative to [Stomp#client]{@link Stomp#client} to let the user + * specify the WebSocket to use (either a standard HTML5 WebSocket or + * a similar object). + * + * In order to support reconnection, the function Client._connect should be callable more than once. + * While reconnecting + * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function + * alternatively allows passing a function that should return a new instance of the underlying socket. + * + * ```javascript + * var client = Stomp.over(function(){ + * return new WebSocket('ws://localhost:15674/ws') + * }); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + static over(ws) { + let wsFn; + if (typeof ws === 'function') { + wsFn = ws; + } + else { + console.warn('Stomp.over did not receive a factory, auto reconnect will not work. ' + + 'Please see https://stomp-js.github.io/api-docs/latest/classes/Stomp.html#over'); + wsFn = () => ws; + } + return new CompatClient(wsFn); + } +} +/** + * In case you need to use a non standard class for WebSocket. + * + * For example when using within NodeJS environment: + * + * ```javascript + * StompJs = require('../../esm5/'); + * Stomp = StompJs.Stomp; + * Stomp.WebSocketClass = require('websocket').w3cwebsocket; + * ``` + * + * **Deprecated** + * + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ +// tslint:disable-next-line:variable-name +Stomp.WebSocketClass = null; +//# sourceMappingURL=stomp.js.map Index: node_modules/@stomp/stompjs/esm6/compatibility/stomp.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/compatibility/stomp.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/compatibility/stomp.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"stomp.js","sourceRoot":"","sources":["../../src/compatibility/stomp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAWlD;;;;;;;;GAQG;AACH,MAAM,OAAO,KAAK;IAqBhB;;;;;;;;;;;;;OAaG;IACI,MAAM,CAAC,MAAM,CAAC,GAAW,EAAE,SAAoB;QACpD,mEAAmE;QACnE,yBAAyB;QACzB,EAAE;QACF,iDAAiD;QACjD,EAAE;QACF,0CAA0C;QAC1C,EAAE;QACF,oCAAoC;QACpC,EAAE;QACF,mEAAmE;QACnE,WAAW;QAEX,yCAAyC;QACzC,IAAI,SAAS,IAAI,IAAI,EAAE;YACrB,SAAS,GAAG,QAAQ,CAAC,OAAO,CAAC,gBAAgB,EAAE,CAAC;SACjD;QACD,MAAM,IAAI,GAAG,GAAG,EAAE;YAChB,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,IAAI,SAAS,CAAC;YAChD,OAAO,IAAI,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;QACnC,CAAC,CAAC;QAEF,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,MAAM,CAAC,IAAI,CAAC,EAAO;QACxB,IAAI,IAAe,CAAC;QAEpB,IAAI,OAAO,EAAE,KAAK,UAAU,EAAE;YAC5B,IAAI,GAAG,EAAE,CAAC;SACX;aAAM;YACL,OAAO,CAAC,IAAI,CACV,sEAAsE;gBACpE,+EAA+E,CAClF,CAAC;YACF,IAAI,GAAG,GAAG,EAAE,CAAC,EAAE,CAAC;SACjB;QAED,OAAO,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;;AA9FD;;;;;;;;;;;;;;;;GAgBG;AACH,yCAAyC;AAC3B,oBAAc,GAAQ,IAAI,CAAC"} Index: node_modules/@stomp/stompjs/esm6/frame-impl.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/frame-impl.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/frame-impl.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,95 @@ +import { IFrame } from './i-frame.js'; +import { StompHeaders } from './stomp-headers.js'; +import { IRawFrameType } from './types.js'; +/** + * Frame class represents a STOMP frame. + * + * @internal + */ +export declare class FrameImpl implements IFrame { + /** + * STOMP Command + */ + command: string; + /** + * Headers, key value pairs. + */ + headers: StompHeaders; + /** + * Is this frame binary (based on whether body/binaryBody was passed when creating this frame). + */ + isBinaryBody: boolean; + /** + * body of the frame + */ + get body(): string; + private _body; + /** + * body as Uint8Array + */ + get binaryBody(): Uint8Array; + private _binaryBody; + private escapeHeaderValues; + private skipContentLengthHeader; + /** + * Frame constructor. `command`, `headers` and `body` are available as properties. + * + * @internal + */ + constructor(params: { + command: string; + headers?: StompHeaders; + body?: string; + binaryBody?: Uint8Array; + escapeHeaderValues?: boolean; + skipContentLengthHeader?: boolean; + }); + /** + * deserialize a STOMP Frame from raw data. + * + * @internal + */ + static fromRawFrame(rawFrame: IRawFrameType, escapeHeaderValues: boolean): FrameImpl; + /** + * @internal + */ + toString(): string; + /** + * serialize this Frame in a format suitable to be passed to WebSocket. + * If the body is string the output will be string. + * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer. + * + * @internal + */ + serialize(): string | ArrayBuffer; + private serializeCmdAndHeaders; + private isBodyEmpty; + private bodyLength; + /** + * Compute the size of a UTF-8 string by counting its number of bytes + * (and not the number of characters composing the string) + */ + private static sizeOfUTF8; + private static toUnit8Array; + /** + * Serialize a STOMP frame as per STOMP standards, suitable to be sent to the STOMP broker. + * + * @internal + */ + static marshall(params: { + command: string; + headers?: StompHeaders; + body?: string; + binaryBody?: Uint8Array; + escapeHeaderValues?: boolean; + skipContentLengthHeader?: boolean; + }): string | ArrayBuffer; + /** + * Escape header values + */ + private static hdrValueEscape; + /** + * UnEscape header values + */ + private static hdrValueUnEscape; +} Index: node_modules/@stomp/stompjs/esm6/frame-impl.js =================================================================== --- node_modules/@stomp/stompjs/esm6/frame-impl.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/frame-impl.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,171 @@ +import { BYTE } from './byte.js'; +/** + * Frame class represents a STOMP frame. + * + * @internal + */ +export class FrameImpl { + /** + * Frame constructor. `command`, `headers` and `body` are available as properties. + * + * @internal + */ + constructor(params) { + const { command, headers, body, binaryBody, escapeHeaderValues, skipContentLengthHeader, } = params; + this.command = command; + this.headers = Object.assign({}, headers || {}); + if (binaryBody) { + this._binaryBody = binaryBody; + this.isBinaryBody = true; + } + else { + this._body = body || ''; + this.isBinaryBody = false; + } + this.escapeHeaderValues = escapeHeaderValues || false; + this.skipContentLengthHeader = skipContentLengthHeader || false; + } + /** + * body of the frame + */ + get body() { + if (!this._body && this.isBinaryBody) { + this._body = new TextDecoder().decode(this._binaryBody); + } + return this._body || ''; + } + /** + * body as Uint8Array + */ + get binaryBody() { + if (!this._binaryBody && !this.isBinaryBody) { + this._binaryBody = new TextEncoder().encode(this._body); + } + // At this stage it will definitely have a valid value + return this._binaryBody; + } + /** + * deserialize a STOMP Frame from raw data. + * + * @internal + */ + static fromRawFrame(rawFrame, escapeHeaderValues) { + const headers = {}; + const trim = (str) => str.replace(/^\s+|\s+$/g, ''); + // In case of repeated headers, as per standards, first value need to be used + for (const header of rawFrame.headers.reverse()) { + const idx = header.indexOf(':'); + const key = trim(header[0]); + let value = trim(header[1]); + if (escapeHeaderValues && + rawFrame.command !== 'CONNECT' && + rawFrame.command !== 'CONNECTED') { + value = FrameImpl.hdrValueUnEscape(value); + } + headers[key] = value; + } + return new FrameImpl({ + command: rawFrame.command, + headers, + binaryBody: rawFrame.binaryBody, + escapeHeaderValues, + }); + } + /** + * @internal + */ + toString() { + return this.serializeCmdAndHeaders(); + } + /** + * serialize this Frame in a format suitable to be passed to WebSocket. + * If the body is string the output will be string. + * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer. + * + * @internal + */ + serialize() { + const cmdAndHeaders = this.serializeCmdAndHeaders(); + if (this.isBinaryBody) { + return FrameImpl.toUnit8Array(cmdAndHeaders, this._binaryBody).buffer; + } + else { + return cmdAndHeaders + this._body + BYTE.NULL; + } + } + serializeCmdAndHeaders() { + const lines = [this.command]; + if (this.skipContentLengthHeader) { + delete this.headers['content-length']; + } + for (const name of Object.keys(this.headers || {})) { + const value = this.headers[name]; + if (this.escapeHeaderValues && + this.command !== 'CONNECT' && + this.command !== 'CONNECTED') { + lines.push(`${name}:${FrameImpl.hdrValueEscape(`${value}`)}`); + } + else { + lines.push(`${name}:${value}`); + } + } + if (this.isBinaryBody || + (!this.isBodyEmpty() && !this.skipContentLengthHeader)) { + lines.push(`content-length:${this.bodyLength()}`); + } + return lines.join(BYTE.LF) + BYTE.LF + BYTE.LF; + } + isBodyEmpty() { + return this.bodyLength() === 0; + } + bodyLength() { + const binaryBody = this.binaryBody; + return binaryBody ? binaryBody.length : 0; + } + /** + * Compute the size of a UTF-8 string by counting its number of bytes + * (and not the number of characters composing the string) + */ + static sizeOfUTF8(s) { + return s ? new TextEncoder().encode(s).length : 0; + } + static toUnit8Array(cmdAndHeaders, binaryBody) { + const uint8CmdAndHeaders = new TextEncoder().encode(cmdAndHeaders); + const nullTerminator = new Uint8Array([0]); + const uint8Frame = new Uint8Array(uint8CmdAndHeaders.length + binaryBody.length + nullTerminator.length); + uint8Frame.set(uint8CmdAndHeaders); + uint8Frame.set(binaryBody, uint8CmdAndHeaders.length); + uint8Frame.set(nullTerminator, uint8CmdAndHeaders.length + binaryBody.length); + return uint8Frame; + } + /** + * Serialize a STOMP frame as per STOMP standards, suitable to be sent to the STOMP broker. + * + * @internal + */ + static marshall(params) { + const frame = new FrameImpl(params); + return frame.serialize(); + } + /** + * Escape header values + */ + static hdrValueEscape(str) { + return str + .replace(/\\/g, '\\\\') + .replace(/\r/g, '\\r') + .replace(/\n/g, '\\n') + .replace(/:/g, '\\c'); + } + /** + * UnEscape header values + */ + static hdrValueUnEscape(str) { + return str + .replace(/\\r/g, '\r') + .replace(/\\n/g, '\n') + .replace(/\\c/g, ':') + .replace(/\\\\/g, '\\'); + } +} +//# sourceMappingURL=frame-impl.js.map Index: node_modules/@stomp/stompjs/esm6/frame-impl.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/frame-impl.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/frame-impl.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"frame-impl.js","sourceRoot":"","sources":["../src/frame-impl.ts"],"names":[],"mappings":"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"} Index: node_modules/@stomp/stompjs/esm6/i-frame.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/i-frame.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-frame.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,35 @@ +import { StompHeaders } from './stomp-headers.js'; +/** + * It represents a STOMP frame. Many of the callbacks pass an IFrame received from + * the STOMP broker. For advanced usage you might need to access [headers]{@link IFrame#headers}. + * + * Part of `@stomp/stompjs`. + * + * {@link IMessage} is an extended IFrame. + */ +export interface IFrame { + /** + * STOMP Command + */ + command: string; + /** + * Headers, key value pairs. + */ + headers: StompHeaders; + /** + * Is this frame binary (based on whether body/binaryBody was passed when creating this frame). + */ + isBinaryBody: boolean; + /** + * body of the frame as string + */ + readonly body: string; + /** + * body as Uint8Array + */ + readonly binaryBody: Uint8Array; +} +/** + * Alias for {@link IFrame} + */ +export declare type Frame = IFrame; Index: node_modules/@stomp/stompjs/esm6/i-frame.js =================================================================== --- node_modules/@stomp/stompjs/esm6/i-frame.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-frame.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,2 @@ +export {}; +//# sourceMappingURL=i-frame.js.map Index: node_modules/@stomp/stompjs/esm6/i-frame.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/i-frame.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-frame.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"i-frame.js","sourceRoot":"","sources":["../src/i-frame.ts"],"names":[],"mappings":""} Index: node_modules/@stomp/stompjs/esm6/i-message.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/i-message.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-message.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,32 @@ +import { IFrame } from './i-frame.js'; +import { StompHeaders } from './stomp-headers.js'; +/** + * Instance of Message will be passed to [subscription callback]{@link Client#subscribe} + * and [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * Since it is an extended {@link IFrame}, you can access [headers]{@link IFrame#headers} + * and [body]{@link IFrame#body} as properties. + * + * Part of `@stomp/stompjs`. + * + * See [Client#subscribe]{@link Client#subscribe} for example. + */ +export interface IMessage extends IFrame { + /** + * When subscribing with manual acknowledgement, call this method on the message to ACK the message. + * + * See [Client#ack]{@link Client#ack} for an example. + */ + ack: (headers?: StompHeaders) => void; + /** + * When subscribing with manual acknowledgement, call this method on the message to NACK the message. + * + * See [Client#nack]{@link Client#nack} for an example. + */ + nack: (headers?: StompHeaders) => void; +} +/** + * Aliased to {@link IMessage}. + * + * Part of `@stomp/stompjs`. + */ +export declare type Message = IMessage; Index: node_modules/@stomp/stompjs/esm6/i-message.js =================================================================== --- node_modules/@stomp/stompjs/esm6/i-message.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-message.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,2 @@ +export {}; +//# sourceMappingURL=i-message.js.map Index: node_modules/@stomp/stompjs/esm6/i-message.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/i-message.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-message.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"i-message.js","sourceRoot":"","sources":["../src/i-message.ts"],"names":[],"mappings":""} Index: node_modules/@stomp/stompjs/esm6/i-transaction.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/i-transaction.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-transaction.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,21 @@ +/** + * A Transaction is created by calling [Client#begin]{@link Client#begin} + * + * Part of `@stomp/stompjs`. + * + * TODO: Example and caveat + */ +export interface ITransaction { + /** + * You will need to access this to send, ack, or nack within this transaction. + */ + id: string; + /** + * Commit this transaction. See [Client#commit]{@link Client#commit} for an example. + */ + commit: () => void; + /** + * Abort this transaction. See [Client#abort]{@link Client#abort} for an example. + */ + abort: () => void; +} Index: node_modules/@stomp/stompjs/esm6/i-transaction.js =================================================================== --- node_modules/@stomp/stompjs/esm6/i-transaction.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-transaction.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,2 @@ +export {}; +//# sourceMappingURL=i-transaction.js.map Index: node_modules/@stomp/stompjs/esm6/i-transaction.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/i-transaction.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/i-transaction.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"i-transaction.js","sourceRoot":"","sources":["../src/i-transaction.ts"],"names":[],"mappings":""} Index: node_modules/@stomp/stompjs/esm6/index.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/index.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/index.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,13 @@ +export * from './client.js'; +export * from './frame-impl.js'; +export * from './i-frame.js'; +export * from './i-message.js'; +export * from './parser.js'; +export * from './stomp-config.js'; +export * from './stomp-headers.js'; +export * from './stomp-subscription.js'; +export * from './i-transaction.js'; +export * from './types.js'; +export * from './versions.js'; +export * from './compatibility/compat-client.js'; +export * from './compatibility/stomp.js'; Index: node_modules/@stomp/stompjs/esm6/index.js =================================================================== --- node_modules/@stomp/stompjs/esm6/index.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/index.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,15 @@ +export * from './client.js'; +export * from './frame-impl.js'; +export * from './i-frame.js'; +export * from './i-message.js'; +export * from './parser.js'; +export * from './stomp-config.js'; +export * from './stomp-headers.js'; +export * from './stomp-subscription.js'; +export * from './i-transaction.js'; +export * from './types.js'; +export * from './versions.js'; +// Compatibility code +export * from './compatibility/compat-client.js'; +export * from './compatibility/stomp.js'; +//# sourceMappingURL=index.js.map Index: node_modules/@stomp/stompjs/esm6/index.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/index.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/index.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oBAAoB,CAAC;AACnC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAE9B,qBAAqB;AACrB,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC"} Index: node_modules/@stomp/stompjs/esm6/parser.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/parser.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/parser.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,70 @@ +import { IRawFrameType } from './types.js'; +/** + * This is an evented, rec descent parser. + * A stream of Octets can be passed and whenever it recognizes + * a complete Frame or an incoming ping it will invoke the registered callbacks. + * + * All incoming Octets are fed into _onByte function. + * Depending on current state the _onByte function keeps changing. + * Depending on the state it keeps accumulating into _token and _results. + * State is indicated by current value of _onByte, all states are named as _collect. + * + * STOMP standards https://stomp.github.io/stomp-specification-1.2.html + * imply that all lengths are considered in bytes (instead of string lengths). + * So, before actual parsing, if the incoming data is String it is converted to Octets. + * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body. + * + * There is no peek function on the incoming data. + * When a state change occurs based on an Octet without consuming the Octet, + * the Octet, after state change, is fed again (_reinjectByte). + * This became possible as the state change can be determined by inspecting just one Octet. + * + * There are two modes to collect the body, if content-length header is there then it by counting Octets + * otherwise it is determined by NULL terminator. + * + * Following the standards, the command and headers are converted to Strings + * and the body is returned as Octets. + * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header. + * + * This parser does not use Regular Expressions as that can only operate on Strings. + * + * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or + * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk + * is pushed. + * + * Typically the higher level function will convert headers to Hash, handle unescaping of header values + * (which is protocol version specific), and convert body to text. + * + * Check the parser.spec.js to understand cases that this parser is supposed to handle. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export declare class Parser { + onFrame: (rawFrame: IRawFrameType) => void; + onIncomingPing: () => void; + private readonly _encoder; + private readonly _decoder; + private _results; + private _token; + private _headerKey; + private _bodyBytesRemaining; + private _onByte; + constructor(onFrame: (rawFrame: IRawFrameType) => void, onIncomingPing: () => void); + parseChunk(segment: string | ArrayBuffer, appendMissingNULLonIncoming?: boolean): void; + private _collectFrame; + private _collectCommand; + private _collectHeaders; + private _reinjectByte; + private _collectHeaderKey; + private _collectHeaderValue; + private _setupCollectBody; + private _collectBodyNullTerminated; + private _collectBodyFixedSize; + private _retrievedBody; + private _consumeByte; + private _consumeTokenAsUTF8; + private _consumeTokenAsRaw; + private _initState; +} Index: node_modules/@stomp/stompjs/esm6/parser.js =================================================================== --- node_modules/@stomp/stompjs/esm6/parser.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/parser.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,222 @@ +/** + * @internal + */ +const NULL = 0; +/** + * @internal + */ +const LF = 10; +/** + * @internal + */ +const CR = 13; +/** + * @internal + */ +const COLON = 58; +/** + * This is an evented, rec descent parser. + * A stream of Octets can be passed and whenever it recognizes + * a complete Frame or an incoming ping it will invoke the registered callbacks. + * + * All incoming Octets are fed into _onByte function. + * Depending on current state the _onByte function keeps changing. + * Depending on the state it keeps accumulating into _token and _results. + * State is indicated by current value of _onByte, all states are named as _collect. + * + * STOMP standards https://stomp.github.io/stomp-specification-1.2.html + * imply that all lengths are considered in bytes (instead of string lengths). + * So, before actual parsing, if the incoming data is String it is converted to Octets. + * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body. + * + * There is no peek function on the incoming data. + * When a state change occurs based on an Octet without consuming the Octet, + * the Octet, after state change, is fed again (_reinjectByte). + * This became possible as the state change can be determined by inspecting just one Octet. + * + * There are two modes to collect the body, if content-length header is there then it by counting Octets + * otherwise it is determined by NULL terminator. + * + * Following the standards, the command and headers are converted to Strings + * and the body is returned as Octets. + * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header. + * + * This parser does not use Regular Expressions as that can only operate on Strings. + * + * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or + * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk + * is pushed. + * + * Typically the higher level function will convert headers to Hash, handle unescaping of header values + * (which is protocol version specific), and convert body to text. + * + * Check the parser.spec.js to understand cases that this parser is supposed to handle. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export class Parser { + constructor(onFrame, onIncomingPing) { + this.onFrame = onFrame; + this.onIncomingPing = onIncomingPing; + this._encoder = new TextEncoder(); + this._decoder = new TextDecoder(); + this._token = []; + this._initState(); + } + parseChunk(segment, appendMissingNULLonIncoming = false) { + let chunk; + if (typeof segment === 'string') { + chunk = this._encoder.encode(segment); + } + else { + chunk = new Uint8Array(segment); + } + // See https://github.com/stomp-js/stompjs/issues/89 + // Remove when underlying issue is fixed. + // + // Send a NULL byte, if the last byte of a Text frame was not NULL.F + if (appendMissingNULLonIncoming && chunk[chunk.length - 1] !== 0) { + const chunkWithNull = new Uint8Array(chunk.length + 1); + chunkWithNull.set(chunk, 0); + chunkWithNull[chunk.length] = 0; + chunk = chunkWithNull; + } + // tslint:disable-next-line:prefer-for-of + for (let i = 0; i < chunk.length; i++) { + const byte = chunk[i]; + this._onByte(byte); + } + } + // The following implements a simple Rec Descent Parser. + // The grammar is simple and just one byte tells what should be the next state + _collectFrame(byte) { + if (byte === NULL) { + // Ignore + return; + } + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + // Incoming Ping + this.onIncomingPing(); + return; + } + this._onByte = this._collectCommand; + this._reinjectByte(byte); + } + _collectCommand(byte) { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._results.command = this._consumeTokenAsUTF8(); + this._onByte = this._collectHeaders; + return; + } + this._consumeByte(byte); + } + _collectHeaders(byte) { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._setupCollectBody(); + return; + } + this._onByte = this._collectHeaderKey; + this._reinjectByte(byte); + } + _reinjectByte(byte) { + this._onByte(byte); + } + _collectHeaderKey(byte) { + if (byte === COLON) { + this._headerKey = this._consumeTokenAsUTF8(); + this._onByte = this._collectHeaderValue; + return; + } + this._consumeByte(byte); + } + _collectHeaderValue(byte) { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._results.headers.push([ + this._headerKey, + this._consumeTokenAsUTF8(), + ]); + this._headerKey = undefined; + this._onByte = this._collectHeaders; + return; + } + this._consumeByte(byte); + } + _setupCollectBody() { + const contentLengthHeader = this._results.headers.filter((header) => { + return header[0] === 'content-length'; + })[0]; + if (contentLengthHeader) { + this._bodyBytesRemaining = parseInt(contentLengthHeader[1], 10); + this._onByte = this._collectBodyFixedSize; + } + else { + this._onByte = this._collectBodyNullTerminated; + } + } + _collectBodyNullTerminated(byte) { + if (byte === NULL) { + this._retrievedBody(); + return; + } + this._consumeByte(byte); + } + _collectBodyFixedSize(byte) { + // It is post decrement, so that we discard the trailing NULL octet + if (this._bodyBytesRemaining-- === 0) { + this._retrievedBody(); + return; + } + this._consumeByte(byte); + } + _retrievedBody() { + this._results.binaryBody = this._consumeTokenAsRaw(); + try { + this.onFrame(this._results); + } + catch (e) { + console.log(`Ignoring an exception thrown by a frame handler. Original exception: `, e); + } + this._initState(); + } + // Rec Descent Parser helpers + _consumeByte(byte) { + this._token.push(byte); + } + _consumeTokenAsUTF8() { + return this._decoder.decode(this._consumeTokenAsRaw()); + } + _consumeTokenAsRaw() { + const rawResult = new Uint8Array(this._token); + this._token = []; + return rawResult; + } + _initState() { + this._results = { + command: undefined, + headers: [], + binaryBody: undefined, + }; + this._token = []; + this._headerKey = undefined; + this._onByte = this._collectFrame; + } +} +//# sourceMappingURL=parser.js.map Index: node_modules/@stomp/stompjs/esm6/parser.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/parser.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/parser.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"parser.js","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"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"} Index: node_modules/@stomp/stompjs/esm6/stomp-config.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-config.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-config.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,116 @@ +import { StompHeaders } from './stomp-headers.js'; +import { ActivationState, closeEventCallbackType, debugFnType, frameCallbackType, messageCallbackType, wsErrorCallbackType } from './types.js'; +import { Versions } from './versions.js'; +/** + * Configuration options for STOMP Client, each key corresponds to + * field by the same name in {@link Client}. This can be passed to + * the constructor of {@link Client} or to [Client#configure]{@link Client#configure}. + * + * Part of `@stomp/stompjs`. + */ +export declare class StompConfig { + /** + * See [Client#brokerURL]{@link Client#brokerURL}. + */ + brokerURL?: string; + /** + * See [Client#stompVersions]{@link Client#stompVersions}. + */ + stompVersions?: Versions; + /** + * See [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + webSocketFactory?: () => any; + /** + * See [Client#connectionTimeout]{@link Client#connectionTimeout}. + */ + connectionTimeout?: number; + /** + * See [Client#reconnectDelay]{@link Client#reconnectDelay}. + */ + reconnectDelay?: number; + /** + * See [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}. + */ + heartbeatIncoming?: number; + /** + * See [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + */ + heartbeatOutgoing?: number; + /** + * See [Client#splitLargeFrames]{@link Client#splitLargeFrames}. + */ + splitLargeFrames?: boolean; + /** + * See [Client#forceBinaryWSFrames]{@link Client#forceBinaryWSFrames}. + */ + forceBinaryWSFrames?: boolean; + /** + * See [Client#appendMissingNULLonIncoming]{@link Client#appendMissingNULLonIncoming}. + */ + appendMissingNULLonIncoming?: boolean; + /** + * See [Client#maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}. + */ + maxWebSocketChunkSize?: number; + /** + * See [Client#connectHeaders]{@link Client#connectHeaders}. + */ + connectHeaders?: StompHeaders; + /** + * See [Client#disconnectHeaders]{@link Client#disconnectHeaders}. + */ + disconnectHeaders?: StompHeaders; + /** + * See [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + */ + onUnhandledMessage?: messageCallbackType; + /** + * See [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + */ + onUnhandledReceipt?: frameCallbackType; + /** + * See [Client#onUnhandledFrame]{@link Client#onUnhandledFrame}. + */ + onUnhandledFrame?: frameCallbackType; + /** + * See [Client#beforeConnect]{@link Client#beforeConnect}. + */ + beforeConnect?: () => void | Promise; + /** + * See [Client#onConnect]{@link Client#onConnect}. + */ + onConnect?: frameCallbackType; + /** + * See [Client#onDisconnect]{@link Client#onDisconnect}. + */ + onDisconnect?: frameCallbackType; + /** + * See [Client#onStompError]{@link Client#onStompError}. + */ + onStompError?: frameCallbackType; + /** + * See [Client#onWebSocketClose]{@link Client#onWebSocketClose}. + */ + onWebSocketClose?: closeEventCallbackType; + /** + * See [Client#onWebSocketError]{@link Client#onWebSocketError}. + */ + onWebSocketError?: wsErrorCallbackType; + /** + * See [Client#logRawCommunication]{@link Client#logRawCommunication}. + */ + logRawCommunication?: boolean; + /** + * See [Client#debug]{@link Client#debug}. + */ + debug?: debugFnType; + /** + * See [Client#discardWebsocketOnCommFailure]{@link Client#discardWebsocketOnCommFailure}. + */ + discardWebsocketOnCommFailure?: boolean; + /** + * See [Client#onChangeState]{@link Client#onChangeState}. + */ + onChangeState?: (state: ActivationState) => void; +} Index: node_modules/@stomp/stompjs/esm6/stomp-config.js =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-config.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-config.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,10 @@ +/** + * Configuration options for STOMP Client, each key corresponds to + * field by the same name in {@link Client}. This can be passed to + * the constructor of {@link Client} or to [Client#configure]{@link Client#configure}. + * + * Part of `@stomp/stompjs`. + */ +export class StompConfig { +} +//# sourceMappingURL=stomp-config.js.map Index: node_modules/@stomp/stompjs/esm6/stomp-config.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-config.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-config.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"stomp-config.js","sourceRoot":"","sources":["../src/stomp-config.ts"],"names":[],"mappings":"AAWA;;;;;;GAMG;AACH,MAAM,OAAO,WAAW;CAkIvB"} Index: node_modules/@stomp/stompjs/esm6/stomp-handler.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-handler.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-handler.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,69 @@ +import { Client } from './client.js'; +import { ITransaction } from './i-transaction.js'; +import { StompHeaders } from './stomp-headers.js'; +import { StompSubscription } from './stomp-subscription.js'; +import { closeEventCallbackType, debugFnType, frameCallbackType, IPublishParams, IStompSocket, IStomptHandlerConfig, messageCallbackType, wsErrorCallbackType } from './types.js'; +import { Versions } from './versions.js'; +/** + * The STOMP protocol handler + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export declare class StompHandler { + private _client; + _webSocket: IStompSocket; + debug: debugFnType; + stompVersions: Versions; + connectHeaders: StompHeaders; + disconnectHeaders: StompHeaders; + heartbeatIncoming: number; + heartbeatOutgoing: number; + onUnhandledMessage: messageCallbackType; + onUnhandledReceipt: frameCallbackType; + onUnhandledFrame: frameCallbackType; + onConnect: frameCallbackType; + onDisconnect: frameCallbackType; + onStompError: frameCallbackType; + onWebSocketClose: closeEventCallbackType; + onWebSocketError: wsErrorCallbackType; + logRawCommunication: boolean; + splitLargeFrames: boolean; + maxWebSocketChunkSize: number; + forceBinaryWSFrames: boolean; + appendMissingNULLonIncoming: boolean; + discardWebsocketOnCommFailure: boolean; + get connectedVersion(): string | undefined; + private _connectedVersion; + get connected(): boolean; + private _connected; + private readonly _subscriptions; + private readonly _receiptWatchers; + private _partialData; + private _escapeHeaderValues; + private _counter; + private _pinger; + private _ponger; + private _lastServerActivityTS; + constructor(_client: Client, _webSocket: IStompSocket, config: IStomptHandlerConfig); + start(): void; + private readonly _serverFrameHandlers; + private _setupHeartbeat; + private _closeOrDiscardWebsocket; + forceDisconnect(): void; + _closeWebsocket(): void; + discardWebsocket(): void; + private _transmit; + dispose(): void; + private _cleanUp; + publish(params: IPublishParams): void; + watchForReceipt(receiptId: string, callback: frameCallbackType): void; + subscribe(destination: string, callback: messageCallbackType, headers?: StompHeaders): StompSubscription; + unsubscribe(id: string, headers?: StompHeaders): void; + begin(transactionId: string): ITransaction; + commit(transactionId: string): void; + abort(transactionId: string): void; + ack(messageId: string, subscriptionId: string, headers?: StompHeaders): void; + nack(messageId: string, subscriptionId: string, headers?: StompHeaders): void; +} Index: node_modules/@stomp/stompjs/esm6/stomp-handler.js =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-handler.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-handler.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,391 @@ +import { BYTE } from './byte.js'; +import { FrameImpl } from './frame-impl.js'; +import { Parser } from './parser.js'; +import { StompSocketState, } from './types.js'; +import { Versions } from './versions.js'; +import { augmentWebsocket } from './augment-websocket.js'; +/** + * The STOMP protocol handler + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export class StompHandler { + constructor(_client, _webSocket, config) { + this._client = _client; + this._webSocket = _webSocket; + this._connected = false; + this._serverFrameHandlers = { + // [CONNECTED Frame](https://stomp.github.com/stomp-specification-1.2.html#CONNECTED_Frame) + CONNECTED: frame => { + this.debug(`connected to server ${frame.headers.server}`); + this._connected = true; + this._connectedVersion = frame.headers.version; + // STOMP version 1.2 needs header values to be escaped + if (this._connectedVersion === Versions.V1_2) { + this._escapeHeaderValues = true; + } + this._setupHeartbeat(frame.headers); + this.onConnect(frame); + }, + // [MESSAGE Frame](https://stomp.github.com/stomp-specification-1.2.html#MESSAGE) + MESSAGE: frame => { + // the callback is registered when the client calls + // `subscribe()`. + // If there is no registered subscription for the received message, + // the default `onUnhandledMessage` callback is used that the client can set. + // This is useful for subscriptions that are automatically created + // on the browser side (e.g. [RabbitMQ's temporary + // queues](https://www.rabbitmq.com/stomp.html)). + const subscription = frame.headers.subscription; + const onReceive = this._subscriptions[subscription] || this.onUnhandledMessage; + // bless the frame to be a Message + const message = frame; + const client = this; + const messageId = this._connectedVersion === Versions.V1_2 + ? message.headers.ack + : message.headers['message-id']; + // add `ack()` and `nack()` methods directly to the returned frame + // so that a simple call to `message.ack()` can acknowledge the message. + message.ack = (headers = {}) => { + return client.ack(messageId, subscription, headers); + }; + message.nack = (headers = {}) => { + return client.nack(messageId, subscription, headers); + }; + onReceive(message); + }, + // [RECEIPT Frame](https://stomp.github.com/stomp-specification-1.2.html#RECEIPT) + RECEIPT: frame => { + const callback = this._receiptWatchers[frame.headers['receipt-id']]; + if (callback) { + callback(frame); + // Server will acknowledge only once, remove the callback + delete this._receiptWatchers[frame.headers['receipt-id']]; + } + else { + this.onUnhandledReceipt(frame); + } + }, + // [ERROR Frame](https://stomp.github.com/stomp-specification-1.2.html#ERROR) + ERROR: frame => { + this.onStompError(frame); + }, + }; + // used to index subscribers + this._counter = 0; + // subscription callbacks indexed by subscriber's ID + this._subscriptions = {}; + // receipt-watchers indexed by receipts-ids + this._receiptWatchers = {}; + this._partialData = ''; + this._escapeHeaderValues = false; + this._lastServerActivityTS = Date.now(); + this.debug = config.debug; + this.stompVersions = config.stompVersions; + this.connectHeaders = config.connectHeaders; + this.disconnectHeaders = config.disconnectHeaders; + this.heartbeatIncoming = config.heartbeatIncoming; + this.heartbeatOutgoing = config.heartbeatOutgoing; + this.splitLargeFrames = config.splitLargeFrames; + this.maxWebSocketChunkSize = config.maxWebSocketChunkSize; + this.forceBinaryWSFrames = config.forceBinaryWSFrames; + this.logRawCommunication = config.logRawCommunication; + this.appendMissingNULLonIncoming = config.appendMissingNULLonIncoming; + this.discardWebsocketOnCommFailure = config.discardWebsocketOnCommFailure; + this.onConnect = config.onConnect; + this.onDisconnect = config.onDisconnect; + this.onStompError = config.onStompError; + this.onWebSocketClose = config.onWebSocketClose; + this.onWebSocketError = config.onWebSocketError; + this.onUnhandledMessage = config.onUnhandledMessage; + this.onUnhandledReceipt = config.onUnhandledReceipt; + this.onUnhandledFrame = config.onUnhandledFrame; + } + get connectedVersion() { + return this._connectedVersion; + } + get connected() { + return this._connected; + } + start() { + const parser = new Parser( + // On Frame + rawFrame => { + const frame = FrameImpl.fromRawFrame(rawFrame, this._escapeHeaderValues); + // if this.logRawCommunication is set, the rawChunk is logged at this._webSocket.onmessage + if (!this.logRawCommunication) { + this.debug(`<<< ${frame}`); + } + const serverFrameHandler = this._serverFrameHandlers[frame.command] || this.onUnhandledFrame; + serverFrameHandler(frame); + }, + // On Incoming Ping + () => { + this.debug('<<< PONG'); + }); + this._webSocket.onmessage = (evt) => { + this.debug('Received data'); + this._lastServerActivityTS = Date.now(); + if (this.logRawCommunication) { + const rawChunkAsString = evt.data instanceof ArrayBuffer + ? new TextDecoder().decode(evt.data) + : evt.data; + this.debug(`<<< ${rawChunkAsString}`); + } + parser.parseChunk(evt.data, this.appendMissingNULLonIncoming); + }; + this._webSocket.onclose = (closeEvent) => { + this.debug(`Connection closed to ${this._webSocket.url}`); + this._cleanUp(); + this.onWebSocketClose(closeEvent); + }; + this._webSocket.onerror = (errorEvent) => { + this.onWebSocketError(errorEvent); + }; + this._webSocket.onopen = () => { + // Clone before updating + const connectHeaders = Object.assign({}, this.connectHeaders); + this.debug('Web Socket Opened...'); + connectHeaders['accept-version'] = this.stompVersions.supportedVersions(); + connectHeaders['heart-beat'] = [ + this.heartbeatOutgoing, + this.heartbeatIncoming, + ].join(','); + this._transmit({ command: 'CONNECT', headers: connectHeaders }); + }; + } + _setupHeartbeat(headers) { + if (headers.version !== Versions.V1_1 && + headers.version !== Versions.V1_2) { + return; + } + // It is valid for the server to not send this header + // https://stomp.github.io/stomp-specification-1.2.html#Heart-beating + if (!headers['heart-beat']) { + return; + } + // heart-beat header received from the server looks like: + // + // heart-beat: sx, sy + const [serverOutgoing, serverIncoming] = headers['heart-beat'] + .split(',') + .map((v) => parseInt(v, 10)); + if (this.heartbeatOutgoing !== 0 && serverIncoming !== 0) { + const ttl = Math.max(this.heartbeatOutgoing, serverIncoming); + this.debug(`send PING every ${ttl}ms`); + this._pinger = setInterval(() => { + if (this._webSocket.readyState === StompSocketState.OPEN) { + this._webSocket.send(BYTE.LF); + this.debug('>>> PING'); + } + }, ttl); + } + if (this.heartbeatIncoming !== 0 && serverOutgoing !== 0) { + const ttl = Math.max(this.heartbeatIncoming, serverOutgoing); + this.debug(`check PONG every ${ttl}ms`); + this._ponger = setInterval(() => { + const delta = Date.now() - this._lastServerActivityTS; + // We wait twice the TTL to be flexible on window's setInterval calls + if (delta > ttl * 2) { + this.debug(`did not receive server activity for the last ${delta}ms`); + this._closeOrDiscardWebsocket(); + } + }, ttl); + } + } + _closeOrDiscardWebsocket() { + if (this.discardWebsocketOnCommFailure) { + this.debug('Discarding websocket, the underlying socket may linger for a while'); + this.discardWebsocket(); + } + else { + this.debug('Issuing close on the websocket'); + this._closeWebsocket(); + } + } + forceDisconnect() { + if (this._webSocket) { + if (this._webSocket.readyState === StompSocketState.CONNECTING || + this._webSocket.readyState === StompSocketState.OPEN) { + this._closeOrDiscardWebsocket(); + } + } + } + _closeWebsocket() { + this._webSocket.onmessage = () => { }; // ignore messages + this._webSocket.close(); + } + discardWebsocket() { + if (typeof this._webSocket.terminate !== 'function') { + augmentWebsocket(this._webSocket, (msg) => this.debug(msg)); + } + // @ts-ignore - this method will be there at this stage + this._webSocket.terminate(); + } + _transmit(params) { + const { command, headers, body, binaryBody, skipContentLengthHeader } = params; + const frame = new FrameImpl({ + command, + headers, + body, + binaryBody, + escapeHeaderValues: this._escapeHeaderValues, + skipContentLengthHeader, + }); + let rawChunk = frame.serialize(); + if (this.logRawCommunication) { + this.debug(`>>> ${rawChunk}`); + } + else { + this.debug(`>>> ${frame}`); + } + if (this.forceBinaryWSFrames && typeof rawChunk === 'string') { + rawChunk = new TextEncoder().encode(rawChunk); + } + if (typeof rawChunk !== 'string' || !this.splitLargeFrames) { + this._webSocket.send(rawChunk); + } + else { + let out = rawChunk; + while (out.length > 0) { + const chunk = out.substring(0, this.maxWebSocketChunkSize); + out = out.substring(this.maxWebSocketChunkSize); + this._webSocket.send(chunk); + this.debug(`chunk sent = ${chunk.length}, remaining = ${out.length}`); + } + } + } + dispose() { + if (this.connected) { + try { + // clone before updating + const disconnectHeaders = Object.assign({}, this.disconnectHeaders); + if (!disconnectHeaders.receipt) { + disconnectHeaders.receipt = `close-${this._counter++}`; + } + this.watchForReceipt(disconnectHeaders.receipt, frame => { + this._closeWebsocket(); + this._cleanUp(); + this.onDisconnect(frame); + }); + this._transmit({ command: 'DISCONNECT', headers: disconnectHeaders }); + } + catch (error) { + this.debug(`Ignoring error during disconnect ${error}`); + } + } + else { + if (this._webSocket.readyState === StompSocketState.CONNECTING || + this._webSocket.readyState === StompSocketState.OPEN) { + this._closeWebsocket(); + } + } + } + _cleanUp() { + this._connected = false; + if (this._pinger) { + clearInterval(this._pinger); + this._pinger = undefined; + } + if (this._ponger) { + clearInterval(this._ponger); + this._ponger = undefined; + } + } + publish(params) { + const { destination, headers, body, binaryBody, skipContentLengthHeader } = params; + const hdrs = Object.assign({ destination }, headers); + this._transmit({ + command: 'SEND', + headers: hdrs, + body, + binaryBody, + skipContentLengthHeader, + }); + } + watchForReceipt(receiptId, callback) { + this._receiptWatchers[receiptId] = callback; + } + subscribe(destination, callback, headers = {}) { + headers = Object.assign({}, headers); + if (!headers.id) { + headers.id = `sub-${this._counter++}`; + } + headers.destination = destination; + this._subscriptions[headers.id] = callback; + this._transmit({ command: 'SUBSCRIBE', headers }); + const client = this; + return { + id: headers.id, + unsubscribe(hdrs) { + return client.unsubscribe(headers.id, hdrs); + }, + }; + } + unsubscribe(id, headers = {}) { + headers = Object.assign({}, headers); + delete this._subscriptions[id]; + headers.id = id; + this._transmit({ command: 'UNSUBSCRIBE', headers }); + } + begin(transactionId) { + const txId = transactionId || `tx-${this._counter++}`; + this._transmit({ + command: 'BEGIN', + headers: { + transaction: txId, + }, + }); + const client = this; + return { + id: txId, + commit() { + client.commit(txId); + }, + abort() { + client.abort(txId); + }, + }; + } + commit(transactionId) { + this._transmit({ + command: 'COMMIT', + headers: { + transaction: transactionId, + }, + }); + } + abort(transactionId) { + this._transmit({ + command: 'ABORT', + headers: { + transaction: transactionId, + }, + }); + } + ack(messageId, subscriptionId, headers = {}) { + headers = Object.assign({}, headers); + if (this._connectedVersion === Versions.V1_2) { + headers.id = messageId; + } + else { + headers['message-id'] = messageId; + } + headers.subscription = subscriptionId; + this._transmit({ command: 'ACK', headers }); + } + nack(messageId, subscriptionId, headers = {}) { + headers = Object.assign({}, headers); + if (this._connectedVersion === Versions.V1_2) { + headers.id = messageId; + } + else { + headers['message-id'] = messageId; + } + headers.subscription = subscriptionId; + return this._transmit({ command: 'NACK', headers }); + } +} +//# sourceMappingURL=stomp-handler.js.map Index: node_modules/@stomp/stompjs/esm6/stomp-handler.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-handler.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-handler.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"stomp-handler.js","sourceRoot":"","sources":["../src/stomp-handler.ts"],"names":[],"mappings":"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"} Index: node_modules/@stomp/stompjs/esm6/stomp-headers.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-headers.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-headers.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,12 @@ +/** + * STOMP headers. Many functions calls will accept headers as parameters. + * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}. + * + * `key` and `value` must be valid strings. + * In addition, `key` must not contain `CR`, `LF`, or `:`. + * + * Part of `@stomp/stompjs`. + */ +export declare class StompHeaders { + [key: string]: string; +} Index: node_modules/@stomp/stompjs/esm6/stomp-headers.js =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-headers.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-headers.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,12 @@ +/** + * STOMP headers. Many functions calls will accept headers as parameters. + * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}. + * + * `key` and `value` must be valid strings. + * In addition, `key` must not contain `CR`, `LF`, or `:`. + * + * Part of `@stomp/stompjs`. + */ +export class StompHeaders { +} +//# sourceMappingURL=stomp-headers.js.map Index: node_modules/@stomp/stompjs/esm6/stomp-headers.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-headers.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-headers.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"stomp-headers.js","sourceRoot":"","sources":["../src/stomp-headers.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,OAAO,YAAY;CAExB"} Index: node_modules/@stomp/stompjs/esm6/stomp-subscription.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-subscription.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-subscription.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,16 @@ +import { StompHeaders } from './stomp-headers.js'; +/** + * Call [Client#subscribe]{@link Client#subscribe} to create a StompSubscription. + * + * Part of `@stomp/stompjs`. + */ +export interface StompSubscription { + /** + * Id associated with this subscription. + */ + id: string; + /** + * Unsubscribe. See [Client#unsubscribe]{@link Client#unsubscribe} for an example. + */ + unsubscribe: (headers?: StompHeaders) => void; +} Index: node_modules/@stomp/stompjs/esm6/stomp-subscription.js =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-subscription.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-subscription.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,2 @@ +export {}; +//# sourceMappingURL=stomp-subscription.js.map Index: node_modules/@stomp/stompjs/esm6/stomp-subscription.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/stomp-subscription.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/stomp-subscription.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"stomp-subscription.js","sourceRoot":"","sources":["../src/stomp-subscription.ts"],"names":[],"mappings":""} Index: node_modules/@stomp/stompjs/esm6/types.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/types.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/types.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,167 @@ +import { IFrame } from './i-frame.js'; +import { IMessage } from './i-message.js'; +import { StompHeaders } from './stomp-headers.js'; +import { Versions } from './versions.js'; +/** + * This callback will receive a `string` as a parameter. + * + * Part of `@stomp/stompjs`. + */ +export declare type debugFnType = (msg: string) => void; +/** + * This callback will receive a {@link IMessage} as parameter. + * + * Part of `@stomp/stompjs`. + */ +export declare type messageCallbackType = (message: IMessage) => void; +/** + * This callback will receive a {@link IFrame} as parameter. + * + * Part of `@stomp/stompjs`. + */ +export declare type frameCallbackType = ((frame: IFrame) => void) | (() => void); +/** + * This callback will receive a [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent} + * as parameter. + * + * Part of `@stomp/stompjs`. + */ +export declare type closeEventCallbackType = (evt: T) => void; +/** + * This callback will receive an [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event} + * as parameter. + * + * Part of `@stomp/stompjs`. + */ +export declare type wsErrorCallbackType = (evt: T) => void; +/** + * Parameters for [Client#publish]{@link Client#publish}. + * Aliased as publishParams as well. + * + * Part of `@stomp/stompjs`. + */ +export interface IPublishParams { + /** + * destination end point + */ + destination: string; + /** + * headers (optional) + */ + headers?: StompHeaders; + /** + * body (optional) + */ + body?: string; + /** + * binary body (optional) + */ + binaryBody?: Uint8Array; + /** + * By default, a `content-length` header will be added in the Frame to the broker. + * Set it to `true` for the header to be skipped. + */ + skipContentLengthHeader?: boolean; +} +/** + * Backward compatibility, switch to {@link IPublishParams}. + */ +export declare type publishParams = IPublishParams; +/** + * Used in {@link IRawFrameType} + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export declare type RawHeaderType = [string, string]; +/** + * The parser yield frames in this structure + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export interface IRawFrameType { + command: string | undefined; + headers: RawHeaderType[]; + binaryBody: Uint8Array | undefined; +} +/** + * @internal + */ +export interface IStompSocketMessageEvent { + data?: string | ArrayBuffer; +} +/** + * Copied from Websocket interface to avoid dom typelib dependency. + * + * @internal + */ +export interface IStompSocket { + url: string; + onclose: ((ev?: any) => any) | undefined | null; + onerror: ((ev: any) => any) | undefined | null; + onmessage: ((ev: IStompSocketMessageEvent) => any) | undefined | null; + onopen: ((ev?: any) => any) | undefined | null; + terminate?: (() => any) | undefined | null; + /** + * Returns a string that indicates how binary data from the socket is exposed to scripts: + * We support only 'arraybuffer'. + */ + binaryType?: string; + /** + * Returns the state of the socket connection. It can have the values of StompSocketState. + */ + readonly readyState: number; + /** + * Closes the connection. + */ + close(): void; + /** + * Transmits data using the connection. data can be a string or an ArrayBuffer. + */ + send(data: string | ArrayBuffer): void; +} +/** + * Possible states for the IStompSocket + */ +export declare enum StompSocketState { + CONNECTING = 0, + OPEN = 1, + CLOSING = 2, + CLOSED = 3 +} +/** + * Possible activation state + */ +export declare enum ActivationState { + ACTIVE = 0, + DEACTIVATING = 1, + INACTIVE = 2 +} +/** + * @internal + */ +export interface IStomptHandlerConfig { + debug: debugFnType; + stompVersions: Versions; + connectHeaders: StompHeaders; + disconnectHeaders: StompHeaders; + heartbeatIncoming: number; + heartbeatOutgoing: number; + splitLargeFrames: boolean; + maxWebSocketChunkSize: number; + forceBinaryWSFrames: boolean; + logRawCommunication: boolean; + appendMissingNULLonIncoming: boolean; + discardWebsocketOnCommFailure: boolean; + onConnect: frameCallbackType; + onDisconnect: frameCallbackType; + onStompError: frameCallbackType; + onWebSocketClose: closeEventCallbackType; + onWebSocketError: wsErrorCallbackType; + onUnhandledMessage: messageCallbackType; + onUnhandledReceipt: frameCallbackType; + onUnhandledFrame: frameCallbackType; +} Index: node_modules/@stomp/stompjs/esm6/types.js =================================================================== --- node_modules/@stomp/stompjs/esm6/types.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/types.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,20 @@ +/** + * Possible states for the IStompSocket + */ +export var StompSocketState; +(function (StompSocketState) { + StompSocketState[StompSocketState["CONNECTING"] = 0] = "CONNECTING"; + StompSocketState[StompSocketState["OPEN"] = 1] = "OPEN"; + StompSocketState[StompSocketState["CLOSING"] = 2] = "CLOSING"; + StompSocketState[StompSocketState["CLOSED"] = 3] = "CLOSED"; +})(StompSocketState = StompSocketState || (StompSocketState = {})); +/** + * Possible activation state + */ +export var ActivationState; +(function (ActivationState) { + ActivationState[ActivationState["ACTIVE"] = 0] = "ACTIVE"; + ActivationState[ActivationState["DEACTIVATING"] = 1] = "DEACTIVATING"; + ActivationState[ActivationState["INACTIVE"] = 2] = "INACTIVE"; +})(ActivationState = ActivationState || (ActivationState = {})); +//# sourceMappingURL=types.js.map Index: node_modules/@stomp/stompjs/esm6/types.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/types.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/types.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AA4IA;;GAEG;AACH,MAAM,CAAN,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,mEAAU,CAAA;IACV,uDAAI,CAAA;IACJ,6DAAO,CAAA;IACP,2DAAM,CAAA;AACR,CAAC,EALW,gBAAgB,GAAhB,gBAAgB,KAAhB,gBAAgB,QAK3B;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,yDAAM,CAAA;IACN,qEAAY,CAAA;IACZ,6DAAQ,CAAA;AACV,CAAC,EAJW,eAAe,GAAf,eAAe,KAAf,eAAe,QAI1B"} Index: node_modules/@stomp/stompjs/esm6/versions.d.ts =================================================================== --- node_modules/@stomp/stompjs/esm6/versions.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/versions.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,39 @@ +/** + * Supported STOMP versions + * + * Part of `@stomp/stompjs`. + */ +export declare class Versions { + versions: string[]; + /** + * Indicates protocol version 1.0 + */ + static V1_0: string; + /** + * Indicates protocol version 1.1 + */ + static V1_1: string; + /** + * Indicates protocol version 1.2 + */ + static V1_2: string; + /** + * @internal + */ + static default: Versions; + /** + * Takes an array of versions, typical elements '1.2', '1.1', or '1.0' + * + * You will be creating an instance of this class if you want to override + * supported versions to be declared during STOMP handshake. + */ + constructor(versions: string[]); + /** + * Used as part of CONNECT STOMP Frame + */ + supportedVersions(): string; + /** + * Used while creating a WebSocket + */ + protocolVersions(): string[]; +} Index: node_modules/@stomp/stompjs/esm6/versions.js =================================================================== --- node_modules/@stomp/stompjs/esm6/versions.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/versions.js (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,49 @@ +/** + * Supported STOMP versions + * + * Part of `@stomp/stompjs`. + */ +export class Versions { + /** + * Takes an array of versions, typical elements '1.2', '1.1', or '1.0' + * + * You will be creating an instance of this class if you want to override + * supported versions to be declared during STOMP handshake. + */ + constructor(versions) { + this.versions = versions; + } + /** + * Used as part of CONNECT STOMP Frame + */ + supportedVersions() { + return this.versions.join(','); + } + /** + * Used while creating a WebSocket + */ + protocolVersions() { + return this.versions.map(x => `v${x.replace('.', '')}.stomp`); + } +} +/** + * Indicates protocol version 1.0 + */ +Versions.V1_0 = '1.0'; +/** + * Indicates protocol version 1.1 + */ +Versions.V1_1 = '1.1'; +/** + * Indicates protocol version 1.2 + */ +Versions.V1_2 = '1.2'; +/** + * @internal + */ +Versions.default = new Versions([ + Versions.V1_2, + Versions.V1_1, + Versions.V1_0, +]); +//# sourceMappingURL=versions.js.map Index: node_modules/@stomp/stompjs/esm6/versions.js.map =================================================================== --- node_modules/@stomp/stompjs/esm6/versions.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/esm6/versions.js.map (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +{"version":3,"file":"versions.js","sourceRoot":"","sources":["../src/versions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,QAAQ;IAuBnB;;;;;OAKG;IACH,YAAmB,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;IAAG,CAAC;IAEzC;;OAEG;IACI,iBAAiB;QACtB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,gBAAgB;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,CAAC,QAAQ,CAAC,CAAC;IAChE,CAAC;;AA1CD;;GAEG;AACW,aAAI,GAAG,KAAK,CAAC;AAC3B;;GAEG;AACW,aAAI,GAAG,KAAK,CAAC;AAC3B;;GAEG;AACW,aAAI,GAAG,KAAK,CAAC;AAE3B;;GAEG;AACW,gBAAO,GAAG,IAAI,QAAQ,CAAC;IACnC,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,IAAI;IACb,QAAQ,CAAC,IAAI;CACd,CAAC,CAAC"} Index: node_modules/@stomp/stompjs/index.d.ts =================================================================== --- node_modules/@stomp/stompjs/index.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/index.d.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,1 @@ +export * from './esm6/index.js'; Index: node_modules/@stomp/stompjs/package.json =================================================================== --- node_modules/@stomp/stompjs/package.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/package.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,93 @@ +{ + "_from": "@stomp/stompjs", + "_id": "@stomp/stompjs@7.0.0", + "_inBundle": false, + "_integrity": "sha512-fGdq4wPDnSV/KyOsjq4P+zLc8MFWC3lMmP5FBgLWKPJTYcuCbAIrnRGjB7q2jHZdYCOD5vxLuFoKIYLy5/u8Pw==", + "_location": "/@stomp/stompjs", + "_phantomChildren": {}, + "_requested": { + "type": "tag", + "registry": true, + "raw": "@stomp/stompjs", + "name": "@stomp/stompjs", + "escapedName": "@stomp%2fstompjs", + "scope": "@stomp", + "rawSpec": "", + "saveSpec": null, + "fetchSpec": "latest" + }, + "_requiredBy": [ + "#USER", + "/" + ], + "_resolved": "https://registry.npmjs.org/@stomp/stompjs/-/stompjs-7.0.0.tgz", + "_shasum": "46b5c454a9dc8262e0b20f3b3dbacaa113993077", + "_spec": "@stomp/stompjs", + "_where": "/home/stevetosak/Projects/BuildBoard", + "author": { + "name": "deepak@kreatio.com" + }, + "browser": "./bundles/stomp.umd.js", + "bugs": { + "url": "https://github.com/stomp-js/stompjs/issues" + }, + "bundleDependencies": false, + "deprecated": false, + "description": "STOMP client for Javascript and Typescript", + "devDependencies": { + "@chiragrupani/karma-chromium-edge-launcher": "^2.2.2", + "@rollup/plugin-terser": "^0.4.0", + "@rollup/plugin-typescript": "^11.0.0", + "jasmine": "^4.3.0", + "karma": "^6.4.0", + "karma-chrome-launcher": "^3.1.1", + "karma-firefox-launcher": "^2.1.2", + "karma-jasmine": "^5.1.0", + "karma-safari-launcher": "git+https://github.com/RLovelett/karma-safari-launcher.git#safari-webdriver", + "karma-summary-reporter": "^3.1.1", + "onchange": "^7.1.0", + "prettier": "^2.7.1", + "rollup": "^3.9.1", + "text-encoding": "^0.7.0", + "ts-loader": "^9.3.1", + "tslint": "^6.1.3", + "tslint-config-prettier": "^1.18.0", + "typescript": "^4.8.2", + "ws": "^8.8.1" + }, + "exports": { + "import": "./esm6/index.js", + "require": "./bundles/stomp.umd.js" + }, + "homepage": "https://github.com/stomp-js/stompjs#readme", + "keywords": [ + "STOMP", + "RabbitMQ", + "ActiveMQ", + "Websocket", + "messaging", + "queue", + "SockJS" + ], + "license": "Apache-2.0", + "name": "@stomp/stompjs", + "repository": { + "type": "git", + "url": "git+https://github.com/stomp-js/stompjs.git" + }, + "scripts": { + "build": "npm run clean && npx tsc && npm run rollup && cp spec/package.json bundles", + "clean": "rm -rf bundles esm6", + "karma": "karma start spec/karma.conf.js --single-run", + "lint": "tslint 'src/**/*.ts'", + "prepublishOnly": "npm run lint && npm run build && npm run karma && npm run test", + "prettier": "prettier --write .", + "rollup": "rollup -c && rm -rf bundles/*.d.ts bundles/compatibility/", + "test": "jasmine", + "test-helpers": "tsc -p spec/helpers-src/tsconfig.json" + }, + "sideEffects": false, + "type": "module", + "typings": "index.d.ts", + "version": "7.0.0" +} Index: node_modules/@stomp/stompjs/src/augment-websocket.ts =================================================================== --- node_modules/@stomp/stompjs/src/augment-websocket.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/augment-websocket.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,39 @@ +import { IStompSocket } from './types.js'; + +/** + * @internal + */ +export function augmentWebsocket( + webSocket: IStompSocket, + debug: (msg: string) => void +) { + webSocket.terminate = function () { + const noOp = () => {}; + + // set all callbacks to no op + this.onerror = noOp; + this.onmessage = noOp; + this.onopen = noOp; + + const ts = new Date(); + const id = Math.random().toString().substring(2, 8); // A simulated id + + const origOnClose = this.onclose; + + // Track delay in actual closure of the socket + this.onclose = closeEvent => { + const delay = new Date().getTime() - ts.getTime(); + debug( + `Discarded socket (#${id}) closed after ${delay}ms, with code/reason: ${closeEvent.code}/${closeEvent.reason}` + ); + }; + + this.close(); + + origOnClose?.call(webSocket, { + code: 4001, + reason: `Quick discarding socket (#${id}) without waiting for the shutdown sequence.`, + wasClean: false, + }); + }; +} Index: node_modules/@stomp/stompjs/src/byte.ts =================================================================== --- node_modules/@stomp/stompjs/src/byte.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/byte.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,13 @@ +/** + * Some byte values, used as per STOMP specifications. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export const BYTE = { + // LINEFEED byte (octet 10) + LF: '\x0A', + // NULL byte (octet 0) + NULL: '\x00', +}; Index: node_modules/@stomp/stompjs/src/client.ts =================================================================== --- node_modules/@stomp/stompjs/src/client.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/client.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,867 @@ +import { ITransaction } from './i-transaction.js'; +import { StompConfig } from './stomp-config.js'; +import { StompHandler } from './stomp-handler.js'; +import { StompHeaders } from './stomp-headers.js'; +import { StompSubscription } from './stomp-subscription.js'; +import { + ActivationState, + closeEventCallbackType, + debugFnType, + frameCallbackType, + IPublishParams, + IStompSocket, + messageCallbackType, + StompSocketState, + wsErrorCallbackType, +} from './types.js'; +import { Versions } from './versions.js'; + +/** + * @internal + */ +declare const WebSocket: { + prototype: IStompSocket; + new (url: string, protocols?: string | string[]): IStompSocket; +}; + +/** + * STOMP Client Class. + * + * Part of `@stomp/stompjs`. + */ +export class Client { + /** + * The URL for the STOMP broker to connect to. + * Typically like `"ws://broker.329broker.com:15674/ws"` or `"wss://broker.329broker.com:15674/ws"`. + * + * Only one of this or [Client#webSocketFactory]{@link Client#webSocketFactory} need to be set. + * If both are set, [Client#webSocketFactory]{@link Client#webSocketFactory} will be used. + * + * If your environment does not support WebSockets natively, please refer to + * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}. + */ + public brokerURL: string | undefined; + + /** + * STOMP versions to attempt during STOMP handshake. By default, versions `1.2`, `1.1`, and `1.0` are attempted. + * + * Example: + * ```javascript + * // Try only versions 1.1 and 1.0 + * client.stompVersions = new Versions(['1.1', '1.0']) + * ``` + */ + public stompVersions = Versions.default; + + /** + * This function should return a WebSocket or a similar (e.g. SockJS) object. + * If your environment does not support WebSockets natively, please refer to + * [Polyfills]{@link https://stomp-js.github.io/guide/stompjs/rx-stomp/ng2-stompjs/pollyfils-for-stompjs-v5.html}. + * If your STOMP Broker supports WebSockets, prefer setting [Client#brokerURL]{@link Client#brokerURL}. + * + * If both this and [Client#brokerURL]{@link Client#brokerURL} are set, this will be used. + * + * Example: + * ```javascript + * // use a WebSocket + * client.webSocketFactory= function () { + * return new WebSocket("wss://broker.329broker.com:15674/ws"); + * }; + * + * // Typical usage with SockJS + * client.webSocketFactory= function () { + * return new SockJS("http://broker.329broker.com/stomp"); + * }; + * ``` + */ + public webSocketFactory: (() => IStompSocket) | undefined; + + /** + * Will retry if Stomp connection is not established in specified milliseconds. + * Default 0, which switches off automatic reconnection. + */ + public connectionTimeout: number = 0; + + // As per https://stackoverflow.com/questions/45802988/typescript-use-correct-version-of-settimeout-node-vs-window/56239226#56239226 + private _connectionWatcher: ReturnType | undefined; // Timer + + /** + * automatically reconnect with delay in milliseconds, set to 0 to disable. + */ + public reconnectDelay: number = 5000; + + /** + * Incoming heartbeat interval in milliseconds. Set to 0 to disable. + */ + public heartbeatIncoming: number = 10000; + + /** + * Outgoing heartbeat interval in milliseconds. Set to 0 to disable. + */ + public heartbeatOutgoing: number = 10000; + + /** + * This switches on a non-standard behavior while sending WebSocket packets. + * It splits larger (text) packets into chunks of [maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}. + * Only Java Spring brokers seem to support this mode. + * + * WebSockets, by itself, split large (text) packets, + * so it is not needed with a truly compliant STOMP/WebSocket broker. + * Setting it for such a broker will cause large messages to fail. + * + * `false` by default. + * + * Binary frames are never split. + */ + public splitLargeFrames: boolean = false; + + /** + * See [splitLargeFrames]{@link Client#splitLargeFrames}. + * This has no effect if [splitLargeFrames]{@link Client#splitLargeFrames} is `false`. + */ + public maxWebSocketChunkSize: number = 8 * 1024; + + /** + * Usually the + * [type of WebSocket frame]{@link https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/send#Parameters} + * is automatically decided by type of the payload. + * Default is `false`, which should work with all compliant brokers. + * + * Set this flag to force binary frames. + */ + public forceBinaryWSFrames: boolean = false; + + /** + * A bug in ReactNative chops a string on occurrence of a NULL. + * See issue [https://github.com/stomp-js/stompjs/issues/89]{@link https://github.com/stomp-js/stompjs/issues/89}. + * This makes incoming WebSocket messages invalid STOMP packets. + * Setting this flag attempts to reverse the damage by appending a NULL. + * If the broker splits a large message into multiple WebSocket messages, + * this flag will cause data loss and abnormal termination of connection. + * + * This is not an ideal solution, but a stop gap until the underlying issue is fixed at ReactNative library. + */ + public appendMissingNULLonIncoming: boolean = false; + + /** + * Underlying WebSocket instance, READONLY. + */ + get webSocket(): IStompSocket | undefined { + return this._stompHandler?._webSocket; + } + + /** + * Connection headers, important keys - `login`, `passcode`, `host`. + * Though STOMP 1.2 standard marks these keys to be present, check your broker documentation for + * details specific to your broker. + */ + public connectHeaders: StompHeaders; + + /** + * Disconnection headers. + */ + get disconnectHeaders(): StompHeaders { + return this._disconnectHeaders; + } + + set disconnectHeaders(value: StompHeaders) { + this._disconnectHeaders = value; + if (this._stompHandler) { + this._stompHandler.disconnectHeaders = this._disconnectHeaders; + } + } + private _disconnectHeaders: StompHeaders; + + /** + * This function will be called for any unhandled messages. + * It is useful for receiving messages sent to RabbitMQ temporary queues. + * + * It can also get invoked with stray messages while the server is processing + * a request to [Client#unsubscribe]{@link Client#unsubscribe} + * from an endpoint. + * + * The actual {@link IMessage} will be passed as parameter to the callback. + */ + public onUnhandledMessage: messageCallbackType; + + /** + * STOMP brokers can be requested to notify when an operation is actually completed. + * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. See + * [Client#watchForReceipt]{@link Client#watchForReceipt} for examples. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + */ + public onUnhandledReceipt: frameCallbackType; + + /** + * Will be invoked if {@link IFrame} of an unknown type is received from the STOMP broker. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + */ + public onUnhandledFrame: frameCallbackType; + + /** + * `true` if there is an active connection to STOMP Broker + */ + get connected(): boolean { + return !!this._stompHandler && this._stompHandler.connected; + } + + /** + * Callback, invoked on before a connection to the STOMP broker. + * + * You can change options on the client, which will impact the immediate connecting. + * It is valid to call [Client#decativate]{@link Client#deactivate} in this callback. + * + * As of version 5.1, this callback can be + * [async](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function) + * (i.e., it can return a + * [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)). + * In that case, connect will be called only after the Promise is resolved. + * This can be used to reliably fetch credentials, access token etc. from some other service + * in an asynchronous way. + */ + public beforeConnect: () => void | Promise; + + /** + * Callback, invoked on every successful connection to the STOMP broker. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + * Sometimes clients will like to use headers from this frame. + */ + public onConnect: frameCallbackType; + + /** + * Callback, invoked on every successful disconnection from the STOMP broker. It will not be invoked if + * the STOMP broker disconnected due to an error. + * + * The actual Receipt {@link IFrame} acknowledging the DISCONNECT will be passed as parameter to the callback. + * + * The way STOMP protocol is designed, the connection may close/terminate without the client + * receiving the Receipt {@link IFrame} acknowledging the DISCONNECT. + * You might find [Client#onWebSocketClose]{@link Client#onWebSocketClose} more appropriate to watch + * STOMP broker disconnects. + */ + public onDisconnect: frameCallbackType; + + /** + * Callback, invoked on an ERROR frame received from the STOMP Broker. + * A compliant STOMP Broker will close the connection after this type of frame. + * Please check broker specific documentation for exact behavior. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + */ + public onStompError: frameCallbackType; + + /** + * Callback, invoked when underlying WebSocket is closed. + * + * Actual [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent} + * is passed as parameter to the callback. + */ + public onWebSocketClose: closeEventCallbackType; + + /** + * Callback, invoked when underlying WebSocket raises an error. + * + * Actual [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event} + * is passed as parameter to the callback. + */ + public onWebSocketError: wsErrorCallbackType; + + /** + * Set it to log the actual raw communication with the broker. + * When unset, it logs headers of the parsed frames. + * + * Changes effect from the next broker reconnect. + * + * **Caution: this assumes that frames only have valid UTF8 strings.** + */ + public logRawCommunication: boolean; + + /** + * By default, debug messages are discarded. To log to `console` following can be used: + * + * ```javascript + * client.debug = function(str) { + * console.log(str); + * }; + * ``` + * + * Currently this method does not support levels of log. Be aware that the + * output can be quite verbose + * and may contain sensitive information (like passwords, tokens etc.). + */ + public debug: debugFnType; + + /** + * Browsers do not immediately close WebSockets when `.close` is issued. + * This may cause reconnection to take a significantly long time in case + * of some types of failures. + * In case of incoming heartbeat failure, this experimental flag instructs + * the library to discard the socket immediately + * (even before it is actually closed). + */ + public discardWebsocketOnCommFailure: boolean = false; + + /** + * version of STOMP protocol negotiated with the server, READONLY + */ + get connectedVersion(): string | undefined { + return this._stompHandler ? this._stompHandler.connectedVersion : undefined; + } + + private _stompHandler: StompHandler | undefined; + + /** + * if the client is active (connected or going to reconnect) + */ + get active(): boolean { + return this.state === ActivationState.ACTIVE; + } + + /** + * It will be called on state change. + * + * When deactivating, it may go from ACTIVE to INACTIVE without entering DEACTIVATING. + */ + public onChangeState: (state: ActivationState) => void; + + private _changeState(state: ActivationState) { + this.state = state; + this.onChangeState(state); + } + + /** + * Activation state. + * + * It will usually be ACTIVE or INACTIVE. + * When deactivating, it may go from ACTIVE to INACTIVE without entering DEACTIVATING. + */ + public state: ActivationState = ActivationState.INACTIVE; + + private _reconnector: any; + + /** + * Create an instance. + */ + constructor(conf: StompConfig = {}) { + // No op callbacks + const noOp = () => {}; + this.debug = noOp; + this.beforeConnect = noOp; + this.onConnect = noOp; + this.onDisconnect = noOp; + this.onUnhandledMessage = noOp; + this.onUnhandledReceipt = noOp; + this.onUnhandledFrame = noOp; + this.onStompError = noOp; + this.onWebSocketClose = noOp; + this.onWebSocketError = noOp; + this.logRawCommunication = false; + this.onChangeState = noOp; + + // These parameters would typically get proper values before connect is called + this.connectHeaders = {}; + this._disconnectHeaders = {}; + + // Apply configuration + this.configure(conf); + } + + /** + * Update configuration. + */ + public configure(conf: StompConfig): void { + // bulk assign all properties to this + (Object as any).assign(this, conf); + } + + /** + * Initiate the connection with the broker. + * If the connection breaks, as per [Client#reconnectDelay]{@link Client#reconnectDelay}, + * it will keep trying to reconnect. + * + * Call [Client#deactivate]{@link Client#deactivate} to disconnect and stop reconnection attempts. + */ + public activate(): void { + const _activate = () => { + if (this.active) { + this.debug('Already ACTIVE, ignoring request to activate'); + return; + } + + this._changeState(ActivationState.ACTIVE); + + this._connect(); + }; + + // if it is deactivating, wait for it to complete before activating. + if (this.state === ActivationState.DEACTIVATING) { + this.debug('Waiting for deactivation to finish before activating'); + this.deactivate().then(() => { + _activate(); + }); + } else { + _activate(); + } + } + + private async _connect(): Promise { + await this.beforeConnect(); + + if (this._stompHandler) { + this.debug('There is already a stompHandler, skipping the call to connect'); + return; + } + + if (!this.active) { + this.debug( + 'Client has been marked inactive, will not attempt to connect' + ); + return; + } + + // setup connection watcher + if (this.connectionTimeout > 0) { + // clear first + if (this._connectionWatcher) { + clearTimeout(this._connectionWatcher); + } + this._connectionWatcher = setTimeout(() => { + if (this.connected) { + return; + } + // Connection not established, close the underlying socket + // a reconnection will be attempted + this.debug( + `Connection not established in ${this.connectionTimeout}ms, closing socket` + ); + this.forceDisconnect(); + }, this.connectionTimeout); + } + + this.debug('Opening Web Socket...'); + + // Get the actual WebSocket (or a similar object) + const webSocket = this._createWebSocket(); + + this._stompHandler = new StompHandler(this, webSocket, { + debug: this.debug, + stompVersions: this.stompVersions, + connectHeaders: this.connectHeaders, + disconnectHeaders: this._disconnectHeaders, + heartbeatIncoming: this.heartbeatIncoming, + heartbeatOutgoing: this.heartbeatOutgoing, + splitLargeFrames: this.splitLargeFrames, + maxWebSocketChunkSize: this.maxWebSocketChunkSize, + forceBinaryWSFrames: this.forceBinaryWSFrames, + logRawCommunication: this.logRawCommunication, + appendMissingNULLonIncoming: this.appendMissingNULLonIncoming, + discardWebsocketOnCommFailure: this.discardWebsocketOnCommFailure, + + onConnect: frame => { + // Successfully connected, stop the connection watcher + if (this._connectionWatcher) { + clearTimeout(this._connectionWatcher); + this._connectionWatcher = undefined; + } + + if (!this.active) { + this.debug( + 'STOMP got connected while deactivate was issued, will disconnect now' + ); + this._disposeStompHandler(); + return; + } + this.onConnect(frame); + }, + onDisconnect: frame => { + this.onDisconnect(frame); + }, + onStompError: frame => { + this.onStompError(frame); + }, + onWebSocketClose: evt => { + this._stompHandler = undefined; // a new one will be created in case of a reconnect + + if (this.state === ActivationState.DEACTIVATING) { + // Mark deactivation complete + this._changeState(ActivationState.INACTIVE); + } + + // The callback is called before attempting to reconnect, this would allow the client + // to be `deactivated` in the callback. + this.onWebSocketClose(evt); + + if (this.active) { + this._schedule_reconnect(); + } + }, + onWebSocketError: evt => { + this.onWebSocketError(evt); + }, + onUnhandledMessage: message => { + this.onUnhandledMessage(message); + }, + onUnhandledReceipt: frame => { + this.onUnhandledReceipt(frame); + }, + onUnhandledFrame: frame => { + this.onUnhandledFrame(frame); + }, + }); + + this._stompHandler.start(); + } + + private _createWebSocket(): IStompSocket { + let webSocket: IStompSocket; + + if (this.webSocketFactory) { + webSocket = this.webSocketFactory(); + } else if (this.brokerURL) { + webSocket = new WebSocket( + this.brokerURL, + this.stompVersions.protocolVersions() + ); + } else { + throw new Error('Either brokerURL or webSocketFactory must be provided'); + } + webSocket.binaryType = 'arraybuffer'; + return webSocket; + } + + private _schedule_reconnect(): void { + if (this.reconnectDelay > 0) { + this.debug(`STOMP: scheduling reconnection in ${this.reconnectDelay}ms`); + + this._reconnector = setTimeout(() => { + this._connect(); + }, this.reconnectDelay); + } + } + + /** + * Disconnect if connected and stop auto reconnect loop. + * Appropriate callbacks will be invoked if there is an underlying STOMP connection. + * + * This call is async. It will resolve immediately if there is no underlying active websocket, + * otherwise, it will resolve after the underlying websocket is properly disposed of. + * + * It is not an error to invoke this method more than once. + * Each of those would resolve on completion of deactivation. + * + * To reactivate, you can call [Client#activate]{@link Client#activate}. + * + * Experimental: pass `force: true` to immediately discard the underlying connection. + * This mode will skip both the STOMP and the Websocket shutdown sequences. + * In some cases, browsers take a long time in the Websocket shutdown + * if the underlying connection had gone stale. + * Using this mode can speed up. + * When this mode is used, the actual Websocket may linger for a while + * and the broker may not realize that the connection is no longer in use. + * + * It is possible to invoke this method initially without the `force` option + * and subsequently, say after a wait, with the `force` option. + */ + public async deactivate(options: { force?: boolean } = {}): Promise { + const force: boolean = options.force || false; + const needToDispose = this.active; + let retPromise: Promise; + + if (this.state === ActivationState.INACTIVE) { + this.debug(`Already INACTIVE, nothing more to do`); + return Promise.resolve(); + } + + this._changeState(ActivationState.DEACTIVATING); + + // Clear if a reconnection was scheduled + if (this._reconnector) { + clearTimeout(this._reconnector); + this._reconnector = undefined; + } + + if ( + this._stompHandler && + // @ts-ignore - if there is a _stompHandler, there is the webSocket + this.webSocket.readyState !== StompSocketState.CLOSED + ) { + const origOnWebSocketClose = this._stompHandler.onWebSocketClose; + // we need to wait for the underlying websocket to close + retPromise = new Promise((resolve, reject) => { + // @ts-ignore - there is a _stompHandler + this._stompHandler.onWebSocketClose = evt => { + origOnWebSocketClose(evt); + resolve(); + }; + }); + } else { + // indicate that auto reconnect loop should terminate + this._changeState(ActivationState.INACTIVE); + return Promise.resolve(); + } + + if (force) { + this._stompHandler?.discardWebsocket(); + } else if (needToDispose) { + this._disposeStompHandler(); + } + + return retPromise; + } + + /** + * Force disconnect if there is an active connection by directly closing the underlying WebSocket. + * This is different from a normal disconnect where a DISCONNECT sequence is carried out with the broker. + * After forcing disconnect, automatic reconnect will be attempted. + * To stop further reconnects call [Client#deactivate]{@link Client#deactivate} as well. + */ + public forceDisconnect() { + if (this._stompHandler) { + this._stompHandler.forceDisconnect(); + } + } + + private _disposeStompHandler() { + // Dispose STOMP Handler + if (this._stompHandler) { + this._stompHandler.dispose(); + } + } + + /** + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. + * + * STOMP protocol specifies and suggests some headers and also allows broker-specific headers. + * + * `body` must be String. + * You will need to covert the payload to string in case it is not string (e.g. JSON). + * + * To send a binary message body, use `binaryBody` parameter. It should be a + * [Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array). + * Sometimes brokers may not support binary frames out of the box. + * Please check your broker documentation. + * + * `content-length` header is automatically added to the STOMP Frame sent to the broker. + * Set `skipContentLengthHeader` to indicate that `content-length` header should not be added. + * For binary messages, `content-length` header is always added. + * + * Caution: The broker will, most likely, report an error and disconnect + * if the message body has NULL octet(s) and `content-length` header is missing. + * + * ```javascript + * client.publish({destination: "/queue/test", headers: {priority: 9}, body: "Hello, STOMP"}); + * + * // Only destination is mandatory parameter + * client.publish({destination: "/queue/test", body: "Hello, STOMP"}); + * + * // Skip content-length header in the frame to the broker + * client.publish({"/queue/test", body: "Hello, STOMP", skipContentLengthHeader: true}); + * + * var binaryData = generateBinaryData(); // This need to be of type Uint8Array + * // setting content-type header is not mandatory, however a good practice + * client.publish({destination: '/topic/special', binaryBody: binaryData, + * headers: {'content-type': 'application/octet-stream'}}); + * ``` + */ + public publish(params: IPublishParams) { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.publish(params); + } + + private _checkConnection() { + if (!this.connected) { + throw new TypeError('There is no underlying STOMP connection'); + } + } + + /** + * STOMP brokers may carry out operation asynchronously and allow requesting for acknowledgement. + * To request an acknowledgement, a `receipt` header needs to be sent with the actual request. + * The value (say receipt-id) for this header needs to be unique for each use. + * Typically, a sequence, a UUID, a random number or a combination may be used. + * + * A complaint broker will send a RECEIPT frame when an operation has actually been completed. + * The operation needs to be matched based on the value of the receipt-id. + * + * This method allows watching for a receipt and invoking the callback + * when the corresponding receipt has been received. + * + * The actual {@link IFrame} will be passed as parameter to the callback. + * + * Example: + * ```javascript + * // Subscribing with acknowledgement + * let receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * + * client.subscribe(TEST.destination, onMessage, {receipt: receiptId}); + * + * + * // Publishing with acknowledgement + * receiptId = randomText(); + * + * client.watchForReceipt(receiptId, function() { + * // Will be called after server acknowledges + * }); + * client.publish({destination: TEST.destination, headers: {receipt: receiptId}, body: msg}); + * ``` + */ + public watchForReceipt(receiptId: string, callback: frameCallbackType): void { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.watchForReceipt(receiptId, callback); + } + + /** + * Subscribe to a STOMP Broker location. The callback will be invoked for each + * received message with the {@link IMessage} as argument. + * + * Note: The library will generate a unique ID if there is none provided in the headers. + * To use your own ID, pass it using the `headers` argument. + * + * ```javascript + * callback = function(message) { + * // called when the client receives a STOMP message from the server + * if (message.body) { + * alert("got message with body " + message.body) + * } else { + * alert("got empty message"); + * } + * }); + * + * var subscription = client.subscribe("/queue/test", callback); + * + * // Explicit subscription id + * var mySubId = 'my-subscription-id-001'; + * var subscription = client.subscribe(destination, callback, { id: mySubId }); + * ``` + */ + public subscribe( + destination: string, + callback: messageCallbackType, + headers: StompHeaders = {} + ): StompSubscription { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + return this._stompHandler.subscribe(destination, callback, headers); + } + + /** + * It is preferable to unsubscribe from a subscription by calling + * `unsubscribe()` directly on {@link StompSubscription} returned by `client.subscribe()`: + * + * ```javascript + * var subscription = client.subscribe(destination, onmessage); + * // ... + * subscription.unsubscribe(); + * ``` + * + * See: https://stomp.github.com/stomp-specification-1.2.html#UNSUBSCRIBE UNSUBSCRIBE Frame + */ + public unsubscribe(id: string, headers: StompHeaders = {}): void { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.unsubscribe(id, headers); + } + + /** + * Start a transaction, the returned {@link ITransaction} has methods - [commit]{@link ITransaction#commit} + * and [abort]{@link ITransaction#abort}. + * + * `transactionId` is optional, if not passed the library will generate it internally. + */ + public begin(transactionId?: string): ITransaction { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + return this._stompHandler.begin(transactionId); + } + + /** + * Commit a transaction. + * + * It is preferable to commit a transaction by calling [commit]{@link ITransaction#commit} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.commit(); + * ``` + */ + public commit(transactionId: string): void { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.commit(transactionId); + } + + /** + * Abort a transaction. + * It is preferable to abort a transaction by calling [abort]{@link ITransaction#abort} directly on + * {@link ITransaction} returned by [client.begin]{@link Client#begin}. + * + * ```javascript + * var tx = client.begin(txId); + * //... + * tx.abort(); + * ``` + */ + public abort(transactionId: string): void { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.abort(transactionId); + } + + /** + * ACK a message. It is preferable to acknowledge a message by calling [ack]{@link IMessage#ack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // acknowledge it + * message.ack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + public ack( + messageId: string, + subscriptionId: string, + headers: StompHeaders = {} + ): void { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.ack(messageId, subscriptionId, headers); + } + + /** + * NACK a message. It is preferable to acknowledge a message by calling [nack]{@link IMessage#nack} directly + * on the {@link IMessage} handled by a subscription callback: + * + * ```javascript + * var callback = function (message) { + * // process the message + * // an error occurs, nack it + * message.nack(); + * }; + * client.subscribe(destination, callback, {'ack': 'client'}); + * ``` + */ + public nack( + messageId: string, + subscriptionId: string, + headers: StompHeaders = {} + ): void { + this._checkConnection(); + // @ts-ignore - we already checked that there is a _stompHandler, and it is connected + this._stompHandler.nack(messageId, subscriptionId, headers); + } +} Index: node_modules/@stomp/stompjs/src/compatibility/compat-client.ts =================================================================== --- node_modules/@stomp/stompjs/src/compatibility/compat-client.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/compatibility/compat-client.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,269 @@ +import { Client } from '../client.js'; +import { StompHeaders } from '../stomp-headers.js'; +import { frameCallbackType, messageCallbackType } from '../types.js'; +import { HeartbeatInfo } from './heartbeat-info.js'; + +/** + * Available for backward compatibility, please shift to using {@link Client}. + * + * **Deprecated** + * + * Part of `@stomp/stompjs`. + * + * To upgrade, please follow the [Upgrade Guide](https://stomp-js.github.io/guide/stompjs/upgrading-stompjs.html) + */ +export class CompatClient extends Client { + /** + * It is no op now. No longer needed. Large packets work out of the box. + */ + public maxWebSocketFrameSize: number = 16 * 1024; + + /** + * Available for backward compatibility, please shift to using {@link Client} + * and [Client#webSocketFactory]{@link Client#webSocketFactory}. + * + * **Deprecated** + * + * @internal + */ + constructor(webSocketFactory: () => any) { + super(); + this.reconnect_delay = 0; + this.webSocketFactory = webSocketFactory; + // Default from previous version + this.debug = (...message: any[]) => { + console.log(...message); + }; + } + + private _parseConnect(...args: any[]): any { + let closeEventCallback; + let connectCallback; + let errorCallback; + let headers: StompHeaders = {}; + if (args.length < 2) { + throw new Error('Connect requires at least 2 arguments'); + } + if (typeof args[1] === 'function') { + [headers, connectCallback, errorCallback, closeEventCallback] = args; + } else { + switch (args.length) { + case 6: + [ + headers.login, + headers.passcode, + connectCallback, + errorCallback, + closeEventCallback, + headers.host, + ] = args; + break; + default: + [ + headers.login, + headers.passcode, + connectCallback, + errorCallback, + closeEventCallback, + ] = args; + } + } + + return [headers, connectCallback, errorCallback, closeEventCallback]; + } + + /** + * Available for backward compatibility, please shift to using [Client#activate]{@link Client#activate}. + * + * **Deprecated** + * + * The `connect` method accepts different number of arguments and types. See the Overloads list. Use the + * version with headers to pass your broker specific options. + * + * overloads: + * - connect(headers, connectCallback) + * - connect(headers, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback) + * - connect(login, passcode, connectCallback, errorCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback) + * - connect(login, passcode, connectCallback, errorCallback, closeEventCallback, host) + * + * params: + * - headers, see [Client#connectHeaders]{@link Client#connectHeaders} + * - connectCallback, see [Client#onConnect]{@link Client#onConnect} + * - errorCallback, see [Client#onStompError]{@link Client#onStompError} + * - closeEventCallback, see [Client#onWebSocketClose]{@link Client#onWebSocketClose} + * - login [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - passcode [String], [Client#connectHeaders](../classes/Client.html#connectHeaders) + * - host [String], see [Client#connectHeaders](../classes/Client.html#connectHeaders) + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + public connect(...args: any[]): void { + const out = this._parseConnect(...args); + + if (out[0]) { + this.connectHeaders = out[0]; + } + if (out[1]) { + this.onConnect = out[1]; + } + if (out[2]) { + this.onStompError = out[2]; + } + if (out[3]) { + this.onWebSocketClose = out[3]; + } + + super.activate(); + } + + /** + * Available for backward compatibility, please shift to using [Client#deactivate]{@link Client#deactivate}. + * + * **Deprecated** + * + * See: + * [Client#onDisconnect]{@link Client#onDisconnect}, and + * [Client#disconnectHeaders]{@link Client#disconnectHeaders} + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + public disconnect( + disconnectCallback?: any, + headers: StompHeaders = {} + ): void { + if (disconnectCallback) { + this.onDisconnect = disconnectCallback; + } + this.disconnectHeaders = headers; + + super.deactivate(); + } + + /** + * Available for backward compatibility, use [Client#publish]{@link Client#publish}. + * + * Send a message to a named destination. Refer to your STOMP broker documentation for types + * and naming of destinations. The headers will, typically, be available to the subscriber. + * However, there may be special purpose headers corresponding to your STOMP broker. + * + * **Deprecated**, use [Client#publish]{@link Client#publish} + * + * Note: Body must be String. You will need to covert the payload to string in case it is not string (e.g. JSON) + * + * ```javascript + * client.send("/queue/test", {priority: 9}, "Hello, STOMP"); + * + * // If you want to send a message with a body, you must also pass the headers argument. + * client.send("/queue/test", {}, "Hello, STOMP"); + * ``` + * + * To upgrade, please follow the [Upgrade Guide](../additional-documentation/upgrading.html) + */ + public send( + destination: string, + headers: { [key: string]: any } = {}, + body: string = '' + ): void { + headers = (Object as any).assign({}, headers); + + const skipContentLengthHeader = headers['content-length'] === false; + if (skipContentLengthHeader) { + delete headers['content-length']; + } + this.publish({ + destination, + headers: headers as StompHeaders, + body, + skipContentLengthHeader, + }); + } + + /** + * Available for backward compatibility, renamed to [Client#reconnectDelay]{@link Client#reconnectDelay}. + * + * **Deprecated** + */ + set reconnect_delay(value: number) { + this.reconnectDelay = value; + } + + /** + * Available for backward compatibility, renamed to [Client#webSocket]{@link Client#webSocket}. + * + * **Deprecated** + */ + get ws(): any { + return this.webSocket; + } + + /** + * Available for backward compatibility, renamed to [Client#connectedVersion]{@link Client#connectedVersion}. + * + * **Deprecated** + */ + get version() { + return this.connectedVersion; + } + + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + get onreceive(): messageCallbackType { + return this.onUnhandledMessage; + } + + /** + * Available for backward compatibility, renamed to [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * + * **Deprecated** + */ + set onreceive(value: messageCallbackType) { + this.onUnhandledMessage = value; + } + + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * Prefer using [Client#watchForReceipt]{@link Client#watchForReceipt}. + * + * **Deprecated** + */ + get onreceipt(): frameCallbackType { + return this.onUnhandledReceipt; + } + + /** + * Available for backward compatibility, renamed to [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + * + * **Deprecated** + */ + set onreceipt(value: frameCallbackType) { + this.onUnhandledReceipt = value; + } + + private _heartbeatInfo: HeartbeatInfo = new HeartbeatInfo(this); + + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + get heartbeat() { + return this._heartbeatInfo; + } + + /** + * Available for backward compatibility, renamed to [Client#heartbeatIncoming]{@link Client#heartbeatIncoming} + * [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + * + * **Deprecated** + */ + set heartbeat(value: { incoming: number; outgoing: number }) { + this.heartbeatIncoming = value.incoming; + this.heartbeatOutgoing = value.outgoing; + } +} Index: node_modules/@stomp/stompjs/src/compatibility/heartbeat-info.ts =================================================================== --- node_modules/@stomp/stompjs/src/compatibility/heartbeat-info.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/compatibility/heartbeat-info.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,26 @@ +import { CompatClient } from './compat-client.js'; + +/** + * Part of `@stomp/stompjs`. + * + * @internal + */ +export class HeartbeatInfo { + constructor(private client: CompatClient) {} + + get outgoing(): number { + return this.client.heartbeatOutgoing; + } + + set outgoing(value: number) { + this.client.heartbeatOutgoing = value; + } + + get incoming(): number { + return this.client.heartbeatIncoming; + } + + set incoming(value: number) { + this.client.heartbeatIncoming = value; + } +} Index: node_modules/@stomp/stompjs/src/compatibility/stomp.ts =================================================================== --- node_modules/@stomp/stompjs/src/compatibility/stomp.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/compatibility/stomp.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,118 @@ +import { Versions } from '../versions.js'; +import { CompatClient } from './compat-client.js'; +import { IStompSocket } from '../types.js'; + +/** + * @internal + */ +declare const WebSocket: { + prototype: IStompSocket; + new (url: string, protocols?: string | string[]): IStompSocket; +}; + +/** + * STOMP Class, acts like a factory to create {@link Client}. + * + * Part of `@stomp/stompjs`. + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client}. + */ +export class Stomp { + /** + * In case you need to use a non standard class for WebSocket. + * + * For example when using within NodeJS environment: + * + * ```javascript + * StompJs = require('../../esm5/'); + * Stomp = StompJs.Stomp; + * Stomp.WebSocketClass = require('websocket').w3cwebsocket; + * ``` + * + * **Deprecated** + * + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + // tslint:disable-next-line:variable-name + public static WebSocketClass: any = null; + + /** + * This method creates a WebSocket client that is connected to + * the STOMP server located at the url. + * + * ```javascript + * var url = "ws://localhost:61614/stomp"; + * var client = Stomp.client(url); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#brokerURL]{@link Client#brokerURL}. + */ + public static client(url: string, protocols?: string[]): CompatClient { + // This is a hack to allow another implementation than the standard + // HTML5 WebSocket class. + // + // It is possible to use another class by calling + // + // Stomp.WebSocketClass = MozWebSocket + // + // *prior* to call `Stomp.client()`. + // + // This hack is deprecated and `Stomp.over()` method should be used + // instead. + + // See remarks on the function Stomp.over + if (protocols == null) { + protocols = Versions.default.protocolVersions(); + } + const wsFn = () => { + const klass = Stomp.WebSocketClass || WebSocket; + return new klass(url, protocols); + }; + + return new CompatClient(wsFn); + } + + /** + * This method is an alternative to [Stomp#client]{@link Stomp#client} to let the user + * specify the WebSocket to use (either a standard HTML5 WebSocket or + * a similar object). + * + * In order to support reconnection, the function Client._connect should be callable more than once. + * While reconnecting + * a new instance of underlying transport (TCP Socket, WebSocket or SockJS) will be needed. So, this function + * alternatively allows passing a function that should return a new instance of the underlying socket. + * + * ```javascript + * var client = Stomp.over(function(){ + * return new WebSocket('ws://localhost:15674/ws') + * }); + * ``` + * + * **Deprecated** + * + * It will be removed in next major version. Please switch to {@link Client} + * using [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + public static over(ws: any): CompatClient { + let wsFn: () => any; + + if (typeof ws === 'function') { + wsFn = ws; + } else { + console.warn( + 'Stomp.over did not receive a factory, auto reconnect will not work. ' + + 'Please see https://stomp-js.github.io/api-docs/latest/classes/Stomp.html#over' + ); + wsFn = () => ws; + } + + return new CompatClient(wsFn); + } +} Index: node_modules/@stomp/stompjs/src/frame-impl.ts =================================================================== --- node_modules/@stomp/stompjs/src/frame-impl.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/frame-impl.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,254 @@ +import { BYTE } from './byte.js'; +import { IFrame } from './i-frame.js'; +import { StompHeaders } from './stomp-headers.js'; +import { IRawFrameType } from './types.js'; + +/** + * Frame class represents a STOMP frame. + * + * @internal + */ +export class FrameImpl implements IFrame { + /** + * STOMP Command + */ + public command: string; + + /** + * Headers, key value pairs. + */ + public headers: StompHeaders; + + /** + * Is this frame binary (based on whether body/binaryBody was passed when creating this frame). + */ + public isBinaryBody: boolean; + + /** + * body of the frame + */ + get body(): string { + if (!this._body && this.isBinaryBody) { + this._body = new TextDecoder().decode(this._binaryBody); + } + return this._body || ''; + } + private _body: string | undefined; + + /** + * body as Uint8Array + */ + get binaryBody(): Uint8Array { + if (!this._binaryBody && !this.isBinaryBody) { + this._binaryBody = new TextEncoder().encode(this._body); + } + // At this stage it will definitely have a valid value + return this._binaryBody as Uint8Array; + } + private _binaryBody: Uint8Array | undefined; + + private escapeHeaderValues: boolean; + private skipContentLengthHeader: boolean; + + /** + * Frame constructor. `command`, `headers` and `body` are available as properties. + * + * @internal + */ + constructor(params: { + command: string; + headers?: StompHeaders; + body?: string; + binaryBody?: Uint8Array; + escapeHeaderValues?: boolean; + skipContentLengthHeader?: boolean; + }) { + const { + command, + headers, + body, + binaryBody, + escapeHeaderValues, + skipContentLengthHeader, + } = params; + this.command = command; + this.headers = (Object as any).assign({}, headers || {}); + + if (binaryBody) { + this._binaryBody = binaryBody; + this.isBinaryBody = true; + } else { + this._body = body || ''; + this.isBinaryBody = false; + } + this.escapeHeaderValues = escapeHeaderValues || false; + this.skipContentLengthHeader = skipContentLengthHeader || false; + } + + /** + * deserialize a STOMP Frame from raw data. + * + * @internal + */ + public static fromRawFrame( + rawFrame: IRawFrameType, + escapeHeaderValues: boolean + ): FrameImpl { + const headers: StompHeaders = {}; + const trim = (str: string): string => str.replace(/^\s+|\s+$/g, ''); + + // In case of repeated headers, as per standards, first value need to be used + for (const header of rawFrame.headers.reverse()) { + const idx = header.indexOf(':'); + + const key = trim(header[0]); + let value = trim(header[1]); + + if ( + escapeHeaderValues && + rawFrame.command !== 'CONNECT' && + rawFrame.command !== 'CONNECTED' + ) { + value = FrameImpl.hdrValueUnEscape(value); + } + + headers[key] = value; + } + + return new FrameImpl({ + command: rawFrame.command as string, + headers, + binaryBody: rawFrame.binaryBody, + escapeHeaderValues, + }); + } + + /** + * @internal + */ + public toString(): string { + return this.serializeCmdAndHeaders(); + } + + /** + * serialize this Frame in a format suitable to be passed to WebSocket. + * If the body is string the output will be string. + * If the body is binary (i.e. of type Unit8Array) it will be serialized to ArrayBuffer. + * + * @internal + */ + public serialize(): string | ArrayBuffer { + const cmdAndHeaders = this.serializeCmdAndHeaders(); + + if (this.isBinaryBody) { + return FrameImpl.toUnit8Array( + cmdAndHeaders, + this._binaryBody as Uint8Array + ).buffer; + } else { + return cmdAndHeaders + this._body + BYTE.NULL; + } + } + + private serializeCmdAndHeaders(): string { + const lines = [this.command]; + if (this.skipContentLengthHeader) { + delete this.headers['content-length']; + } + + for (const name of Object.keys(this.headers || {})) { + const value = this.headers[name]; + if ( + this.escapeHeaderValues && + this.command !== 'CONNECT' && + this.command !== 'CONNECTED' + ) { + lines.push(`${name}:${FrameImpl.hdrValueEscape(`${value}`)}`); + } else { + lines.push(`${name}:${value}`); + } + } + if ( + this.isBinaryBody || + (!this.isBodyEmpty() && !this.skipContentLengthHeader) + ) { + lines.push(`content-length:${this.bodyLength()}`); + } + return lines.join(BYTE.LF) + BYTE.LF + BYTE.LF; + } + + private isBodyEmpty(): boolean { + return this.bodyLength() === 0; + } + + private bodyLength(): number { + const binaryBody = this.binaryBody; + return binaryBody ? binaryBody.length : 0; + } + + /** + * Compute the size of a UTF-8 string by counting its number of bytes + * (and not the number of characters composing the string) + */ + private static sizeOfUTF8(s: string): number { + return s ? new TextEncoder().encode(s).length : 0; + } + + private static toUnit8Array( + cmdAndHeaders: string, + binaryBody: Uint8Array + ): Uint8Array { + const uint8CmdAndHeaders = new TextEncoder().encode(cmdAndHeaders); + const nullTerminator = new Uint8Array([0]); + const uint8Frame = new Uint8Array( + uint8CmdAndHeaders.length + binaryBody.length + nullTerminator.length + ); + + uint8Frame.set(uint8CmdAndHeaders); + uint8Frame.set(binaryBody, uint8CmdAndHeaders.length); + uint8Frame.set( + nullTerminator, + uint8CmdAndHeaders.length + binaryBody.length + ); + + return uint8Frame; + } + /** + * Serialize a STOMP frame as per STOMP standards, suitable to be sent to the STOMP broker. + * + * @internal + */ + public static marshall(params: { + command: string; + headers?: StompHeaders; + body?: string; + binaryBody?: Uint8Array; + escapeHeaderValues?: boolean; + skipContentLengthHeader?: boolean; + }) { + const frame = new FrameImpl(params); + return frame.serialize(); + } + + /** + * Escape header values + */ + private static hdrValueEscape(str: string): string { + return str + .replace(/\\/g, '\\\\') + .replace(/\r/g, '\\r') + .replace(/\n/g, '\\n') + .replace(/:/g, '\\c'); + } + + /** + * UnEscape header values + */ + private static hdrValueUnEscape(str: string): string { + return str + .replace(/\\r/g, '\r') + .replace(/\\n/g, '\n') + .replace(/\\c/g, ':') + .replace(/\\\\/g, '\\'); + } +} Index: node_modules/@stomp/stompjs/src/i-frame.ts =================================================================== --- node_modules/@stomp/stompjs/src/i-frame.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/i-frame.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,41 @@ +import { StompHeaders } from './stomp-headers.js'; + +/** + * It represents a STOMP frame. Many of the callbacks pass an IFrame received from + * the STOMP broker. For advanced usage you might need to access [headers]{@link IFrame#headers}. + * + * Part of `@stomp/stompjs`. + * + * {@link IMessage} is an extended IFrame. + */ +export interface IFrame { + /** + * STOMP Command + */ + command: string; + + /** + * Headers, key value pairs. + */ + headers: StompHeaders; + + /** + * Is this frame binary (based on whether body/binaryBody was passed when creating this frame). + */ + isBinaryBody: boolean; + + /** + * body of the frame as string + */ + readonly body: string; + + /** + * body as Uint8Array + */ + readonly binaryBody: Uint8Array; +} + +/** + * Alias for {@link IFrame} + */ +export type Frame = IFrame; Index: node_modules/@stomp/stompjs/src/i-message.ts =================================================================== --- node_modules/@stomp/stompjs/src/i-message.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/i-message.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,35 @@ +import { IFrame } from './i-frame.js'; +import { StompHeaders } from './stomp-headers.js'; + +/** + * Instance of Message will be passed to [subscription callback]{@link Client#subscribe} + * and [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + * Since it is an extended {@link IFrame}, you can access [headers]{@link IFrame#headers} + * and [body]{@link IFrame#body} as properties. + * + * Part of `@stomp/stompjs`. + * + * See [Client#subscribe]{@link Client#subscribe} for example. + */ +export interface IMessage extends IFrame { + /** + * When subscribing with manual acknowledgement, call this method on the message to ACK the message. + * + * See [Client#ack]{@link Client#ack} for an example. + */ + ack: (headers?: StompHeaders) => void; + + /** + * When subscribing with manual acknowledgement, call this method on the message to NACK the message. + * + * See [Client#nack]{@link Client#nack} for an example. + */ + nack: (headers?: StompHeaders) => void; +} + +/** + * Aliased to {@link IMessage}. + * + * Part of `@stomp/stompjs`. + */ +export type Message = IMessage; Index: node_modules/@stomp/stompjs/src/i-transaction.ts =================================================================== --- node_modules/@stomp/stompjs/src/i-transaction.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/i-transaction.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,23 @@ +/** + * A Transaction is created by calling [Client#begin]{@link Client#begin} + * + * Part of `@stomp/stompjs`. + * + * TODO: Example and caveat + */ +export interface ITransaction { + /** + * You will need to access this to send, ack, or nack within this transaction. + */ + id: string; + + /** + * Commit this transaction. See [Client#commit]{@link Client#commit} for an example. + */ + commit: () => void; + + /** + * Abort this transaction. See [Client#abort]{@link Client#abort} for an example. + */ + abort: () => void; +} Index: node_modules/@stomp/stompjs/src/index.ts =================================================================== --- node_modules/@stomp/stompjs/src/index.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/index.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,15 @@ +export * from './client.js'; +export * from './frame-impl.js'; +export * from './i-frame.js'; +export * from './i-message.js'; +export * from './parser.js'; +export * from './stomp-config.js'; +export * from './stomp-headers.js'; +export * from './stomp-subscription.js'; +export * from './i-transaction.js'; +export * from './types.js'; +export * from './versions.js'; + +// Compatibility code +export * from './compatibility/compat-client.js'; +export * from './compatibility/stomp.js'; Index: node_modules/@stomp/stompjs/src/parser.ts =================================================================== --- node_modules/@stomp/stompjs/src/parser.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/parser.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,267 @@ +import { IRawFrameType } from './types.js'; + +/** + * @internal + */ +const NULL = 0; +/** + * @internal + */ +const LF = 10; +/** + * @internal + */ +const CR = 13; +/** + * @internal + */ +const COLON = 58; + +/** + * This is an evented, rec descent parser. + * A stream of Octets can be passed and whenever it recognizes + * a complete Frame or an incoming ping it will invoke the registered callbacks. + * + * All incoming Octets are fed into _onByte function. + * Depending on current state the _onByte function keeps changing. + * Depending on the state it keeps accumulating into _token and _results. + * State is indicated by current value of _onByte, all states are named as _collect. + * + * STOMP standards https://stomp.github.io/stomp-specification-1.2.html + * imply that all lengths are considered in bytes (instead of string lengths). + * So, before actual parsing, if the incoming data is String it is converted to Octets. + * This allows faithful implementation of the protocol and allows NULL Octets to be present in the body. + * + * There is no peek function on the incoming data. + * When a state change occurs based on an Octet without consuming the Octet, + * the Octet, after state change, is fed again (_reinjectByte). + * This became possible as the state change can be determined by inspecting just one Octet. + * + * There are two modes to collect the body, if content-length header is there then it by counting Octets + * otherwise it is determined by NULL terminator. + * + * Following the standards, the command and headers are converted to Strings + * and the body is returned as Octets. + * Headers are returned as an array and not as Hash - to allow multiple occurrence of an header. + * + * This parser does not use Regular Expressions as that can only operate on Strings. + * + * It handles if multiple STOMP frames are given as one chunk, a frame is split into multiple chunks, or + * any combination there of. The parser remembers its state (any partial frame) and continues when a new chunk + * is pushed. + * + * Typically the higher level function will convert headers to Hash, handle unescaping of header values + * (which is protocol version specific), and convert body to text. + * + * Check the parser.spec.js to understand cases that this parser is supposed to handle. + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export class Parser { + private readonly _encoder = new TextEncoder(); + private readonly _decoder = new TextDecoder(); + + // @ts-ignore - it always has a value + private _results: IRawFrameType; + + private _token: number[] = []; + private _headerKey: string | undefined; + private _bodyBytesRemaining: number | undefined; + + // @ts-ignore - it always has a value + private _onByte: (byte: number) => void; + + public constructor( + public onFrame: (rawFrame: IRawFrameType) => void, + public onIncomingPing: () => void + ) { + this._initState(); + } + + public parseChunk( + segment: string | ArrayBuffer, + appendMissingNULLonIncoming: boolean = false + ) { + let chunk: Uint8Array; + + if (typeof segment === 'string') { + chunk = this._encoder.encode(segment); + } else { + chunk = new Uint8Array(segment); + } + + // See https://github.com/stomp-js/stompjs/issues/89 + // Remove when underlying issue is fixed. + // + // Send a NULL byte, if the last byte of a Text frame was not NULL.F + if (appendMissingNULLonIncoming && chunk[chunk.length - 1] !== 0) { + const chunkWithNull = new Uint8Array(chunk.length + 1); + chunkWithNull.set(chunk, 0); + chunkWithNull[chunk.length] = 0; + chunk = chunkWithNull; + } + + // tslint:disable-next-line:prefer-for-of + for (let i = 0; i < chunk.length; i++) { + const byte = chunk[i]; + this._onByte(byte); + } + } + + // The following implements a simple Rec Descent Parser. + // The grammar is simple and just one byte tells what should be the next state + + private _collectFrame(byte: number): void { + if (byte === NULL) { + // Ignore + return; + } + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + // Incoming Ping + this.onIncomingPing(); + return; + } + + this._onByte = this._collectCommand; + this._reinjectByte(byte); + } + + private _collectCommand(byte: number): void { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._results.command = this._consumeTokenAsUTF8(); + this._onByte = this._collectHeaders; + return; + } + + this._consumeByte(byte); + } + + private _collectHeaders(byte: number): void { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._setupCollectBody(); + return; + } + this._onByte = this._collectHeaderKey; + this._reinjectByte(byte); + } + + private _reinjectByte(byte: number) { + this._onByte(byte); + } + + private _collectHeaderKey(byte: number): void { + if (byte === COLON) { + this._headerKey = this._consumeTokenAsUTF8(); + this._onByte = this._collectHeaderValue; + return; + } + this._consumeByte(byte); + } + + private _collectHeaderValue(byte: number): void { + if (byte === CR) { + // Ignore CR + return; + } + if (byte === LF) { + this._results.headers.push([ + this._headerKey as string, + this._consumeTokenAsUTF8(), + ]); + this._headerKey = undefined; + this._onByte = this._collectHeaders; + return; + } + this._consumeByte(byte); + } + + private _setupCollectBody() { + const contentLengthHeader = this._results.headers.filter( + (header: [string, string]) => { + return header[0] === 'content-length'; + } + )[0]; + + if (contentLengthHeader) { + this._bodyBytesRemaining = parseInt(contentLengthHeader[1], 10); + this._onByte = this._collectBodyFixedSize; + } else { + this._onByte = this._collectBodyNullTerminated; + } + } + + private _collectBodyNullTerminated(byte: number): void { + if (byte === NULL) { + this._retrievedBody(); + return; + } + this._consumeByte(byte); + } + + private _collectBodyFixedSize(byte: number): void { + // It is post decrement, so that we discard the trailing NULL octet + if ((this._bodyBytesRemaining as number)-- === 0) { + this._retrievedBody(); + return; + } + this._consumeByte(byte); + } + + private _retrievedBody() { + this._results.binaryBody = this._consumeTokenAsRaw(); + + try { + this.onFrame(this._results); + } catch (e) { + console.log( + `Ignoring an exception thrown by a frame handler. Original exception: `, + e + ); + } + + this._initState(); + } + + // Rec Descent Parser helpers + + private _consumeByte(byte: number) { + this._token.push(byte); + } + + private _consumeTokenAsUTF8() { + return this._decoder.decode(this._consumeTokenAsRaw()); + } + + private _consumeTokenAsRaw() { + const rawResult = new Uint8Array(this._token); + this._token = []; + return rawResult; + } + + private _initState() { + this._results = { + command: undefined, + headers: [], + binaryBody: undefined, + }; + + this._token = []; + this._headerKey = undefined; + + this._onByte = this._collectFrame; + } +} Index: node_modules/@stomp/stompjs/src/stomp-config.ts =================================================================== --- node_modules/@stomp/stompjs/src/stomp-config.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/stomp-config.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,149 @@ +import { StompHeaders } from './stomp-headers.js'; +import { + ActivationState, + closeEventCallbackType, + debugFnType, + frameCallbackType, + messageCallbackType, + wsErrorCallbackType, +} from './types.js'; +import { Versions } from './versions.js'; + +/** + * Configuration options for STOMP Client, each key corresponds to + * field by the same name in {@link Client}. This can be passed to + * the constructor of {@link Client} or to [Client#configure]{@link Client#configure}. + * + * Part of `@stomp/stompjs`. + */ +export class StompConfig { + /** + * See [Client#brokerURL]{@link Client#brokerURL}. + */ + public brokerURL?: string; + + /** + * See [Client#stompVersions]{@link Client#stompVersions}. + */ + public stompVersions?: Versions; + + /** + * See [Client#webSocketFactory]{@link Client#webSocketFactory}. + */ + public webSocketFactory?: () => any; + + /** + * See [Client#connectionTimeout]{@link Client#connectionTimeout}. + */ + public connectionTimeout?: number; + + /** + * See [Client#reconnectDelay]{@link Client#reconnectDelay}. + */ + public reconnectDelay?: number; + + /** + * See [Client#heartbeatIncoming]{@link Client#heartbeatIncoming}. + */ + public heartbeatIncoming?: number; + + /** + * See [Client#heartbeatOutgoing]{@link Client#heartbeatOutgoing}. + */ + public heartbeatOutgoing?: number; + + /** + * See [Client#splitLargeFrames]{@link Client#splitLargeFrames}. + */ + public splitLargeFrames?: boolean; + + /** + * See [Client#forceBinaryWSFrames]{@link Client#forceBinaryWSFrames}. + */ + public forceBinaryWSFrames?: boolean; + + /** + * See [Client#appendMissingNULLonIncoming]{@link Client#appendMissingNULLonIncoming}. + */ + public appendMissingNULLonIncoming?: boolean; + + /** + * See [Client#maxWebSocketChunkSize]{@link Client#maxWebSocketChunkSize}. + */ + public maxWebSocketChunkSize?: number; + + /** + * See [Client#connectHeaders]{@link Client#connectHeaders}. + */ + public connectHeaders?: StompHeaders; + + /** + * See [Client#disconnectHeaders]{@link Client#disconnectHeaders}. + */ + public disconnectHeaders?: StompHeaders; + + /** + * See [Client#onUnhandledMessage]{@link Client#onUnhandledMessage}. + */ + public onUnhandledMessage?: messageCallbackType; + + /** + * See [Client#onUnhandledReceipt]{@link Client#onUnhandledReceipt}. + */ + public onUnhandledReceipt?: frameCallbackType; + + /** + * See [Client#onUnhandledFrame]{@link Client#onUnhandledFrame}. + */ + public onUnhandledFrame?: frameCallbackType; + + /** + * See [Client#beforeConnect]{@link Client#beforeConnect}. + */ + public beforeConnect?: () => void | Promise; + + /** + * See [Client#onConnect]{@link Client#onConnect}. + */ + public onConnect?: frameCallbackType; + + /** + * See [Client#onDisconnect]{@link Client#onDisconnect}. + */ + public onDisconnect?: frameCallbackType; + + /** + * See [Client#onStompError]{@link Client#onStompError}. + */ + public onStompError?: frameCallbackType; + + /** + * See [Client#onWebSocketClose]{@link Client#onWebSocketClose}. + */ + public onWebSocketClose?: closeEventCallbackType; + + /** + * See [Client#onWebSocketError]{@link Client#onWebSocketError}. + */ + public onWebSocketError?: wsErrorCallbackType; + + /** + * See [Client#logRawCommunication]{@link Client#logRawCommunication}. + */ + public logRawCommunication?: boolean; + + /** + * See [Client#debug]{@link Client#debug}. + */ + public debug?: debugFnType; + + /** + * See [Client#discardWebsocketOnCommFailure]{@link Client#discardWebsocketOnCommFailure}. + */ + public discardWebsocketOnCommFailure?: boolean; + + /** + * See [Client#onChangeState]{@link Client#onChangeState}. + */ + public onChangeState?: (state: ActivationState) => void; +} Index: node_modules/@stomp/stompjs/src/stomp-handler.ts =================================================================== --- node_modules/@stomp/stompjs/src/stomp-handler.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/stomp-handler.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,555 @@ +import { BYTE } from './byte.js'; +import { Client } from './client.js'; +import { FrameImpl } from './frame-impl.js'; +import { IMessage } from './i-message.js'; +import { ITransaction } from './i-transaction.js'; +import { Parser } from './parser.js'; +import { StompHeaders } from './stomp-headers.js'; +import { StompSubscription } from './stomp-subscription.js'; +import { + closeEventCallbackType, + debugFnType, + frameCallbackType, + IPublishParams, + IStompSocket, + IStompSocketMessageEvent, + IStomptHandlerConfig, + messageCallbackType, + StompSocketState, + wsErrorCallbackType, +} from './types.js'; +import { Versions } from './versions.js'; +import { augmentWebsocket } from './augment-websocket.js'; + +/** + * The STOMP protocol handler + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export class StompHandler { + public debug: debugFnType; + + public stompVersions: Versions; + + public connectHeaders: StompHeaders; + + public disconnectHeaders: StompHeaders; + + public heartbeatIncoming: number; + + public heartbeatOutgoing: number; + + public onUnhandledMessage: messageCallbackType; + + public onUnhandledReceipt: frameCallbackType; + + public onUnhandledFrame: frameCallbackType; + + public onConnect: frameCallbackType; + + public onDisconnect: frameCallbackType; + + public onStompError: frameCallbackType; + + public onWebSocketClose: closeEventCallbackType; + + public onWebSocketError: wsErrorCallbackType; + + public logRawCommunication: boolean; + + public splitLargeFrames: boolean; + + public maxWebSocketChunkSize: number; + + public forceBinaryWSFrames: boolean; + + public appendMissingNULLonIncoming: boolean; + + public discardWebsocketOnCommFailure: boolean; + + get connectedVersion(): string | undefined { + return this._connectedVersion; + } + private _connectedVersion: string | undefined; + + get connected(): boolean { + return this._connected; + } + + private _connected: boolean = false; + + private readonly _subscriptions: { [key: string]: messageCallbackType }; + private readonly _receiptWatchers: { [key: string]: frameCallbackType }; + private _partialData: string; + private _escapeHeaderValues: boolean; + private _counter: number; + private _pinger: any; + private _ponger: any; + private _lastServerActivityTS: number; + + constructor( + private _client: Client, + public _webSocket: IStompSocket, + config: IStomptHandlerConfig + ) { + // used to index subscribers + this._counter = 0; + + // subscription callbacks indexed by subscriber's ID + this._subscriptions = {}; + + // receipt-watchers indexed by receipts-ids + this._receiptWatchers = {}; + + this._partialData = ''; + + this._escapeHeaderValues = false; + + this._lastServerActivityTS = Date.now(); + + this.debug = config.debug; + this.stompVersions = config.stompVersions; + this.connectHeaders = config.connectHeaders; + this.disconnectHeaders = config.disconnectHeaders; + this.heartbeatIncoming = config.heartbeatIncoming; + this.heartbeatOutgoing = config.heartbeatOutgoing; + this.splitLargeFrames = config.splitLargeFrames; + this.maxWebSocketChunkSize = config.maxWebSocketChunkSize; + this.forceBinaryWSFrames = config.forceBinaryWSFrames; + this.logRawCommunication = config.logRawCommunication; + this.appendMissingNULLonIncoming = config.appendMissingNULLonIncoming; + this.discardWebsocketOnCommFailure = config.discardWebsocketOnCommFailure; + this.onConnect = config.onConnect; + this.onDisconnect = config.onDisconnect; + this.onStompError = config.onStompError; + this.onWebSocketClose = config.onWebSocketClose; + this.onWebSocketError = config.onWebSocketError; + this.onUnhandledMessage = config.onUnhandledMessage; + this.onUnhandledReceipt = config.onUnhandledReceipt; + this.onUnhandledFrame = config.onUnhandledFrame; + } + + public start(): void { + const parser = new Parser( + // On Frame + rawFrame => { + const frame = FrameImpl.fromRawFrame( + rawFrame, + this._escapeHeaderValues + ); + + // if this.logRawCommunication is set, the rawChunk is logged at this._webSocket.onmessage + if (!this.logRawCommunication) { + this.debug(`<<< ${frame}`); + } + + const serverFrameHandler = + this._serverFrameHandlers[frame.command] || this.onUnhandledFrame; + serverFrameHandler(frame); + }, + // On Incoming Ping + () => { + this.debug('<<< PONG'); + } + ); + + this._webSocket.onmessage = (evt: IStompSocketMessageEvent) => { + this.debug('Received data'); + this._lastServerActivityTS = Date.now(); + + if (this.logRawCommunication) { + const rawChunkAsString = + evt.data instanceof ArrayBuffer + ? new TextDecoder().decode(evt.data) + : evt.data; + this.debug(`<<< ${rawChunkAsString}`); + } + + parser.parseChunk( + evt.data as string | ArrayBuffer, + this.appendMissingNULLonIncoming + ); + }; + + this._webSocket.onclose = (closeEvent): void => { + this.debug(`Connection closed to ${this._webSocket.url}`); + this._cleanUp(); + this.onWebSocketClose(closeEvent); + }; + + this._webSocket.onerror = (errorEvent): void => { + this.onWebSocketError(errorEvent); + }; + + this._webSocket.onopen = () => { + // Clone before updating + const connectHeaders = (Object as any).assign({}, this.connectHeaders); + + this.debug('Web Socket Opened...'); + connectHeaders['accept-version'] = this.stompVersions.supportedVersions(); + connectHeaders['heart-beat'] = [ + this.heartbeatOutgoing, + this.heartbeatIncoming, + ].join(','); + this._transmit({ command: 'CONNECT', headers: connectHeaders }); + }; + } + + private readonly _serverFrameHandlers: { + [key: string]: frameCallbackType; + } = { + // [CONNECTED Frame](https://stomp.github.com/stomp-specification-1.2.html#CONNECTED_Frame) + CONNECTED: frame => { + this.debug(`connected to server ${frame.headers.server}`); + this._connected = true; + this._connectedVersion = frame.headers.version; + // STOMP version 1.2 needs header values to be escaped + if (this._connectedVersion === Versions.V1_2) { + this._escapeHeaderValues = true; + } + + this._setupHeartbeat(frame.headers); + this.onConnect(frame); + }, + + // [MESSAGE Frame](https://stomp.github.com/stomp-specification-1.2.html#MESSAGE) + MESSAGE: frame => { + // the callback is registered when the client calls + // `subscribe()`. + // If there is no registered subscription for the received message, + // the default `onUnhandledMessage` callback is used that the client can set. + // This is useful for subscriptions that are automatically created + // on the browser side (e.g. [RabbitMQ's temporary + // queues](https://www.rabbitmq.com/stomp.html)). + const subscription = frame.headers.subscription; + const onReceive = + this._subscriptions[subscription] || this.onUnhandledMessage; + + // bless the frame to be a Message + const message = frame as IMessage; + + const client = this; + const messageId = + this._connectedVersion === Versions.V1_2 + ? message.headers.ack + : message.headers['message-id']; + + // add `ack()` and `nack()` methods directly to the returned frame + // so that a simple call to `message.ack()` can acknowledge the message. + message.ack = (headers: StompHeaders = {}): void => { + return client.ack(messageId, subscription, headers); + }; + message.nack = (headers: StompHeaders = {}): void => { + return client.nack(messageId, subscription, headers); + }; + onReceive(message); + }, + + // [RECEIPT Frame](https://stomp.github.com/stomp-specification-1.2.html#RECEIPT) + RECEIPT: frame => { + const callback = this._receiptWatchers[frame.headers['receipt-id']]; + if (callback) { + callback(frame); + // Server will acknowledge only once, remove the callback + delete this._receiptWatchers[frame.headers['receipt-id']]; + } else { + this.onUnhandledReceipt(frame); + } + }, + + // [ERROR Frame](https://stomp.github.com/stomp-specification-1.2.html#ERROR) + ERROR: frame => { + this.onStompError(frame); + }, + }; + + private _setupHeartbeat(headers: StompHeaders): void { + if ( + headers.version !== Versions.V1_1 && + headers.version !== Versions.V1_2 + ) { + return; + } + + // It is valid for the server to not send this header + // https://stomp.github.io/stomp-specification-1.2.html#Heart-beating + if (!headers['heart-beat']) { + return; + } + + // heart-beat header received from the server looks like: + // + // heart-beat: sx, sy + const [serverOutgoing, serverIncoming] = headers['heart-beat'] + .split(',') + .map((v: string) => parseInt(v, 10)); + + if (this.heartbeatOutgoing !== 0 && serverIncoming !== 0) { + const ttl: number = Math.max(this.heartbeatOutgoing, serverIncoming); + this.debug(`send PING every ${ttl}ms`); + this._pinger = setInterval(() => { + if (this._webSocket.readyState === StompSocketState.OPEN) { + this._webSocket.send(BYTE.LF); + this.debug('>>> PING'); + } + }, ttl); + } + + if (this.heartbeatIncoming !== 0 && serverOutgoing !== 0) { + const ttl: number = Math.max(this.heartbeatIncoming, serverOutgoing); + this.debug(`check PONG every ${ttl}ms`); + this._ponger = setInterval(() => { + const delta = Date.now() - this._lastServerActivityTS; + // We wait twice the TTL to be flexible on window's setInterval calls + if (delta > ttl * 2) { + this.debug(`did not receive server activity for the last ${delta}ms`); + this._closeOrDiscardWebsocket(); + } + }, ttl); + } + } + + private _closeOrDiscardWebsocket() { + if (this.discardWebsocketOnCommFailure) { + this.debug( + 'Discarding websocket, the underlying socket may linger for a while' + ); + this.discardWebsocket(); + } else { + this.debug('Issuing close on the websocket'); + this._closeWebsocket(); + } + } + + public forceDisconnect() { + if (this._webSocket) { + if ( + this._webSocket.readyState === StompSocketState.CONNECTING || + this._webSocket.readyState === StompSocketState.OPEN + ) { + this._closeOrDiscardWebsocket(); + } + } + } + + public _closeWebsocket() { + this._webSocket.onmessage = () => {}; // ignore messages + this._webSocket.close(); + } + + public discardWebsocket() { + if (typeof this._webSocket.terminate !== 'function') { + augmentWebsocket(this._webSocket, (msg: string) => this.debug(msg)); + } + + // @ts-ignore - this method will be there at this stage + this._webSocket.terminate(); + } + + private _transmit(params: { + command: string; + headers?: StompHeaders; + body?: string; + binaryBody?: Uint8Array; + skipContentLengthHeader?: boolean; + }): void { + const { command, headers, body, binaryBody, skipContentLengthHeader } = + params; + const frame = new FrameImpl({ + command, + headers, + body, + binaryBody, + escapeHeaderValues: this._escapeHeaderValues, + skipContentLengthHeader, + }); + + let rawChunk = frame.serialize(); + + if (this.logRawCommunication) { + this.debug(`>>> ${rawChunk}`); + } else { + this.debug(`>>> ${frame}`); + } + + if (this.forceBinaryWSFrames && typeof rawChunk === 'string') { + rawChunk = new TextEncoder().encode(rawChunk); + } + + if (typeof rawChunk !== 'string' || !this.splitLargeFrames) { + this._webSocket.send(rawChunk); + } else { + let out = rawChunk as string; + while (out.length > 0) { + const chunk = out.substring(0, this.maxWebSocketChunkSize); + out = out.substring(this.maxWebSocketChunkSize); + this._webSocket.send(chunk); + this.debug(`chunk sent = ${chunk.length}, remaining = ${out.length}`); + } + } + } + + public dispose(): void { + if (this.connected) { + try { + // clone before updating + const disconnectHeaders = (Object as any).assign( + {}, + this.disconnectHeaders + ); + + if (!disconnectHeaders.receipt) { + disconnectHeaders.receipt = `close-${this._counter++}`; + } + this.watchForReceipt(disconnectHeaders.receipt, frame => { + this._closeWebsocket(); + this._cleanUp(); + this.onDisconnect(frame); + }); + this._transmit({ command: 'DISCONNECT', headers: disconnectHeaders }); + } catch (error) { + this.debug(`Ignoring error during disconnect ${error}`); + } + } else { + if ( + this._webSocket.readyState === StompSocketState.CONNECTING || + this._webSocket.readyState === StompSocketState.OPEN + ) { + this._closeWebsocket(); + } + } + } + + private _cleanUp() { + this._connected = false; + + if (this._pinger) { + clearInterval(this._pinger); + this._pinger = undefined; + } + if (this._ponger) { + clearInterval(this._ponger); + this._ponger = undefined; + } + } + + public publish(params: IPublishParams): void { + const { destination, headers, body, binaryBody, skipContentLengthHeader } = + params; + const hdrs: StompHeaders = (Object as any).assign({ destination }, headers); + this._transmit({ + command: 'SEND', + headers: hdrs, + body, + binaryBody, + skipContentLengthHeader, + }); + } + + public watchForReceipt(receiptId: string, callback: frameCallbackType): void { + this._receiptWatchers[receiptId] = callback; + } + + public subscribe( + destination: string, + callback: messageCallbackType, + headers: StompHeaders = {} + ): StompSubscription { + headers = (Object as any).assign({}, headers); + + if (!headers.id) { + headers.id = `sub-${this._counter++}`; + } + headers.destination = destination; + this._subscriptions[headers.id] = callback; + this._transmit({ command: 'SUBSCRIBE', headers }); + const client = this; + return { + id: headers.id, + + unsubscribe(hdrs) { + return client.unsubscribe(headers.id, hdrs); + }, + }; + } + + public unsubscribe(id: string, headers: StompHeaders = {}): void { + headers = (Object as any).assign({}, headers); + + delete this._subscriptions[id]; + headers.id = id; + this._transmit({ command: 'UNSUBSCRIBE', headers }); + } + + public begin(transactionId: string): ITransaction { + const txId = transactionId || `tx-${this._counter++}`; + this._transmit({ + command: 'BEGIN', + headers: { + transaction: txId, + }, + }); + const client = this; + return { + id: txId, + commit(): void { + client.commit(txId); + }, + abort(): void { + client.abort(txId); + }, + }; + } + + public commit(transactionId: string): void { + this._transmit({ + command: 'COMMIT', + headers: { + transaction: transactionId, + }, + }); + } + + public abort(transactionId: string): void { + this._transmit({ + command: 'ABORT', + headers: { + transaction: transactionId, + }, + }); + } + + public ack( + messageId: string, + subscriptionId: string, + headers: StompHeaders = {} + ): void { + headers = (Object as any).assign({}, headers); + + if (this._connectedVersion === Versions.V1_2) { + headers.id = messageId; + } else { + headers['message-id'] = messageId; + } + headers.subscription = subscriptionId; + this._transmit({ command: 'ACK', headers }); + } + + public nack( + messageId: string, + subscriptionId: string, + headers: StompHeaders = {} + ): void { + headers = (Object as any).assign({}, headers); + + if (this._connectedVersion === Versions.V1_2) { + headers.id = messageId; + } else { + headers['message-id'] = messageId; + } + headers.subscription = subscriptionId; + return this._transmit({ command: 'NACK', headers }); + } +} Index: node_modules/@stomp/stompjs/src/stomp-headers.ts =================================================================== --- node_modules/@stomp/stompjs/src/stomp-headers.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/stomp-headers.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,12 @@ +/** + * STOMP headers. Many functions calls will accept headers as parameters. + * The headers sent by Broker will be available as [IFrame#headers]{@link IFrame#headers}. + * + * `key` and `value` must be valid strings. + * In addition, `key` must not contain `CR`, `LF`, or `:`. + * + * Part of `@stomp/stompjs`. + */ +export class StompHeaders { + [key: string]: string; +} Index: node_modules/@stomp/stompjs/src/stomp-subscription.ts =================================================================== --- node_modules/@stomp/stompjs/src/stomp-subscription.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/stomp-subscription.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,18 @@ +import { StompHeaders } from './stomp-headers.js'; + +/** + * Call [Client#subscribe]{@link Client#subscribe} to create a StompSubscription. + * + * Part of `@stomp/stompjs`. + */ +export interface StompSubscription { + /** + * Id associated with this subscription. + */ + id: string; + + /** + * Unsubscribe. See [Client#unsubscribe]{@link Client#unsubscribe} for an example. + */ + unsubscribe: (headers?: StompHeaders) => void; +} Index: node_modules/@stomp/stompjs/src/types.ts =================================================================== --- node_modules/@stomp/stompjs/src/types.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/types.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,184 @@ +import { IFrame } from './i-frame.js'; +import { IMessage } from './i-message.js'; +import { StompHeaders } from './stomp-headers.js'; +import { Versions } from './versions.js'; + +/** + * This callback will receive a `string` as a parameter. + * + * Part of `@stomp/stompjs`. + */ +export type debugFnType = (msg: string) => void; + +/** + * This callback will receive a {@link IMessage} as parameter. + * + * Part of `@stomp/stompjs`. + */ +export type messageCallbackType = (message: IMessage) => void; + +/** + * This callback will receive a {@link IFrame} as parameter. + * + * Part of `@stomp/stompjs`. + */ +export type frameCallbackType = ((frame: IFrame) => void) | (() => void); + +/** + * This callback will receive a [CloseEvent]{@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent} + * as parameter. + * + * Part of `@stomp/stompjs`. + */ +export type closeEventCallbackType = (evt: T) => void; + +/** + * This callback will receive an [Event]{@link https://developer.mozilla.org/en-US/docs/Web/API/Event} + * as parameter. + * + * Part of `@stomp/stompjs`. + */ +export type wsErrorCallbackType = (evt: T) => void; + +/** + * Parameters for [Client#publish]{@link Client#publish}. + * Aliased as publishParams as well. + * + * Part of `@stomp/stompjs`. + */ +export interface IPublishParams { + /** + * destination end point + */ + destination: string; + /** + * headers (optional) + */ + headers?: StompHeaders; + /** + * body (optional) + */ + body?: string; + /** + * binary body (optional) + */ + binaryBody?: Uint8Array; + /** + * By default, a `content-length` header will be added in the Frame to the broker. + * Set it to `true` for the header to be skipped. + */ + skipContentLengthHeader?: boolean; +} + +/** + * Backward compatibility, switch to {@link IPublishParams}. + */ +export type publishParams = IPublishParams; + +/** + * Used in {@link IRawFrameType} + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export type RawHeaderType = [string, string]; + +/** + * The parser yield frames in this structure + * + * Part of `@stomp/stompjs`. + * + * @internal + */ +export interface IRawFrameType { + command: string | undefined; + headers: RawHeaderType[]; + binaryBody: Uint8Array | undefined; +} + +/** + * @internal + */ +export interface IStompSocketMessageEvent { + data?: string | ArrayBuffer; +} + +/** + * Copied from Websocket interface to avoid dom typelib dependency. + * + * @internal + */ +export interface IStompSocket { + url: string; + onclose: ((ev?: any) => any) | undefined | null; + onerror: ((ev: any) => any) | undefined | null; + onmessage: ((ev: IStompSocketMessageEvent) => any) | undefined | null; + onopen: ((ev?: any) => any) | undefined | null; + terminate?: (() => any) | undefined | null; + + /** + * Returns a string that indicates how binary data from the socket is exposed to scripts: + * We support only 'arraybuffer'. + */ + binaryType?: string; + + /** + * Returns the state of the socket connection. It can have the values of StompSocketState. + */ + readonly readyState: number; + + /** + * Closes the connection. + */ + close(): void; + /** + * Transmits data using the connection. data can be a string or an ArrayBuffer. + */ + send(data: string | ArrayBuffer): void; +} + +/** + * Possible states for the IStompSocket + */ +export enum StompSocketState { + CONNECTING, + OPEN, + CLOSING, + CLOSED, +} + +/** + * Possible activation state + */ +export enum ActivationState { + ACTIVE, + DEACTIVATING, + INACTIVE, +} + +/** + * @internal + */ +export interface IStomptHandlerConfig { + debug: debugFnType; + stompVersions: Versions; + connectHeaders: StompHeaders; + disconnectHeaders: StompHeaders; + heartbeatIncoming: number; + heartbeatOutgoing: number; + splitLargeFrames: boolean; + maxWebSocketChunkSize: number; + forceBinaryWSFrames: boolean; + logRawCommunication: boolean; + appendMissingNULLonIncoming: boolean; + discardWebsocketOnCommFailure: boolean; + onConnect: frameCallbackType; + onDisconnect: frameCallbackType; + onStompError: frameCallbackType; + onWebSocketClose: closeEventCallbackType; + onWebSocketError: wsErrorCallbackType; + onUnhandledMessage: messageCallbackType; + onUnhandledReceipt: frameCallbackType; + onUnhandledFrame: frameCallbackType; +} Index: node_modules/@stomp/stompjs/src/versions.ts =================================================================== --- node_modules/@stomp/stompjs/src/versions.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ node_modules/@stomp/stompjs/src/versions.ts (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,50 @@ +/** + * Supported STOMP versions + * + * Part of `@stomp/stompjs`. + */ +export class Versions { + /** + * Indicates protocol version 1.0 + */ + public static V1_0 = '1.0'; + /** + * Indicates protocol version 1.1 + */ + public static V1_1 = '1.1'; + /** + * Indicates protocol version 1.2 + */ + public static V1_2 = '1.2'; + + /** + * @internal + */ + public static default = new Versions([ + Versions.V1_2, + Versions.V1_1, + Versions.V1_0, + ]); + + /** + * Takes an array of versions, typical elements '1.2', '1.1', or '1.0' + * + * You will be creating an instance of this class if you want to override + * supported versions to be declared during STOMP handshake. + */ + constructor(public versions: string[]) {} + + /** + * Used as part of CONNECT STOMP Frame + */ + public supportedVersions() { + return this.versions.join(','); + } + + /** + * Used while creating a WebSocket + */ + public protocolVersions() { + return this.versions.map(x => `v${x.replace('.', '')}.stomp`); + } +} Index: package-lock.json =================================================================== --- package-lock.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ package-lock.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,13 @@ +{ + "name": "buildboard", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "@stomp/stompjs": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/@stomp/stompjs/-/stompjs-7.0.0.tgz", + "integrity": "sha512-fGdq4wPDnSV/KyOsjq4P+zLc8MFWC3lMmP5FBgLWKPJTYcuCbAIrnRGjB7q2jHZdYCOD5vxLuFoKIYLy5/u8Pw==" + } + } +} Index: package.json =================================================================== --- package.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ package.json (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,17 @@ +{ + "name": "buildboard", + "version": "1.0.0", + "description": "", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "https://github.com/stevetosak/BuildBoard.git" + }, + "private": true, + "dependencies": { + "@stomp/stompjs": "^7.0.0" + } +} Index: pom.xml =================================================================== --- pom.xml (revision 6ee72fa49804187c22d069f1a3c5bf5f3c0336a1) +++ pom.xml (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -68,4 +68,11 @@ 42.7.4 + + + org.springframework.boot + spring-boot-starter-websocket + + + Index: src/main/java/com/db/finki/www/build_board/config/WebSocketConfig.java =================================================================== --- src/main/java/com/db/finki/www/build_board/config/WebSocketConfig.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ src/main/java/com/db/finki/www/build_board/config/WebSocketConfig.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,42 @@ +package com.db.finki.www.build_board.config; + +import com.fasterxml.jackson.databind.ObjectMapper; +import org.springframework.context.annotation.Configuration; +import org.springframework.messaging.converter.MappingJackson2MessageConverter; +import org.springframework.messaging.converter.MessageConverter; +import org.springframework.messaging.simp.config.MessageBrokerRegistry; +import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker; +import org.springframework.web.socket.config.annotation.StompEndpointRegistry; +import org.springframework.web.socket.config.annotation.WebSocketMessageBrokerConfigurer; + +import java.util.List; + +@Configuration +@EnableWebSocketMessageBroker +public class WebSocketConfig implements WebSocketMessageBrokerConfigurer { + + private final ObjectMapper objectMapper; + + public WebSocketConfig(ObjectMapper objectMapper) { + this.objectMapper = objectMapper; + } + + @Override + public void configureMessageBroker(MessageBrokerRegistry config) { + config.enableSimpleBroker("/project"); + config.setApplicationDestinationPrefixes("/project"); + } + + @Override + public void registerStompEndpoints(StompEndpointRegistry registry) { + registry.addEndpoint("/channel-websocket"); + } + + @Override + public boolean configureMessageConverters(List messageConverters) { + MappingJackson2MessageConverter converter = new MappingJackson2MessageConverter(); + converter.setObjectMapper(objectMapper); // Use the configured ObjectMapper + messageConverters.add(converter); + return false; // Disable default converters + } +} Index: src/main/java/com/db/finki/www/build_board/controller/channels/ChannelWebSocketController.java =================================================================== --- src/main/java/com/db/finki/www/build_board/controller/channels/ChannelWebSocketController.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) +++ src/main/java/com/db/finki/www/build_board/controller/channels/ChannelWebSocketController.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -0,0 +1,37 @@ +package com.db.finki.www.build_board.controller.channels; + +import com.db.finki.www.build_board.dto.channel.MessageDTO; +import com.db.finki.www.build_board.entity.channels.Message; +import com.db.finki.www.build_board.entity.user_types.BBUser; +import com.db.finki.www.build_board.mappers.MessageMapper; +import com.db.finki.www.build_board.service.channel.MessageService; +import jakarta.transaction.Transactional; +import org.springframework.messaging.handler.annotation.MessageMapping; +import org.springframework.messaging.handler.annotation.SendTo; +import org.springframework.stereotype.Controller; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.SessionAttribute; + +import java.time.LocalDateTime; + +@Controller +public class ChannelWebSocketController { + + private final MessageService messageService; + private final MessageMapper messageMapper; + + public ChannelWebSocketController(MessageService messageService, MessageMapper messageMapper) { + this.messageService = messageService; + this.messageMapper = messageMapper; + } + + @MessageMapping("/{projectName}/channels/{channelName}") + @Transactional + MessageDTO chatMessage(MessageDTO messageDTO) { + messageDTO.setSentAt(LocalDateTime.now()); + Message m = messageService.saveMessage(messageDTO); + MessageDTO rabotaj = messageMapper.toDTO(m); + rabotaj.setAvatarUrl(m.getSentBy().getAvatarUrl()); + return rabotaj; + } +} Index: src/main/java/com/db/finki/www/build_board/dto/channel/MessageDTO.java =================================================================== --- src/main/java/com/db/finki/www/build_board/dto/channel/MessageDTO.java (revision 6ee72fa49804187c22d069f1a3c5bf5f3c0336a1) +++ src/main/java/com/db/finki/www/build_board/dto/channel/MessageDTO.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -10,6 +10,4 @@ import java.time.LocalDateTime; -@Getter -@Setter @NoArgsConstructor @AllArgsConstructor @@ -21,3 +19,51 @@ private Integer projectId; private String avatarUrl; + + public void setChannelName(String channelName) { + this.channelName = channelName; + } + + public void setContent(String content) { + this.content = content; + } + + public void setSenderUsername(String senderUsername) { + this.senderUsername = senderUsername; + } + + public void setSentAt(LocalDateTime sentAt) { + this.sentAt = sentAt; + } + + public void setProjectId(Integer projectId) { + this.projectId = projectId; + } + + public void setAvatarUrl(String avatarUrl) { + this.avatarUrl = avatarUrl; + } + + public String getChannelName() { + return channelName; + } + + public String getContent() { + return content; + } + + public String getSenderUsername() { + return senderUsername; + } + + public LocalDateTime getSentAt() { + return sentAt; + } + + public Integer getProjectId() { + return projectId; + } + + public String getAvatarUrl() { + return avatarUrl; + } } Index: src/main/java/com/db/finki/www/build_board/mappers/MessageMapper.java =================================================================== --- src/main/java/com/db/finki/www/build_board/mappers/MessageMapper.java (revision 6ee72fa49804187c22d069f1a3c5bf5f3c0336a1) +++ src/main/java/com/db/finki/www/build_board/mappers/MessageMapper.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -9,4 +9,5 @@ import com.db.finki.www.build_board.repository.thread.ProjectRepository; import com.db.finki.www.build_board.service.thread.impl.ProjectService; +import org.hibernate.Hibernate; import org.springframework.stereotype.Component; Index: src/main/java/com/db/finki/www/build_board/repository/channel/MessageRepository.java =================================================================== --- src/main/java/com/db/finki/www/build_board/repository/channel/MessageRepository.java (revision 6ee72fa49804187c22d069f1a3c5bf5f3c0336a1) +++ src/main/java/com/db/finki/www/build_board/repository/channel/MessageRepository.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -10,4 +10,4 @@ @Repository public interface MessageRepository extends JpaRepository { - List findAllByNameAndProjectIdOrderBySentAtDesc(String channelName, Integer projectId); + List findAllByNameAndProjectIdOrderBySentAtAsc(String channelName, Integer projectId); } Index: src/main/java/com/db/finki/www/build_board/service/channel/MessageService.java =================================================================== --- src/main/java/com/db/finki/www/build_board/service/channel/MessageService.java (revision 6ee72fa49804187c22d069f1a3c5bf5f3c0336a1) +++ src/main/java/com/db/finki/www/build_board/service/channel/MessageService.java (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -12,10 +12,16 @@ public class MessageService { private final MessageRepository messageRepository; - public MessageService(MessageRepository messageRepository) { + private final MessageMapper messageMapper; + public MessageService(MessageRepository messageRepository, MessageMapper messageMapper) { this.messageRepository = messageRepository; + this.messageMapper = messageMapper; } public List getAllMessagesForProjectChannel(Integer projectId,String channelName) { - return messageRepository.findAllByNameAndProjectIdOrderBySentAtDesc(channelName,projectId); + return messageRepository.findAllByNameAndProjectIdOrderBySentAtAsc(channelName,projectId); + } + public Message saveMessage(MessageDTO messageDTO) { + Message message = messageMapper.fromDTO(messageDTO); + return messageRepository.save(message); } Index: src/main/resources/templates/channels/view-channel.html =================================================================== --- src/main/resources/templates/channels/view-channel.html (revision 6ee72fa49804187c22d069f1a3c5bf5f3c0336a1) +++ src/main/resources/templates/channels/view-channel.html (revision a86879faab35a7fd7e2b07352ab5b33d677835e6) @@ -6,5 +6,5 @@ Channel - + @@ -36,10 +36,9 @@ -
- +
- user-logo + user-logo
@@ -52,12 +51,12 @@
- - +
- - + +
@@ -75,23 +74,130 @@
- + + - + + + + +