@ohos-ports/genesys-cloud-streaming-client 20.1.0-beta.1

package/dist/es/notifications.js

@@ -0,0 +1,507 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import debounce from 'debounce-promise';
+import { splitIntoIndividualTopics } from './utils';
+import { StreamingSubscriptionError } from './';
+const PUBSUB_HOST_DEFAULT = 'notifications.mypurecloud.com';
+const MAX_SUBSCRIBABLE_TOPICS = 1000;
+const DROPPED_TOPICS_DISPLAY_COUNT = 20;
+const DEFAULT_PRIORITY = 0;
+function mergeAndDedup(arr1, arr2) {
+    return [...arr1, ...arr2].filter((t, i, arr) => arr.indexOf(t) === i);
+}
+export class Notifications {
+    constructor(client, options) {
+        var _a;
+        this.subscriptions = {};
+        this.bulkSubscriptions = {};
+        this.topicPriorities = {};
+        this.internalSubscriptions = [];
+        this.client = client;
+        this.enablePartialBulkResubscribe = (_a = options === null || options === void 0 ? void 0 : options.enablePartialBulkResubscribe) !== null && _a !== void 0 ? _a : false;
+        client.on('pubsub:event', this.pubsubEvent.bind(this));
+        client.on('connected', this.subscriptionsKeepAlive.bind(this));
+        this.debouncedResubscribe = debounce(this.resubscribe.bind(this), 100);
+    }
+    get pubsubHost() {
+        try {
+            const host = this.client.config.apiHost.replace(/http(s?):\/\//, '');
+            return `notifications.${host}`;
+        }
+        catch (e) {
+            return PUBSUB_HOST_DEFAULT;
+        }
+    }
+    handleStanzaInstanceChange(stanza) {
+        // we need to resub if we go through a hard reconnect
+        const needsToResub = this.stanzaInstance &&
+            this.stanzaInstance.id !== stanza.id &&
+            this.stanzaInstance.channelId !== stanza.channelId;
+        this.stanzaInstance = stanza;
+        if (needsToResub) {
+            this.client.logger.info('resubscribing due to hard reconnect');
+            this.debouncedResubscribe().catch((err) => {
+                const msg = 'Error resubscribing to topics';
+                this.client.logger.error(msg, err);
+                this.client.emit('pubsub:error', { msg, err });
+            });
+        }
+    }
+    topicHandlers(topic) {
+        if (!this.subscriptions[topic]) {
+            this.subscriptions[topic] = [];
+        }
+        return this.subscriptions[topic];
+    }
+    pubsubEvent({ pubsub }) {
+        let topic = pubsub.items.node;
+        if (topic.includes('no_longer_subscribed')) {
+            topic = 'no_longer_subscribed';
+        }
+        else if (topic.includes('duplicate_id')) {
+            topic = 'duplicate_id';
+        }
+        const payload = pubsub.items.published[0].content.json;
+        const handlers = this.topicHandlers(topic);
+        this.client.emit('notify', { topic, data: payload });
+        this.client.emit(`notify:${topic}`, payload);
+        handlers.forEach((handler) => {
+            handler(payload);
+        });
+    }
+    xmppSubscribe(topic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.topicHandlers(topic).length !== 0 || this.bulkSubscriptions[topic]) {
+                return Promise.resolve();
+            }
+            const subscribe = () => this.stanzaInstance.subscribeToNode(this.pubsubHost, topic);
+            if (this.client.connected) {
+                return subscribe();
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    this.client.once('connected', () => {
+                        return subscribe().then(resolve, reject);
+                    });
+                });
+            }
+        });
+    }
+    xmppUnsubscribe(topic) {
+        if (this.topicHandlers(topic).length !== 0 || this.bulkSubscriptions[topic]) {
+            return Promise.resolve();
+        }
+        const unsubscribe = () => this.stanzaInstance.unsubscribeFromNode(this.pubsubHost, topic);
+        if (this.client.connected) {
+            return unsubscribe();
+        }
+        else {
+            return new Promise((resolve, reject) => {
+                this.client.once('connected', () => {
+                    return unsubscribe().then(resolve, reject);
+                });
+            });
+        }
+    }
+    mapCombineTopics(topics) {
+        const prefixes = {};
+        const precombinedTopics = [];
+        const uncombinedTopics = [];
+        topics.forEach(t => {
+            if (t.includes('?')) {
+                precombinedTopics.push({ id: t });
+            }
+            else {
+                uncombinedTopics.push(t);
+            }
+        });
+        uncombinedTopics.map(t => {
+            const split = t.split('.');
+            const postfix = split.splice(split.length - 1);
+            const prefix = split.join('.');
+            return { prefix, postfix };
+        }).forEach(t => {
+            if (prefixes[t.prefix]) {
+                prefixes[t.prefix].push(t.postfix);
+            }
+            else {
+                prefixes[t.prefix] = [t.postfix];
+            }
+        });
+        const combinedTopics = [];
+        // Max length of 200 in topic names
+        // so recursively break them up if the combined length exceeds 200
+        const combineTopics = (prefix, postFixes) => {
+            const delimiter = postFixes.length === 1 ? '.' : '?';
+            const id = `${prefix}${delimiter}${postFixes.join('&')}`;
+            if (id.length < 200) {
+                combinedTopics.push({ id });
+            }
+            else if (postFixes.length === 1) {
+                this.client.logger.error('Refusing to attempt topic with length > 200', id);
+            }
+            else {
+                combineTopics(prefix, postFixes.slice(0, postFixes.length / 2));
+                combineTopics(prefix, postFixes.slice(postFixes.length / 2));
+            }
+        };
+        Object.keys(prefixes).forEach(prefix => {
+            const postFixes = prefixes[prefix];
+            combineTopics(prefix, postFixes);
+        });
+        const allTopics = combinedTopics.concat(precombinedTopics);
+        return this.truncateTopicList(this.prioritizeTopicList(allTopics));
+    }
+    prioritizeTopicList(topics) {
+        topics.sort((topicA, topicB) => {
+            return (this.getTopicPriority(topicB.id) - this.getTopicPriority(topicA.id));
+        });
+        return topics;
+    }
+    getTopicPriority(topic, returnDefault = true) {
+        const { prefix, postfixes } = this.getTopicParts(topic);
+        const oldPriorities = this.topicPriorities[prefix];
+        const matches = oldPriorities && Object.keys(oldPriorities).filter(p => postfixes.includes(p)).map(p => oldPriorities[p]);
+        const priority = matches && matches.length && matches.reduce((max, current) => current > max ? current : max);
+        return returnDefault ? priority || DEFAULT_PRIORITY : priority;
+    }
+    truncateTopicList(topics) {
+        const keptTopics = topics.slice(0, MAX_SUBSCRIBABLE_TOPICS);
+        if (topics.length > MAX_SUBSCRIBABLE_TOPICS) {
+            let droppedTopics = topics.slice(MAX_SUBSCRIBABLE_TOPICS);
+            if (droppedTopics.length > DROPPED_TOPICS_DISPLAY_COUNT) {
+                const length = droppedTopics.length - DROPPED_TOPICS_DISPLAY_COUNT;
+                droppedTopics = droppedTopics.slice(DROPPED_TOPICS_DISPLAY_COUNT);
+                droppedTopics.push(`...and ${length} more`);
+            }
+            this.client.logger.warn('Too many topics to subscribe to; truncating extra topics', { droppedTopics });
+        }
+        return keptTopics;
+    }
+    makeBulkSubscribeRequest(topics, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Cancel any in-flight retry or connected-wait from a previous bulk subscribe.
+            // If the topic list has changed (subscribe/unsubscribe called between retries),
+            // the stale request would send an outdated topic list. Since bulk subscribes with
+            // replace=true use PUT (full replacement), only the most recent request matters.
+            if (this.pendingConnectedWait) {
+                this.pendingConnectedWait.cancel(new Error('Superseded by newer bulk subscribe request'));
+                this.pendingConnectedWait = undefined;
+            }
+            if (this.pendingBulkSubscribeRetry && !this.pendingBulkSubscribeRetry.hasCompleted()) {
+                this.client.logger.info('Cancelling previous bulk subscribe retry — new request supersedes it');
+                this.pendingBulkSubscribeRetry.cancel(new Error('Superseded by newer bulk subscribe request'));
+            }
+            // If the client is not connected, wait for reconnection before attempting the request.
+            // This prevents firing requests against a dead/stale channel ID which would result in
+            // 400 errors (notification.unable.to.get.channel.id). After reconnection, the stanza
+            // instance will have the fresh channel ID from the new connection.
+            if (!this.client.connected) {
+                this.client.logger.info('Client not connected, waiting for reconnection before bulk subscribe', {
+                    topicCount: topics.length
+                });
+                yield new Promise((resolve, reject) => {
+                    const onConnected = () => {
+                        this.pendingConnectedWait = undefined;
+                        resolve();
+                    };
+                    this.client.once('connected', onConnected);
+                    this.pendingConnectedWait = {
+                        cancel: (reason) => {
+                            this.client.off('connected', onConnected);
+                            reject(reason);
+                        }
+                    };
+                });
+            }
+            const requestOptions = {
+                method: options.replace ? 'put' : 'post',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                data: JSON.stringify(this.mapCombineTopics(topics)),
+                logger: this.client.logger,
+                maxAttempts: 3
+            };
+            const channelId = this.stanzaInstance.channelId;
+            let path = `notifications/channels/${channelId}/subscriptions`;
+            if (this.enablePartialBulkResubscribe) {
+                path += '?ignoreErrors=true';
+            }
+            const retry = this.client.http.requestApiWithRetry(path, requestOptions, 2000);
+            this.pendingBulkSubscribeRetry = retry;
+            return retry.promise;
+        });
+    }
+    createSubscription(topic, handler) {
+        const topics = splitIntoIndividualTopics(topic);
+        topics.forEach(t => {
+            const handlers = this.topicHandlers(t);
+            if (!handlers.includes(handler)) {
+                handlers.push(handler);
+            }
+        });
+    }
+    removeSubscription(topic, handler) {
+        const topics = splitIntoIndividualTopics(topic);
+        topics.forEach(t => {
+            const handlers = this.topicHandlers(t);
+            const handlerIndex = handlers.indexOf(handler);
+            if (handlerIndex > -1) {
+                handlers.splice(handlerIndex, 1);
+            }
+            /* if we have removed all our individual handlers, we don't need the topic anymore
+              (note: we aren't removing any bulkSubs if they exist for this topic) */
+            if (!handlers.length) {
+                delete this.subscriptions[t];
+            }
+        });
+    }
+    removeTopicPriority(topic) {
+        if (this.getTopicPriority(topic, false)) {
+            const { prefix, postfixes } = this.getTopicParts(topic);
+            postfixes.forEach(postfix => {
+                delete this.topicPriorities[prefix][postfix];
+            });
+            if (!Object.keys(this.topicPriorities[prefix]).length) {
+                delete this.topicPriorities[prefix];
+            }
+        }
+    }
+    getActiveIndividualTopics() {
+        const activeTopics = [];
+        const topics = Object.keys(this.subscriptions);
+        topics.forEach(topic => {
+            if (topic === 'streaming-subscriptions-expiring') {
+                return; // this doesn't need subscribed
+            }
+            const handlers = this.topicHandlers(topic);
+            if (handlers.length > 0) {
+                activeTopics.push(topic);
+            }
+        });
+        return activeTopics;
+    }
+    resubscribe() {
+        const bulkSubs = Object.keys(this.bulkSubscriptions);
+        /* if we don't have bulk or individual subs, we don't need to resubscribe */
+        const noTopics = bulkSubs.length + this.getActiveIndividualTopics().length === 0;
+        if (noTopics) {
+            return Promise.resolve({});
+        }
+        /* only pass in bulk subs with the replace flag – bulkSubscribe() will handle merging our individual topics (see PCM-1846) */
+        return this.bulkSubscribe(bulkSubs, { replace: true });
+    }
+    subscriptionsKeepAlive() {
+        const topic = 'streaming-subscriptions-expiring';
+        if (this.topicHandlers(topic).length === 0) {
+            this.createSubscription(topic, () => {
+                this.client.logger.info(`${topic} - Triggering resubscribe.`, { channelId: this.client.config.channelId });
+                this.debouncedResubscribe().catch((err) => {
+                    const msg = 'Error resubscribing to topics';
+                    this.client.logger.error(msg, err);
+                    this.client.emit('pubsub:error', { msg, err });
+                });
+            });
+        }
+    }
+    getTopicParts(topic) {
+        const isCombined = topic.includes('?');
+        const separator = isCombined ? '?' : '.';
+        const split = topic.split(separator);
+        const postfix = isCombined ? split[1] : split.splice(split.length - 1);
+        const prefix = isCombined ? split[0] : split.join('.');
+        let postfixes = [];
+        if (isCombined) {
+            postfixes = postfix.split('&');
+        }
+        else {
+            postfixes = postfix;
+        }
+        return { prefix, postfixes };
+    }
+    setTopicPriorities(priorities = {}) {
+        Object.keys(priorities).forEach(priority => {
+            const topicParts = this.getTopicParts(priority);
+            const oldPriorities = this.topicPriorities[topicParts.prefix];
+            const newPriority = priorities[priority];
+            if (oldPriorities) {
+                topicParts.postfixes.forEach(postfix => {
+                    const oldPriority = oldPriorities[postfix];
+                    if ((oldPriority && oldPriority < newPriority) || !oldPriority) {
+                        oldPriorities[postfix] = newPriority;
+                    }
+                });
+            }
+            else {
+                const newTopics = topicParts.postfixes.reduce((newTopics, p) => {
+                    newTopics[p] = newPriority;
+                    return newTopics;
+                }, {});
+                this.topicPriorities[topicParts.prefix] = newTopics;
+            }
+        });
+    }
+    subscribe(topic, handler, immediate, priority) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (priority) {
+                this.setTopicPriorities({ [topic]: priority });
+            }
+            let promise;
+            if (!immediate) {
+                // let this and any other subscribe/unsubscribe calls roll in, then trigger a whole resubscribe
+                promise = this.debouncedResubscribe();
+            }
+            else {
+                promise = this.xmppSubscribe(topic);
+            }
+            if (handler) {
+                this.createSubscription(topic, handler);
+            }
+            else {
+                this.bulkSubscriptions[topic] = true;
+            }
+            const result = yield promise;
+            // Assume topic subscription succeeded if promise is resolved...
+            let topicResult = { topic, state: 'Permitted' };
+            // ... but if partial bulk resubscribe is enabled, use topic's individual result from the API response.
+            if (this.enablePartialBulkResubscribe && result && typeof result === 'object' && isTopicSubscribeResult(result[topic])) {
+                topicResult = result[topic];
+            }
+            // Topic result other than state=Permitted becomes a StreamingSubscriptionError promise rejection.
+            if (topicResult.state !== 'Permitted') {
+                const message = topicResult.rejectionReason || `Failed to subscribe topic ${topic}`;
+                const missingPermissions = topicResult.missingPermissions;
+                throw new StreamingSubscriptionError(message, topic, 'subscribe', { missingPermissions });
+            }
+            return topicResult;
+        });
+    }
+    /**
+     * Use `_subscribeInternal` when subscribing to a topic from within streaming-client itself.
+     * Internal subscriptions won't be overwritten by subscriptions from consumers and will be prioritized
+     * over subscriptions from consumers.
+     */
+    _subscribeInternal(topic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.internalSubscriptions.includes(topic)) {
+                return Promise.resolve();
+            }
+            this.setTopicPriorities({ [topic]: Number.MAX_VALUE });
+            const promise = this.xmppSubscribe(topic);
+            this.internalSubscriptions.push(topic);
+            this.bulkSubscriptions[topic] = true;
+            return promise;
+        });
+    }
+    unsubscribe(topic, handler, immediate) {
+        if (handler) {
+            this.removeSubscription(topic, handler);
+        }
+        else {
+            delete this.bulkSubscriptions[topic];
+            delete this.subscriptions[topic];
+        }
+        this.removeTopicPriority(topic);
+        if (!immediate) {
+            // let this and any other subscribe/unsubscribe calls roll in, then trigger a whole resubscribe
+            return this.debouncedResubscribe();
+        }
+        return this.xmppUnsubscribe(topic);
+    }
+    bulkSubscribe(topics, options = { replace: false, force: false }, priorities = {}) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setTopicPriorities(priorities);
+            let toSubscribe = mergeAndDedup(topics, this.internalSubscriptions);
+            if (options.replace && !options.force) {
+                // if this is a bulk subscription, but not a forcible one, keep all individual subscriptions
+                toSubscribe = mergeAndDedup(toSubscribe, this.getActiveIndividualTopics());
+            }
+            else if (options.force) {
+                // if it's a forcible bulk subscribe, wipe out individual subscriptions
+                this.subscriptions = {};
+            }
+            let response;
+            try {
+                response = yield this.makeBulkSubscribeRequest(toSubscribe, options);
+            }
+            catch (err) {
+                // If this request was cancelled because a newer bulk subscribe superseded it,
+                // return an 'Unknown' state for all topics. The superseding request will carry
+                // the current desired topic list and handle the actual subscription.
+                if ((_a = err === null || err === void 0 ? void 0 : err.message) === null || _a === void 0 ? void 0 : _a.includes('Superseded by newer bulk subscribe request')) {
+                    this.client.logger.debug('Bulk subscribe was superseded, deferring to newer request');
+                    const result = {};
+                    for (const topic of toSubscribe) {
+                        result[topic] = { topic, state: 'Unknown' };
+                    }
+                    return result;
+                }
+                throw err;
+            }
+            let topicResponseEntities = [];
+            if (response && response.data && 'entities' in response.data && Array.isArray(response.data.entities)) {
+                topicResponseEntities = response.data.entities;
+            }
+            const result = {};
+            for (const topicEntity of topicResponseEntities) {
+                const { id, state, rejectionReason, missingPermissions } = topicEntity;
+                result[id] = { topic: id, state, rejectionReason, missingPermissions };
+                // If response entity is a combined topic ID like "a.b?c&d" include individualized topic IDs
+                // as keys in the map. This could either point to the same result as the combined topic ID
+                // or to a specific result for that individual topic if backend provides a specific result.
+                // Example: caller asked to subscribe "a.b?c&d" but user lacks permission for topic "a.b.d"
+                // In this case, API response will include "a.b?c&d" as success along with "a.b.d" as failure.
+                if (id.includes('?')) {
+                    for (const individualTopic of splitIntoIndividualTopics(id)) {
+                        const hasIndividualTopicResult = result.hasOwnProperty(individualTopic);
+                        // Only use the combined topic result for this individual topic ID if there isn't already
+                        // a result for the individual topic itself. Exact topic result takes precedence.
+                        if (!hasIndividualTopicResult) {
+                            result[individualTopic] = result[id];
+                        }
+                    }
+                }
+            }
+            if (options.replace) {
+                this.bulkSubscriptions = {};
+            }
+            topics.forEach(topic => {
+                this.bulkSubscriptions[topic] = true;
+            });
+            this.internalSubscriptions.forEach(topic => {
+                this.bulkSubscriptions[topic] = true;
+            });
+            // Add a fallback result for any topic in the toSubscribe list that isn't already in result.
+            // With partial bulk resubscribe enabled missing result means "Unknown" state but when not
+            // enabled the fallback is "Permitted" for backward compatibility (success response means OK).
+            for (const topic of toSubscribe) {
+                (_b = result[topic]) !== null && _b !== void 0 ? _b : (result[topic] = { topic, state: this.enablePartialBulkResubscribe ? 'Unknown' : 'Permitted' });
+            }
+            return result;
+        });
+    }
+    get expose() {
+        return {
+            subscribe: this.subscribe.bind(this),
+            unsubscribe: this.unsubscribe.bind(this),
+            bulkSubscribe: this.bulkSubscribe.bind(this)
+        };
+    }
+}
+function isTopicSubscribeResult(value) {
+    let hasTopic = false;
+    let hasValidState = false;
+    if (value && typeof value === 'object') {
+        hasTopic = 'topic' in value && typeof value.topic === 'string';
+        hasValidState = 'state' in value && ['Permitted', 'Rejected', 'Unknown'].includes(value.state);
+    }
+    return hasTopic && hasValidState;
+}

