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

package/dist/deploy-info.json

@@ -0,0 +1,21 @@
+{
+  "version": "20.1.0",
+  "build": "19",
+  "buildDate": "2026-09-11T05:12:04.713Z",
+  "indexFiles": [
+    {
+      "file": "v20.1.0/streaming-client.browser.js"
+    },
+    {
+      "file": "v20.1.0/streaming-client.browser.js.LICENSE.txt"
+    },
+    {
+      "file": "v20/streaming-client.browser.js"
+    },
+    {
+      "file": "v20/streaming-client.browser.js.LICENSE.txt"
+    }
+  ],
+  "team": "Client Streaming and Signaling",
+  "gcServiceName": "developercenter-cdn--streaming-client-webui"
+}

package/dist/es/alerting-leader.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { IClientOptions, ILeaderStatus, StreamingClientExtension } from './types/interfaces';
+import { Client } from './client';
+import { EventEmitter } from 'events';
+import { NamedAgent } from './types/named-agent';
+export declare class AlertingLeaderExtension extends EventEmitter implements StreamingClientExtension {
+    private client;
+    private connectionId?;
+    private alertableInteractionTypes;
+    private getLeaderAbortController?;
+    private leaderStatus;
+    private debouncedClaimAlertingLeader;
+    constructor(client: Client, options: IClientOptions);
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    private setupAlertingLeader;
+    private subscribeToAlertingLeader;
+    private markAsAlertable;
+    private getAlertingLeaderEarly;
+    private getAlertingLeader;
+    private claimAlertingLeader;
+    get expose(): AlertingLeaderApi;
+}
+export interface AlertingLeaderApi {
+    on: (event: string, handler: (...args: any) => void) => void;
+    off: (event: string, handler: (...args: any) => void) => void;
+    claimAlertingLeader(): Promise<void>;
+    getLeaderStatus(): ILeaderStatus;
+    leaderStatus: ILeaderStatus;
+}

package/dist/es/alerting-leader.js

