@morgan-stanley/composeui-messaging-client 0.1.0-alpha.10

package/dist/index.js

@@ -0,0 +1,756 @@
+
+  /**
+   * @license
+   * author: Morgan Stanley
+   * composeui-messaging-client.js v0.1.0-alpha.10
+   * Released under the Apache-2.0 license.
+   */
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+const ErrorNames = {
+    duplicateEndpoint: "DuplicateEndpoint",
+    duplicateRequestId: "DuplicateRequestId",
+    invalidEndpoint: "InvalidEndpoint",
+    invalidTopic: "InvalidTopic",
+    unknownEndpoint: "UnknownEndpoint",
+    unknownClient: "UnknownClient",
+    connectionClosed: "ConnectionClosed",
+    connectionAborted: "ConnectionAborted",
+    invalidAccessToken: "InvalidAccessToken",
+    connectionFailed: "ConnectionFailed",
+};
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+class WebSocketConnection {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    connect() {
+        return new Promise((resolve, reject) => {
+            this.websocket = new WebSocket(this.options.url);
+            this.websocket.addEventListener('open', () => {
+                this.isConnected = true;
+                resolve();
+            });
+            this.websocket.addEventListener('message', ev => {
+                const message = WebSocketConnection.deserializeMessage(ev.data);
+                this._onMessage?.call(undefined, message);
+            });
+            this.websocket.addEventListener('error', ev => {
+                if (!this.isConnected) {
+                    reject();
+                }
+                else {
+                    this.isConnected = false;
+                    this._onError?.call(undefined, new Error());
+                }
+            });
+            this.websocket.addEventListener('close', () => {
+                this.isConnected = false;
+                delete this.websocket;
+                this._onClose?.call(undefined);
+            });
+        });
+    }
+    send(message) {
+        if (!this.websocket) {
+            return Promise.reject();
+        }
+        this.websocket.send(JSON.stringify(message));
+        return Promise.resolve();
+    }
+    close() {
+        if (this.isConnected) {
+            this.websocket?.close(1000, "Closed by client");
+            this.isConnected = false;
+            delete this.websocket;
+        }
+        return Promise.resolve();
+    }
+    onMessage(callback) {
+        this._onMessage = callback;
+    }
+    onError(callback) {
+        this._onError = callback;
+    }
+    onClose(callback) {
+        this._onClose = callback;
+    }
+    static deserializeMessage(data) {
+        const msg = JSON.parse(data);
+        return msg;
+    }
+    websocket;
+    isConnected = false;
+    messageQueue = [];
+    _onMessage;
+    _onError;
+    _onClose;
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+class Deferred {
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolve =
+                (value) => {
+                    this.settle();
+                    resolve(value);
+                };
+            this.reject =
+                (reason) => {
+                    this.settle();
+                    reject(reason);
+                };
+        });
+    }
+    resolve = () => { };
+    reject = () => { };
+    promise;
+    settle() {
+        const noop = () => { };
+        this.resolve = noop;
+        this.reject = noop;
+    }
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+function isProtocolError(err) {
+    return (typeof err === "object") && ("name" in err);
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+class MessageRouterError extends Error {
+    constructor(err, message, stack) {
+        let [name, msg] = isProtocolError(err) ? [err.name, err.message] : [err, message];
+        super(msg);
+        this.name = name;
+        if (stack) {
+            this.stack = stack;
+        }
+    }
+}
+function createProtocolError(err) {
+    if (typeof err === "string")
+        return {
+            name: "Error",
+            message: err
+        };
+    return {
+        name: err.name ?? "Error",
+        message: err.message ?? `Unknown error (${err})`
+    };
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+class ThrowHelper {
+    static duplicateEndpoint(endpoint) {
+        return new MessageRouterError({ name: ErrorNames.duplicateEndpoint, message: `Duplicate endpoint registration: '${endpoint}'` });
+    }
+    static duplicateRequestId() {
+        return new MessageRouterError({ name: ErrorNames.duplicateRequestId, message: "Duplicate request ID" });
+    }
+    static invalidEndpoint(endpoint) {
+        return new MessageRouterError({ name: ErrorNames.invalidEndpoint, message: `Invalid endpoint: '${endpoint}'` });
+    }
+    static invalidTopic(topic) {
+        return new MessageRouterError({ name: ErrorNames.invalidTopic, message: `Invalid topic: '${topic}'` });
+    }
+    static unknownEndpoint(endpoint) {
+        return new MessageRouterError({ name: ErrorNames.unknownEndpoint, message: `Unknown endpoint: ${endpoint}` });
+    }
+    static connectionClosed() {
+        return new MessageRouterError({ name: ErrorNames.connectionClosed, message: "The connection has been closed" });
+    }
+    static connectionFailed(message) {
+        return new MessageRouterError({ name: ErrorNames.connectionFailed, message: `Connection failed with message ${message}` });
+    }
+    static connectionAborted() {
+        return new MessageRouterError({ name: ErrorNames.connectionAborted, message: "The connection dropped unexpectedly" });
+    }
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+function isResponse(message) {
+    return (message.type === "InvokeResponse"
+        || message.type === "RegisterServiceResponse"
+        || message.type === "UnregisterServiceResponse"
+        || message.type === "SubscribeResponse"
+        || message.type === "UnsubscribeResponse"
+        || message.type === "PublishResponse");
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+function isConnectResponse(message) {
+    return message.type == "ConnectResponse";
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+function isInvokeRequest(message) {
+    return message.type == "Invoke";
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+function isTopicMessage(message) {
+    return message.type == "Topic";
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+var ClientState;
+(function (ClientState) {
+    ClientState[ClientState["Created"] = 0] = "Created";
+    ClientState[ClientState["Connecting"] = 1] = "Connecting";
+    ClientState[ClientState["Connected"] = 2] = "Connected";
+    ClientState[ClientState["Closing"] = 3] = "Closing";
+    ClientState[ClientState["Closed"] = 4] = "Closed";
+})(ClientState || (ClientState = {}));
+class MessageRouterClient {
+    connection;
+    options;
+    constructor(connection, options) {
+        this.connection = connection;
+        this.options = options;
+        this.options = options ?? {};
+    }
+    _clientId;
+    get clientId() {
+        return this._clientId;
+    }
+    connect() {
+        switch (this._state) {
+            case ClientState.Connected:
+                return Promise.resolve();
+            case ClientState.Created:
+                return this.connectCore();
+            case ClientState.Connecting:
+                return this.connected.promise;
+        }
+        return Promise.reject(ThrowHelper.connectionClosed());
+    }
+    close() {
+        return this.closeCore();
+    }
+    async subscribe(topicName, subscriber) {
+        this.checkState();
+        if (this.pendingUnsubscriptions[topicName]) {
+            await this.pendingUnsubscriptions[topicName];
+        }
+        let needsSubscription = false;
+        let topic = this.topics[topicName];
+        if (!topic) {
+            this.topics[topicName] = topic = new Topic(() => this.unsubscribe(topicName));
+            needsSubscription = true;
+        }
+        if (typeof subscriber === "function") {
+            subscriber = { next: subscriber };
+        }
+        const subscription = topic.subscribe(subscriber);
+        if (needsSubscription) {
+            try {
+                await this.sendRequest({
+                    requestId: this.getRequestId(),
+                    type: "Subscribe",
+                    topic: topicName
+                });
+            }
+            catch (error) {
+                delete this.topics[topicName];
+                throw error;
+            }
+        }
+        return subscription;
+    }
+    async publish(topic, payload, options) {
+        this.checkState();
+        await this.sendRequest({
+            type: "Publish",
+            requestId: this.getRequestId(),
+            topic,
+            payload,
+            correlationId: options?.correlationId
+        });
+    }
+    async invoke(endpoint, payload, options) {
+        this.checkState();
+        const response = await this.sendRequest({
+            type: "Invoke",
+            requestId: this.getRequestId(),
+            endpoint,
+            payload,
+            correlationId: options?.correlationId
+        });
+        return response.payload;
+    }
+    async registerService(endpoint, handler, descriptor) {
+        this.checkState();
+        if (this.endpointHandlers[endpoint])
+            throw ThrowHelper.duplicateEndpoint(endpoint);
+        this.endpointHandlers[endpoint] = handler;
+        try {
+            await this.sendRequest({
+                type: "RegisterService",
+                requestId: this.getRequestId(),
+                endpoint,
+                descriptor
+            });
+        }
+        catch (error) {
+            delete this.endpointHandlers[endpoint];
+            throw error;
+        }
+    }
+    async unregisterService(endpoint) {
+        this.checkState();
+        if (!this.endpointHandlers[endpoint])
+            return;
+        await this.sendRequest({
+            type: "UnregisterService",
+            requestId: this.getRequestId(),
+            endpoint
+        });
+        delete this.endpointHandlers[endpoint];
+    }
+    registerEndpoint(endpoint, handler, descriptor) {
+        this.checkState();
+        if (this.endpointHandlers[endpoint])
+            throw ThrowHelper.duplicateEndpoint(endpoint);
+        this.endpointHandlers[endpoint] = handler;
+        return Promise.resolve();
+    }
+    unregisterEndpoint(endpoint) {
+        this.checkState();
+        delete this.endpointHandlers[endpoint];
+        return Promise.resolve();
+    }
+    get state() {
+        return this._state;
+    }
+    _state = ClientState.Created;
+    lastRequestId = 0;
+    topics = {};
+    connected = new Deferred();
+    closed = new Deferred();
+    pendingRequests = {};
+    endpointHandlers = {};
+    pendingUnsubscriptions = {};
+    async connectCore() {
+        this._state = ClientState.Connecting;
+        try {
+            this.connection.onMessage(this.handleMessage.bind(this));
+            this.connection.onError(this.handleError.bind(this));
+            this.connection.onClose(this.handleClose.bind(this));
+            await this.connection.connect();
+            const req = {
+                type: "Connect",
+                accessToken: this.options.accessToken
+            };
+            await this.connection.send(req);
+            // This must be the last statement before catch so that awaiting `connected` 
+            // has the same effect as awaiting `connect()`. `close()` also rejects this promise.
+            await this.connected.promise;
+        }
+        catch (error) {
+            if (error instanceof MessageRouterError) {
+                throw error;
+            }
+            else {
+                await this.closeCore(error);
+                throw ThrowHelper.connectionFailed(error.message || error);
+            }
+        }
+    }
+    async closeCore(error) {
+        error ??= ThrowHelper.connectionClosed();
+        switch (this._state) {
+            case ClientState.Created:
+                {
+                    this._state = ClientState.Closed;
+                    return;
+                }
+            case ClientState.Closed:
+                return;
+            case ClientState.Closing:
+                await this.closed.promise;
+                return;
+            case ClientState.Connecting:
+                {
+                    this._state = ClientState.Closed;
+                    this.connected.reject(ThrowHelper.connectionClosed());
+                    return;
+                }
+        }
+        this._state = ClientState.Closing;
+        this.failPendingRequests(error);
+        this.failSubscribers(error);
+        try {
+            await this.connection.close();
+        }
+        catch (e) {
+            console.error(e);
+        }
+        this._state = ClientState.Closed;
+        this.closed.resolve();
+    }
+    failPendingRequests(error) {
+        for (let requestId in this.pendingRequests) {
+            this.pendingRequests[requestId].reject(error);
+            delete this.pendingRequests[requestId];
+        }
+    }
+    async failSubscribers(error) {
+        for (let topicName in this.topics) {
+            const topic = this.topics[topicName];
+            topic.error(error);
+        }
+    }
+    async sendMessage(message) {
+        await this.connect();
+        await this.connection.send(message);
+    }
+    async sendRequest(request) {
+        const deferred = this.pendingRequests[request.requestId] = new Deferred();
+        try {
+            await this.sendMessage(request);
+        }
+        catch (error) {
+            delete this.pendingRequests[request.requestId];
+            throw error;
+        }
+        return await deferred.promise;
+    }
+    handleMessage(message) {
+        if (isTopicMessage(message)) {
+            this.handleTopicMessage(message);
+            return;
+        }
+        if (isResponse(message)) {
+            this.handleResponse(message);
+            return;
+        }
+        if (isInvokeRequest(message)) {
+            this.handleInvokeRequest(message);
+            return;
+        }
+        if (isConnectResponse(message)) {
+            this.handleConnectResponse(message);
+            return;
+        }
+    }
+    handleTopicMessage(message) {
+        const topic = this.topics[message.topic];
+        if (!topic)
+            return;
+        topic.next({
+            topic: message.topic,
+            payload: message.payload,
+            context: {
+                sourceId: message.sourceId,
+                correlationId: message.correlationId
+            }
+        });
+    }
+    handleResponse(message) {
+        const request = this.pendingRequests[message.requestId];
+        if (!request)
+            return;
+        if (message.error) {
+            request.reject(new MessageRouterError(message.error));
+        }
+        else {
+            request.resolve(message);
+        }
+    }
+    async handleInvokeRequest(message) {
+        try {
+            const handler = this.endpointHandlers[message.endpoint];
+            if (!handler)
+                throw ThrowHelper.unknownEndpoint(message.endpoint);
+            const result = await handler(message.endpoint, message.payload, {
+                sourceId: message.sourceId,
+                correlationId: message.correlationId
+            });
+            await this.sendMessage({
+                type: "InvokeResponse",
+                requestId: message.requestId,
+                payload: typeof result === "string" ? result : undefined
+            });
+        }
+        catch (error) {
+            await this.sendMessage({
+                type: "InvokeResponse",
+                requestId: message.requestId,
+                error: createProtocolError(error)
+            });
+        }
+    }
+    handleConnectResponse(message) {
+        if (message.error) {
+            this._state = ClientState.Closed;
+            this.connected.reject(new MessageRouterError(message.error));
+        }
+        else {
+            this._clientId = message.clientId;
+            this._state = ClientState.Connected;
+            this.connected.resolve();
+        }
+    }
+    checkState() {
+        if (this._state == ClientState.Closed || this._state == ClientState.Closing) {
+            throw ThrowHelper.connectionClosed();
+        }
+    }
+    handleError(error) {
+        switch (this._state) {
+            case ClientState.Closing:
+            case ClientState.Closed:
+                return;
+        }
+        this.closeCore(error);
+    }
+    handleClose() {
+        this.handleError(ThrowHelper.connectionAborted());
+    }
+    async unsubscribe(topicName) {
+        let topic = this.topics[topicName];
+        if (!topic)
+            return;
+        if (this.pendingUnsubscriptions[topicName]) {
+            await this.pendingUnsubscriptions[topicName];
+        }
+        this.pendingUnsubscriptions[topicName] = this.sendRequest({
+            requestId: this.getRequestId(),
+            type: "Unsubscribe",
+            topic: topicName
+        })
+            .then(() => {
+            delete this.topics[topicName];
+        })
+            .catch(error => {
+            console.error("Exception thrown while unsubscribing.", error);
+            throw error;
+        })
+            .finally(() => {
+            delete this.pendingUnsubscriptions[topicName];
+        });
+        await this.pendingUnsubscriptions[topicName];
+    }
+    getRequestId() {
+        return '' + (++this.lastRequestId);
+    }
+}
+class Topic {
+    constructor(onUnsubscribe) {
+        this.onUnsubscribe = onUnsubscribe;
+    }
+    subscribe(subscriber) {
+        if (this.isCompleted)
+            return {
+                unsubscribe: () => { }
+            };
+        this.subscribers.push(subscriber);
+        return {
+            unsubscribe: () => this.unsubscribe(subscriber)
+        };
+    }
+    unsubscribe(subscriber) {
+        if (this.isCompleted)
+            return;
+        const idx = this.subscribers.lastIndexOf(subscriber);
+        if (idx < 0)
+            return;
+        this.subscribers.splice(idx, 1);
+        if (this.subscribers.length == 0) {
+            this.onUnsubscribe();
+        }
+    }
+    next(message) {
+        if (this.isCompleted) {
+            return;
+        }
+        for (let subscriber of this.subscribers) {
+            try {
+                subscriber.next?.call(subscriber, message);
+            }
+            catch (error) {
+                console.error(error);
+            }
+        }
+    }
+    error(error) {
+        if (this.isCompleted)
+            return;
+        this.isCompleted = true;
+        for (let subscriber of this.subscribers) {
+            try {
+                subscriber.error?.call(subscriber, error);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    complete() {
+        if (this.isCompleted)
+            return;
+        for (let subscriber of this.subscribers) {
+            try {
+                subscriber.complete?.call(subscriber);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+    isCompleted = false;
+    onUnsubscribe;
+    subscribers = [];
+}
+
+/*
+ *  Morgan Stanley makes this available to you under the Apache License,
+ *  Version 2.0 (the "License"). You may obtain a copy of the License at
+ *       http://www.apache.org/licenses/LICENSE-2.0.
+ *  See the NOTICE file distributed with this work for additional information
+ *  regarding copyright ownership. 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.
+ *
+ */
+function createMessageRouter(config) {
+    config ??= window.composeui?.messageRouterConfig;
+    if (config?.webSocket) {
+        const connection = new WebSocketConnection(config.webSocket);
+        return new MessageRouterClient(connection, config);
+    }
+    throw ConfigNotFound();
+    function ConfigNotFound() {
+        return new Error("Unable to create the MessageRouter client, configuration is missing.");
+    }
+}
+
+export { ErrorNames, MessageRouterError, createMessageRouter, createProtocolError };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"index.js","sources":["../src/ErrorNames.ts","../src/client/websocket/WebSocketConnection.ts","../src/client/Deferred.ts","../src/protocol/Error.ts","../src/MessageRouterError.ts","../src/exceptions/ThrowHelper.ts","../src/protocol/messages/AbstractResponse.ts","../src/protocol/messages/ConnectResponse.ts","../src/protocol/messages/InvokeRequest.ts","../src/protocol/messages/TopicMessage.ts","../src/client/MessageRouterClient.ts","../src/MessageRouter.ts"],"sourcesContent":[null,null,null,null,null,null,null,null,null,null,null,null],"names":["messages.isTopicMessage","messages.isResponse","messages.isInvokeRequest","messages.isConnectResponse"],"mappings":"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"}