package/dist/es/ping.d.ts

@@ -0,0 +1,21 @@
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+export interface PingOptions {
+    pingInterval?: number;
+    failedPingsBeforeDisconnect?: number;
+    jid?: string;
+}
+export declare class Ping {
+    private client;
+    private stanzaInstance;
+    private options;
+    private pingInterval;
+    private failedPingsBeforeDisconnect;
+    private numberOfFailedPings;
+    private nextPingTimeoutId;
+    constructor(client: Client, stanzaInstance: NamedAgent, options?: PingOptions);
+    start(): void;
+    stop(): void;
+    private performPing;
+    private queueNextPing;
+}

package/dist/es/ping.js

@@ -0,0 +1,68 @@
+'use strict';
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const DEFAULT_PING_INTERVAL = 14 * 1000;
+const DEFAULT_MAXIMUM_FAILED_PINGS_BEFORE_DISCONNECT = 1;
+export class Ping {
+    constructor(client, stanzaInstance, options = {}) {
+        this.client = client;
+        this.stanzaInstance = stanzaInstance;
+        this.options = options;
+        this.pingInterval = options.pingInterval || DEFAULT_PING_INTERVAL;
+        this.failedPingsBeforeDisconnect = options.failedPingsBeforeDisconnect || DEFAULT_MAXIMUM_FAILED_PINGS_BEFORE_DISCONNECT;
+        this.numberOfFailedPings = 0;
+        this.nextPingTimeoutId = undefined;
+        this.start();
+    }
+    start() {
+        if (!this.nextPingTimeoutId) {
+            this.nextPingTimeoutId = -1;
+            this.queueNextPing();
+        }
+    }
+    stop() {
+        clearTimeout(this.nextPingTimeoutId);
+        this.nextPingTimeoutId = undefined;
+        this.numberOfFailedPings = 0;
+    }
+    performPing() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.stanzaInstance.ping(this.options.jid);
+                this.numberOfFailedPings = 0;
+                this.queueNextPing();
+            }
+            catch (err) {
+                const info = {
+                    channelId: this.client.config.channelId,
+                    jid: this.stanzaInstance.jid,
+                    stanzaInstanceId: this.stanzaInstance.id
+                };
+                this.client.logger.warn('Missed a ping.', Object.assign({ error: err }, info));
+                /* if we have reached max number of missed pings, disconnect */
+                if (++this.numberOfFailedPings > this.failedPingsBeforeDisconnect) {
+                    this.client.logger.error('Missed too many pings, disconnecting', Object.assign({ numberOfFailedPings: this.numberOfFailedPings }, info));
+                    this.stanzaInstance.sendStreamError({ text: 'too many missed pongs', condition: 'connection-timeout' });
+                    this.stop();
+                    (_a = this.stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.disconnect(false);
+                }
+                else {
+                    this.queueNextPing();
+                }
+            }
+        });
+    }
+    queueNextPing() {
+        if (this.nextPingTimeoutId) {
+            this.nextPingTimeoutId = setTimeout(this.performPing.bind(this), this.pingInterval);
+        }
+    }
+}

