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

package/dist/cjs/notifications.js

@@ -0,0 +1,495 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Notifications = void 0;
+const debounce_promise_1 = __importDefault(require("debounce-promise"));
+const utils_1 = require("./utils");
+const _1 = require("./");
+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);
+}
+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 = (0, debounce_promise_1.default)(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);
+        });
+    }
+    async xmppSubscribe(topic) {
+        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;
+    }
+    async makeBulkSubscribeRequest(topics, options) {
+        // 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
+            });
+            await 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 = (0, utils_1.splitIntoIndividualTopics)(topic);
+        topics.forEach(t => {
+            const handlers = this.topicHandlers(t);
+            if (!handlers.includes(handler)) {
+                handlers.push(handler);
+            }
+        });
+    }
+    removeSubscription(topic, handler) {
+        const topics = (0, utils_1.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;
+            }
+        });
+    }
+    async subscribe(topic, handler, immediate, priority) {
+        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 = await 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 _1.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.
+     */
+    async _subscribeInternal(topic) {
+        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);
+    }
+    async bulkSubscribe(topics, options = { replace: false, force: false }, priorities = {}) {
+        var _a, _b;
+        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 = await 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 (0, utils_1.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)
+        };
+    }
+}
+exports.Notifications = Notifications;
+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/cjs/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/cjs/ping.js

@@ -0,0 +1,60 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ping = void 0;
+const DEFAULT_PING_INTERVAL = 14 * 1000;
+const DEFAULT_MAXIMUM_FAILED_PINGS_BEFORE_DISCONNECT = 1;
+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;
+    }
+    async performPing() {
+        var _a;
+        try {
+            await 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);
+        }
+    }
+}
+exports.Ping = Ping;

package/dist/cjs/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/cjs/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/cjs/server-monitor.js

@@ -0,0 +1,44 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerMonitor = void 0;
+const DEFAULT_STANZA_TIMEOUT = 35 * 1000;
+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);
+    }
+}
+exports.ServerMonitor = ServerMonitor;

package/dist/cjs/stanza-definitions/webrtc-signaling.d.ts

@@ -0,0 +1,29 @@
+import { DefinitionOptions } from 'stanza/jxt';
+import { Stanzas } from 'stanza';
+import { GenesysMediaMessage, GenesysWebrtcJsonRpcMessage } from '../types/interfaces';
+export interface Propose {
+    sessionId: string;
+    conversationId: string;
+    autoAnswer: boolean;
+    persistentConversationId?: string;
+    originalRoomJid?: string;
+    fromUserId?: string;
+    sdpOverXmpp?: boolean;
+    privAnswerMode?: 'Auto';
+}
+declare module 'stanza/protocol' {
+    interface IQPayload {
+        genesysWebrtc?: GenesysWebrtcJsonRpcMessage;
+    }
+    interface ReceivedMessage {
+        mediaMessage?: GenesysMediaMessage;
+    }
+}
+declare module 'stanza' {
+    interface AgentEvents {
+        'iq:set:genesysWebrtc': Stanzas.ReceivedIQ & {
+            genesysWebrtc: GenesysWebrtcJsonRpcMessage;
+        };
+    }
+}
+export declare const definitions: DefinitionOptions<any>[];