@@ -0,0 +1,177 @@
+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 axios from 'axios';
+import debounce from 'debounce-promise';
+import { StreamingClientErrorTypes } from './types/interfaces';
+import { EventEmitter } from 'events';
+import { StreamingClientError, retryPromise } from './utils';
+export class AlertingLeaderExtension extends EventEmitter {
+    constructor(client, options) {
+        var _a;
+        super();
+        this.client = client;
+        this.leaderStatus = {};
+        this.alertableInteractionTypes = (_a = options.alertableInteractionTypes) !== null && _a !== void 0 ? _a : [];
+        this.debouncedClaimAlertingLeader = debounce(this.claimAlertingLeader.bind(this), 300);
+    }
+    handleStanzaInstanceChange(stanzaInstance) {
+        var _a, _b;
+        this.connectionId = (_b = (_a = stanzaInstance.transport) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.id;
+        this.setupAlertingLeader();
+    }
+    setupAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.alertableInteractionTypes.length !== 0) {
+                try {
+                    this.getAlertingLeaderEarly();
+                    yield this.subscribeToAlertingLeader();
+                    yield this.markAsAlertable();
+                    yield this.getAlertingLeader();
+                }
+                catch (err) {
+                    this.client.logger.warn('Failed to setup alerting leader; falling back to acting as the leader');
+                    // Fail 'open' so users don't miss calls
+                    this.leaderStatus = { voice: { alerting: true, configured: false } };
+                    this.emit('alertingLeaderChanged', this.leaderStatus);
+                }
+            }
+        });
+    }
+    subscribeToAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const topic = `v2.users.${this.client.config.userId}.alertingleader`;
+            this.client.on(`notify:${topic}`, (event) => {
+                var _a, _b;
+                (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+                if ((_b = event.eventBody) === null || _b === void 0 ? void 0 : _b.connectionId) {
+                    // The consuming client should be the one alerting if our connection is the current leader
+                    const alerting = event.eventBody.connectionId === this.connectionId;
+                    const clientType = event.eventBody.clientType;
+                    let voice = { alerting, configured: true };
+                    if (clientType) {
+                        voice = Object.assign(Object.assign({}, voice), { clientType });
+                    }
+                    this.leaderStatus = { voice };
+                    this.emit('alertingLeaderChanged', this.leaderStatus);
+                }
+            });
+            return this.client._notifications._subscribeInternal(topic);
+        });
+    }
+    markAsAlertable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const userId = this.client.config.userId;
+            const connectionsRequestOptions = {
+                method: 'patch',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                logger: this.client.logger,
+                data: {
+                    alertable: true
+                }
+            };
+            // STREAM-1204
+            // There's a race condition between the backend service knowing about the connection
+            // and us marking the connection as alertable. For now, we'll just retry with some delay.
+            const maxRetries = 16;
+            let retryCount = 0;
+            const retry = retryPromise(() => this.client.http.requestApi(`apps/users/${userId}/connections/${this.connectionId}`, connectionsRequestOptions), () => {
+                retryCount++;
+                if (retryCount >= maxRetries) {
+                    this.client.logger.info('Max retries reached for marking connection as alertable');
+                    return false;
+                }
+                return true;
+            }, 500, this.client.logger);
+            return retry.promise
+                .catch(() => {
+                this.client.logger.warn('Could not mark this connection as alertable');
+            });
+        });
+    }
+    getAlertingLeaderEarly() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.getAlertingLeader();
+            }
+            catch (error) {
+                if (axios.isAxiosError(error) && error.status === 400) {
+                    this.client.logger.info('The org has not configured alerting leader functionality or there are not yet any active alertable connections; falling back to acting as the leader');
+                    this.leaderStatus = { voice: { alerting: true, configured: false } };
+                    this.emit('alertingLeaderChanged', this.leaderStatus);
+                }
+            }
+        });
+    }
+    getAlertingLeader() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // If an early request is still in-flight, cancel it and get more recent data
+            (_a = this.getLeaderAbortController) === null || _a === void 0 ? void 0 : _a.abort();
+            this.getLeaderAbortController = new AbortController();
+            const leaderRequestOptions = {
+                method: 'get',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                logger: this.client.logger,
+                signal: this.getLeaderAbortController.signal
+            };
+            try {
+                const currentLeader = yield this.client.http.requestApiWithRetry('users/alertingleader', leaderRequestOptions, 1000).promise;
+                // The consuming client should be the one alerting if our connection is the current leader
+                const alerting = currentLeader.data.connectionId === this.connectionId;
+                const clientType = currentLeader.data.clientType;
+                let voice = { alerting, configured: true };
+                if (clientType) {
+                    voice = Object.assign(Object.assign({}, voice), { clientType });
+                }
+                this.leaderStatus = { voice };
+                this.emit('alertingLeaderChanged', this.leaderStatus);
+            }
+            catch (err) {
+                if (axios.isCancel(err)) {
+                    return;
+                }
+                throw err;
+            }
+        });
+    }
+    claimAlertingLeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.alertableInteractionTypes.length === 0) {
+                this.client.logger.info('This client is not configured for any alertable interactions and will not attempt to claim alerting leader');
+                throw new StreamingClientError(StreamingClientErrorTypes.generic, 'Unable to claim alerting leader; this client is not configured for any alertable interactions');
+            }
+            const leaderRequestOptions = {
+                method: 'put',
+                host: this.client.config.apiHost,
+                authToken: this.client.config.authToken,
+                logger: this.client.logger,
+                data: {
+                    connectionId: this.connectionId
+                }
+            };
+            return this.client.http.requestApi('users/alertingleader', leaderRequestOptions)
+                .catch((err) => {
+                this.client.logger.warn('Unable to claim alerting leader; this client may not alert for incoming interactions');
+                throw new StreamingClientError(StreamingClientErrorTypes.generic, 'Unable to claim alerting leader', err);
+            });
+        });
+    }
+    get expose() {
+        return {
+            on: this.on.bind(this),
+            off: this.off.bind(this),
+            claimAlertingLeader: this.debouncedClaimAlertingLeader,
+            getLeaderStatus: () => { return this.leaderStatus; },
+            leaderStatus: this.leaderStatus
+        };
+    }
+}

