genesys-cloud-streaming-client 13.5.0-develop.6 → 14.0.1-develop.9

package/dist/npm/reconnector.js

@@ -95,13 +95,15 @@ class Reconnector {
         });
         this._backoffActive = false;
     }
-    async hardReconnect() {
+    async hardReconnect(maxAttempts, interval = HARD_RECONNECT_RETRY_MS) {
         if (this._hardReconnectRetryInfo) {
             return this._hardReconnectRetryInfo.promise;
         }
         this.cleanupReconnect();
         this._hasConnected = false;
-        this._hardReconnectRetryInfo = utils_1.retryPromise(this._attemptHardReconnect.bind(this), this._shouldRetryError.bind(this), HARD_RECONNECT_RETRY_MS, this.client.logger);
+        this._hardReconnectRetryInfo = utils_1.retryPromise(this._attemptHardReconnect.bind(this), (error, retryCount) => {
+            return this._shouldRetryError(error, retryCount, maxAttempts);
+        }, interval, this.client.logger);
         try {
             await this._hardReconnectRetryInfo.promise;
             this._stopHardReconnect();
@@ -136,22 +138,32 @@ class Reconnector {
             if (typeof error === 'string') {
                 error = new Error(error);
             }
-            this._hardReconnectRetryInfo.cancel(error);
+            this._hardReconnectRetryInfo.reject(error);
         }
         else {
-            this._hardReconnectRetryInfo.complete();
+            this._hardReconnectRetryInfo.resolve();
         }
         this._hardReconnectRetryInfo = null;
     }
-    async _attemptHardReconnect() {
+    _attemptHardReconnect() {
         /* if we aren't online, don't retry the new channel */
         if (!navigator.onLine) {
             throw new Error(OFFLINE_ERROR);
         }
         this.client.logger.info('Attempting to reconnect with new channel.');
-        await this.client.connect();
+        return this.client.connect();
     }
-    _shouldRetryError(error) {
+    _shouldRetryError(error, attemptNumber, maxAttempts) {
+        if (typeof maxAttempts === 'number' && typeof attemptNumber === 'number') {
+            if (attemptNumber > maxAttempts) {
+                this.client.logger.debug('Max retry attempts reached trying to connect to new channel. Stopping retry', { attemptNumber, maxAttempts });
+                return false;
+            }
+            else {
+                this.client.logger.debug('Max retry attempts NOT reached trying to connect to new channel. Retrying', { attemptNumber, maxAttempts });
+                return true;
+            }
+        }
         /* we throw this is we are offline */
         if (error.message === OFFLINE_ERROR) {
             this.client.logger.debug('Browser is offline. Not attempting to reconnect with new channel.');

package/dist/npm/types/retry-utils.d.ts

@@ -0,0 +1,54 @@
+import WildEmitter from 'wildemitter';
+export interface IRetryConfig<T = any> {
+    /**
+     * Function to attempt until it completes or rejects based on the
+     *  criteria for retrying.
+     */
+    promiseFn: () => Promise<T>;
+    /**
+     * Retry criteria to retry the promise function on failure. Available options:
+     * - `boolean`: if `true`, it will _always_ be retried. if `false`, it will _never_
+     *  be retried.
+     * - `number`: max attempts to retry
+     * - `function`: a function that accepts the error thrown and determines if it
+     *  should be retried. It will be passed the `Error` and the `attemptCount`.
+     *
+     * Default: `false`
+     */
+    retry?: boolean | number | ((error?: Error | any, attemptCount?: number) => boolean);
+    /**
+     * Milliseconds to wait inbetween next retry of the promise function on failure.
+     *
+     * Default: `15000`
+     */
+    retryInterval?: number;
+}
+export declare class RetryPromise<T = any> extends WildEmitter {
+    promise: Promise<T>;
+    _id: string;
+    private _reject;
+    private _resolve;
+    private _hasCompleted;
+    private _attemptCount;
+    private _timeout;
+    private _config;
+    constructor(config: IRetryConfig);
+    /**
+     * @deprecated use `reject(reason)`
+     * @param reason value to reject the promise with
+     * @returns void
+     */
+    cancel(reason?: string | Error | any): void;
+    reject(reason?: string | Error | any): void;
+    /**
+     * @deprecated use `resolve(reason)`
+     * @param value to resolve the promise with
+     * @returns void
+     */
+    complete(value: T | PromiseLike<T>): void;
+    resolve(value: T | PromiseLike<T>): void;
+    hasCompleted(): boolean;
+    attemptCount(): number;
+    private _tryPromiseFn;
+}
+export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retry?: boolean | number | ((error?: Error | any, attemptCount?: number) => boolean), retryInterval?: number, _logger?: any): RetryPromise<T>;

package/dist/npm/types/retry-utils.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryPromise = exports.RetryPromise = void 0;
+const tslib_1 = require("tslib");
+const uuid_1 = require("uuid");
+const wildemitter_1 = tslib_1.__importDefault(require("wildemitter"));
+class RetryPromise extends wildemitter_1.default {
+    constructor(config) {
+        super();
+        this._id = uuid_1.v4();
+        this._hasCompleted = false;
+        this._attemptCount = 0;
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this._config = {
+            promiseFn: config.promiseFn,
+            retry: config.retry || false,
+            retryInterval: config.retryInterval !== undefined && config.retryInterval > -1 ? config.retryInterval : 15000
+        };
+        /* tslint:disable:no-floating-promises */
+        this._tryPromiseFn();
+    }
+    /**
+     * @deprecated use `reject(reason)`
+     * @param reason value to reject the promise with
+     * @returns void
+     */
+    cancel(reason) {
+        return this.reject(reason);
+    }
+    reject(reason) {
+        this._reject(reason);
+        clearTimeout(this._timeout);
+        this._hasCompleted = true;
+        this.emit('rejected', reason);
+    }
+    /**
+     * @deprecated use `resolve(reason)`
+     * @param value to resolve the promise with
+     * @returns void
+     */
+    complete(value) {
+        return this.resolve(value);
+    }
+    resolve(value) {
+        this._resolve(value);
+        clearTimeout(this._timeout);
+        this._hasCompleted = true;
+        this.emit('resolved', value);
+    }
+    hasCompleted() {
+        return this._hasCompleted;
+    }
+    attemptCount() {
+        return this._attemptCount;
+    }
+    async _tryPromiseFn() {
+        const { retry, retryInterval } = this._config;
+        try {
+            this._attemptCount++;
+            this.emit('trying', {
+                attemptCount: this._attemptCount,
+                promise: this.promise
+            });
+            const val = await this._config.promiseFn();
+            this.resolve(val);
+        }
+        catch (error) {
+            if (
+            /* always retry */
+            retry === true ||
+                /* retry if under max retry attempts */
+                typeof retry === 'number' && this._attemptCount <= retry ||
+                /* retry if retry function returns true */
+                typeof retry === 'function' && retry(error, this._attemptCount + 1)) {
+                this.emit('retrying', {
+                    error,
+                    attemptCount: this._attemptCount,
+                    retryInterval
+                });
+                this._timeout = setTimeout(this._tryPromiseFn.bind(this), retryInterval);
+                return;
+            }
+            this.reject(error);
+        }
+    }
+}
+exports.RetryPromise = RetryPromise;
+function retryPromise(promiseFn, retry, retryInterval = 15000, _logger = console) {
+    return new RetryPromise({ promiseFn, retry, retryInterval });
+}
+exports.retryPromise = retryPromise;

package/dist/npm/utils.d.ts

@@ -1,16 +1,9 @@
+export { retryPromise, RetryPromise } from './types/retry-utils';
 export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<void>;
 export declare function splitIntoIndividualTopics(topicString: string): string[];
 export declare const isAcdJid: (jid: string) => boolean;
 export declare const isScreenRecordingJid: (jid: string) => boolean;
 export declare const isSoftphoneJid: (jid: string) => boolean;
 export declare const isVideoJid: (jid: string) => boolean;
-export declare type RetryPromise<T = any> = {
-    promise: Promise<T>;
-    cancel: (reason?: string | Error) => void;
-    complete: (value?: T) => void;
-    hasCompleted: () => boolean;
-    _id: string;
-};
-export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retryFn: (error?: Error | any) => boolean, retryInterval?: number, logger?: any): RetryPromise<T>;
 export declare const parseJwt: (token: string) => any;
 export declare function calculatePayloadSize(trace: any): number;

package/dist/npm/utils.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = void 0;
-const uuid_1 = require("uuid");
+exports.calculatePayloadSize = exports.parseJwt = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = exports.RetryPromise = exports.retryPromise = void 0;
+var retry_utils_1 = require("./types/retry-utils");
+Object.defineProperty(exports, "retryPromise", { enumerable: true, get: function () { return retry_utils_1.retryPromise; } });
+Object.defineProperty(exports, "RetryPromise", { enumerable: true, get: function () { return retry_utils_1.RetryPromise; } });
 function timeoutPromise(fn, timeoutMs, msg, details) {
     return new Promise(function (resolve, reject) {
         const timeout = setTimeout(function () {
@@ -35,66 +37,27 @@ function splitIntoIndividualTopics(topicString) {
     return topics;
 }
 exports.splitIntoIndividualTopics = splitIntoIndividualTopics;
-exports.isAcdJid = function (jid) {
+const isAcdJid = function (jid) {
     return jid.startsWith('acd-');
 };
-exports.isScreenRecordingJid = function (jid) {
+exports.isAcdJid = isAcdJid;
+const isScreenRecordingJid = function (jid) {
     return jid.startsWith('screenrecording-');
 };
-exports.isSoftphoneJid = function (jid) {
+exports.isScreenRecordingJid = isScreenRecordingJid;
+const isSoftphoneJid = function (jid) {
     if (!jid) {
         return false;
     }
     return !!jid.match(/.*@.*gjoll.*/i);
 };
-exports.isVideoJid = function (jid) {
+exports.isSoftphoneJid = isSoftphoneJid;
+const isVideoJid = function (jid) {
     return !!(jid && jid.match(/@conference/) && !exports.isAcdJid(jid));
 };
-function retryPromise(promiseFn, retryFn, retryInterval = 15000, logger = console) {
-    let timeout;
-    let cancel;
-    let complete;
-    let tryPromiseFn;
-    let _hasCompleted = false;
-    const promise = new Promise((resolve, reject) => {
-        tryPromiseFn = async () => {
-            try {
-                const val = await promiseFn();
-                complete(val);
-            }
-            catch (error) {
-                if (retryFn(error)) {
-                    logger.debug('Retrying promise', error);
-                    timeout = setTimeout(tryPromiseFn, retryInterval);
-                }
-                else {
-                    cancel(error);
-                }
-            }
-        };
-        complete = (value) => {
-            clearTimeout(timeout);
-            _hasCompleted = true;
-            resolve(value);
-        };
-        cancel = (reason) => {
-            clearTimeout(timeout);
-            _hasCompleted = true;
-            reject(reason);
-        };
-        tryPromiseFn();
-    });
-    return {
-        promise,
-        cancel,
-        complete,
-        _id: uuid_1.v4(),
-        hasCompleted: () => _hasCompleted
-    };
-}
-exports.retryPromise = retryPromise;
+exports.isVideoJid = isVideoJid;
 // from https://stackoverflow.com/questions/38552003/how-to-decode-jwt-token-in-javascript
-exports.parseJwt = (token) => {
+const parseJwt = (token) => {
     const base64Url = token.split('.')[1];
     const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
     const jsonPayload = decodeURIComponent(window.atob(base64).split('').map(function (c) {
@@ -102,6 +65,7 @@ exports.parseJwt = (token) => {
     }).join(''));
     return JSON.parse(jsonPayload);
 };
+exports.parseJwt = parseJwt;
 function calculatePayloadSize(trace) {
     const str = JSON.stringify(trace);
     // http://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript

package/dist/npm/webrtc.d.ts

@@ -46,6 +46,7 @@ export declare class WebrtcExtension extends EventEmitter {
         sessionId: string;
         sessionType?: SessionTypes;
     };
+    flushStats(): void;
     sendStats(): Promise<void>;
     addEventListeners(): void;
     proxyEvents(): void;

package/dist/npm/webrtc.js

@@ -102,6 +102,10 @@ class WebrtcExtension extends events_1.EventEmitter {
     // This should be moved when the sdk is the primary consumer
     proxyStatsForSession(session) {
         session.on('stats', (statsEvent) => {
+            /* if our logger was stopped, we need to stop stats logging too */
+            if (this.client.logger['stopReason']) {
+                return;
+            }
             const statsCopy = JSON.parse(JSON.stringify(statsEvent));
             const extraDetails = {
                 conference: session.conversationId,
@@ -117,7 +121,7 @@ class WebrtcExtension extends events_1.EventEmitter {
             this.statBuffer += currentEventSize;
             // If it exceeds max size, don't append just send current payload.
             if (exceedsMaxStatSize) {
-                this.throttledSendStats.flush();
+                this.flushStats();
             }
             else {
                 this.throttledSendStats();
@@ -135,6 +139,9 @@ class WebrtcExtension extends events_1.EventEmitter {
         }
         return logDetails;
     }
+    flushStats() {
+        this.throttledSendStats.flush();
+    }
     async sendStats() {
         const statsToSend = [];
         let currentSize = 0;