package/dist/es/polyfills.js

@@ -0,0 +1,6 @@
+"use strict";
+/* istanbul ignore file */
+if (!global) {
+    // @ts-ignore
+    Object.defineProperty(window, 'crypto', { value: window.crypto || window.msCrypto, writable: false, configurable: false });
+}

package/dist/es/server-monitor.d.ts

@@ -0,0 +1,16 @@
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+export interface ServerMonitorOptions {
+    stanzaTimeout?: number;
+}
+export declare class ServerMonitor {
+    private client;
+    private stanzaInstance;
+    private stanzaTimeout;
+    private timeoutId?;
+    private boundSetupStanzaTimeout?;
+    constructor(client: Client, stanzaInstance: NamedAgent, options?: ServerMonitorOptions);
+    private start;
+    stop(): void;
+    private setupStanzaTimeout;
+}

package/dist/es/server-monitor.js

@@ -0,0 +1,41 @@
+'use strict';
+const DEFAULT_STANZA_TIMEOUT = 35 * 1000;
+export class ServerMonitor {
+    constructor(client, stanzaInstance, options = {}) {
+        this.client = client;
+        this.stanzaInstance = stanzaInstance;
+        this.stanzaTimeout = options.stanzaTimeout || DEFAULT_STANZA_TIMEOUT;
+        this.timeoutId = undefined;
+        this.start();
+    }
+    start() {
+        this.boundSetupStanzaTimeout = this.setupStanzaTimeout.bind(this);
+        this.client.on('connected', this.boundSetupStanzaTimeout);
+        this.stanzaInstance.on('raw:incoming', this.boundSetupStanzaTimeout);
+    }
+    stop() {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = undefined;
+        if (this.boundSetupStanzaTimeout) {
+            this.client.off('connected', this.boundSetupStanzaTimeout);
+            this.stanzaInstance.off('raw:incoming', this.boundSetupStanzaTimeout);
+            this.boundSetupStanzaTimeout = undefined;
+        }
+    }
+    setupStanzaTimeout() {
+        clearTimeout(this.timeoutId);
+        this.timeoutId = setTimeout(() => {
+            var _a;
+            const info = {
+                channelId: this.client.config.channelId,
+                jid: this.stanzaInstance.jid,
+                stanzaInstanceId: this.stanzaInstance.id,
+                timeout: this.stanzaTimeout
+            };
+            this.client.logger.error('Time between XMPP stanzas exceeded timeout, disconnecting', info);
+            this.stanzaInstance.sendStreamError({ text: 'time between stanzas exceeded timeout', condition: 'connection-timeout' });
+            this.stop();
+            (_a = this.stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.disconnect(false);
+        }, this.stanzaTimeout);
+    }
+}