package/dist/es/client.d.ts

@@ -0,0 +1,84 @@
+/// <reference types="node" />
+import { Logger } from 'genesys-cloud-client-logger';
+import './polyfills';
+import { AlertingLeaderExtension, AlertingLeaderApi } from './alerting-leader';
+import { Notifications, NotificationsAPI } from './notifications';
+import { WebrtcExtension, WebrtcExtensionAPI } from './webrtc';
+import { Ping } from './ping';
+import { StreamingClientExtension } from './types/streaming-client-extension';
+import { HttpClient } from './http-client';
+import { IClientOptions, IClientConfig, StreamingClientConnectOptions } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+import EventEmitter from 'events';
+import { MessengerExtensionApi, MessengerExtension } from './messenger';
+export declare class Client extends EventEmitter {
+    activeStanzaInstance?: NamedAgent;
+    connected: boolean;
+    connecting: boolean;
+    hardReconnectRequired: boolean;
+    reconnectOnNoLongerSubscribed: boolean;
+    useServerSidePings: boolean;
+    logger: Logger;
+    config: IClientConfig;
+    isGuest: boolean;
+    backgroundAssistantMode: boolean;
+    private autoReconnect;
+    private cancelConnectionAttempt;
+    private extensions;
+    private connectionManager;
+    private channelReuses;
+    private backoffReductionTimer;
+    private hasMadeInitialAttempt;
+    private jidResource;
+    private boundStanzaDisconnect?;
+    private boundStanzaNoLongerSubscribed?;
+    private boundStanzaDuplicateId?;
+    http: HttpClient;
+    notifications: NotificationsAPI;
+    _notifications: Notifications;
+    webrtcSessions: WebrtcExtensionAPI;
+    _webrtcSessions: WebrtcExtension;
+    messenger: MessengerExtension;
+    _messenger: MessengerExtensionApi;
+    alertingLeader: AlertingLeaderApi;
+    _alertingLeader: AlertingLeaderExtension;
+    _ping: Ping;
+    constructor(options: IClientOptions);
+    private handleSendEventFromExtension;
+    private checkIsBackgroundAssistant;
+    private addInateEventHandlers;
+    private removeStanzaBoundEventHandlers;
+    private proxyStanzaEvents;
+    private handleStanzaDisconnectedEvent;
+    private handleNoLongerSubscribed;
+    private handleDuplicateId;
+    disconnect(): Promise<any>;
+    private getSessionStoreKey;
+    private getConnectionData;
+    private setConnectionData;
+    private increaseBackoff;
+    private decreaseBackoff;
+    private getStartingDelay;
+    connect(connectOpts?: StreamingClientConnectOptions): Promise<void>;
+    private backoffConnectRetryHandler;
+    private networkErrorNeedsAuth;
+    private saslErrorIsRetryable;
+    /**
+     * Performs an active network connectivity check by querying the API.
+     * navigator.onLine is unreliable (VPNs, virtual adapters, etc.), so we
+     * actually reach out to verify we can talk to the server.
+     *
+     * Returns true if connectivity is confirmed, false otherwise.
+     * This is advisory only — it does not gate connection attempts.
+     */
+    checkNetworkConnectivity(): Promise<boolean>;
+    private makeConnectionAttempt;
+    private setupConnectionMonitoring;
+    private prepareForConnect;
+    stopServerLogging(): void;
+    startServerLogging(): void;
+    setAccessToken(token: string): void;
+    static extend(namespace: any, extension: StreamingClientExtension | ((client: Client) => void)): void;
+    get version(): string;
+    static get version(): string;
+}