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

package/dist/es/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="types/libs.d.ts" />
+import { Client } from './client';
+export * from './types/genesys-cloud-media-session';
+export * from './types/stanza-media-session';
+export * from './types/media-session';
+export * from './types/interfaces';
+export * from './messenger';
+export { HttpClient } from './http-client';
+export { StreamingClientError, StreamingSubscriptionError, parseJwt } from './utils';
+export default Client;

package/dist/es/index.js

@@ -0,0 +1,10 @@
+/// <reference path="types/libs.ts" />
+import { Client } from './client';
+export * from './types/genesys-cloud-media-session';
+export * from './types/stanza-media-session';
+export * from './types/media-session';
+export * from './types/interfaces';
+export * from './messenger';
+export { HttpClient } from './http-client';
+export { StreamingClientError, StreamingSubscriptionError, parseJwt } from './utils';
+export default Client;

package/dist/es/messenger.d.ts

@@ -0,0 +1,37 @@
+import { ReceivedMessage } from 'stanza/protocol';
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+import { GenesysMediaMessage, StreamingClientExtension } from './types/interfaces';
+import { Emitter } from 'strict-event-emitter';
+declare type MessageWithMediaMessage = {
+    from?: string;
+    id?: string;
+    to?: string;
+    mediaMessage: GenesysMediaMessage;
+};
+export declare type MediaMessageEvent = MessageWithMediaMessage & {
+    fromMyUser: boolean;
+    fromMyClient: boolean;
+};
+export declare type MessengerEvents = {
+    mediaMessage: [MediaMessageEvent];
+};
+export declare class MessengerExtension extends Emitter<MessengerEvents> implements StreamingClientExtension {
+    private client;
+    private stanzaInstance;
+    constructor(client: Client, stanzaInstance: NamedAgent);
+    get bareJid(): string;
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    isMediaMessage(msg: any): msg is MessageWithMediaMessage;
+    handleMessage(msg: ReceivedMessage): void;
+    /**
+     * @param msg
+     * @returns Promise<messageId>
+     */
+    broadcastMessage(msg: MessageWithMediaMessage): Promise<string>;
+    get expose(): MessengerExtensionApi;
+}
+export interface MessengerExtensionApi extends Pick<Emitter<MessengerEvents>, 'on' | 'off' | 'once' | 'addListener' | 'removeListener'> {
+    broadcastMessage(msg: MessageWithMediaMessage): Promise<string>;
+}
+export {};

package/dist/es/messenger.js

@@ -0,0 +1,62 @@
+'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());
+    });
+};
+import { Emitter } from 'strict-event-emitter';
+import { toBare } from 'stanza/JID';
+export class MessengerExtension extends Emitter {
+    constructor(client, stanzaInstance) {
+        super();
+        this.client = client;
+        this.stanzaInstance = stanzaInstance;
+    }
+    get bareJid() {
+        return toBare(this.stanzaInstance.jid);
+    }
+    handleStanzaInstanceChange(stanzaInstance) {
+        this.stanzaInstance = stanzaInstance;
+    }
+    isMediaMessage(msg) {
+        return !!msg.mediaMessage;
+    }
+    handleMessage(msg) {
+        if (!this.isMediaMessage(msg)) {
+            return;
+        }
+        const fromMyClient = msg.from === this.stanzaInstance.jid;
+        const fromMyUser = toBare(msg.from) === this.bareJid;
+        this.emit('mediaMessage', Object.assign(Object.assign({}, msg), { fromMyClient, fromMyUser }));
+    }
+    /**
+     * @param msg
+     * @returns Promise<messageId>
+     */
+    broadcastMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = globalThis.crypto.randomUUID();
+            msg.id = id;
+            msg.from = this.stanzaInstance.jid;
+            if (!msg.to) {
+                msg.to = this.bareJid;
+            }
+            yield this.stanzaInstance.send('message', msg);
+            return id;
+        });
+    }
+    get expose() {
+        return {
+            broadcastMessage: this.broadcastMessage.bind(this),
+            on: this.on.bind(this),
+            once: this.once.bind(this),
+            off: this.off.bind(this),
+            removeListener: this.removeListener.bind(this),
+            addListener: this.addListener.bind(this)
+        };
+    }
+}

package/dist/es/notifications.d.ts

@@ -0,0 +1,94 @@
+import { PubsubEvent, PubsubSubscription, PubsubSubscriptionWithOptions } from 'stanza/protocol';
+import { Client } from './client';
+import { IClientOptions, StreamingClientExtension } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+import { AxiosResponse } from 'axios';
+export declare class Notifications implements StreamingClientExtension {
+    client: Client;
+    stanzaInstance?: NamedAgent;
+    subscriptions: any;
+    bulkSubscriptions: any;
+    topicPriorities: any;
+    debouncedResubscribe: () => Promise<BulkSubscribeResult>;
+    enablePartialBulkResubscribe: boolean;
+    private internalSubscriptions;
+    private pendingBulkSubscribeRetry?;
+    private pendingConnectedWait?;
+    constructor(client: any, options?: IClientOptions);
+    get pubsubHost(): string;
+    handleStanzaInstanceChange(stanza: NamedAgent): void;
+    topicHandlers(topic: string): Array<(obj?: any) => void>;
+    pubsubEvent({ pubsub }: {
+        pubsub: PubsubEvent;
+    }): void;
+    xmppSubscribe(topic: string): Promise<PubsubSubscriptionWithOptions | void>;
+    xmppUnsubscribe(topic: string): Promise<PubsubSubscription | void>;
+    mapCombineTopics(topics: string[]): Array<{
+        id: string;
+    }>;
+    prioritizeTopicList(topics: Array<{
+        id: string;
+    }>): Array<{
+        id: string;
+    }>;
+    getTopicPriority(topic: string, returnDefault?: boolean): number;
+    truncateTopicList(topics: Array<{
+        id: string;
+    }>): Array<{
+        id: string;
+    }>;
+    makeBulkSubscribeRequest(topics: string[], options: any): Promise<AxiosResponse<ChannelTopicsEntityListing>>;
+    createSubscription(topic: string, handler: (obj?: any) => void): void;
+    removeSubscription(topic: string, handler: (obj?: any) => void): void;
+    removeTopicPriority(topic: string): void;
+    getActiveIndividualTopics(): string[];
+    resubscribe(): Promise<BulkSubscribeResult>;
+    subscriptionsKeepAlive(): void;
+    getTopicParts(topic: string): {
+        prefix: string;
+        postfixes: string[];
+    };
+    setTopicPriorities(priorities?: {}): void;
+    subscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean, priority?: number): Promise<TopicSubscribeResult>;
+    /**
+     * 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: string): Promise<PubsubSubscriptionWithOptions | void>;
+    unsubscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean): Promise<any>;
+    bulkSubscribe(topics: string[], options?: BulkSubscribeOpts, priorities?: {
+        [topicName: string]: number;
+    }): Promise<BulkSubscribeResult>;
+    get expose(): NotificationsAPI;
+}
+export interface NotificationsAPI {
+    subscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean, priority?: number): Promise<any>;
+    unsubscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean): Promise<any>;
+    bulkSubscribe(topics: string[], options?: BulkSubscribeOpts, priorities?: {
+        [topicName: string]: number;
+    }): Promise<any>;
+}
+export interface BulkSubscribeOpts {
+    replace?: boolean;
+    force?: boolean;
+}
+export interface BulkSubscribeResult {
+    [topic: string]: TopicSubscribeResult;
+}
+export interface TopicSubscribeResult {
+    topic: string;
+    state: 'Permitted' | 'Rejected' | 'Unknown';
+    rejectionReason?: string;
+    missingPermissions?: string[];
+}
+export interface ChannelTopicResponseEntity {
+    id: string;
+    state: 'Permitted' | 'Rejected';
+    rejectionReason?: string;
+    missingPermissions?: string[];
+    selfUri?: string;
+}
+export interface ChannelTopicsEntityListing {
+    entities: ChannelTopicResponseEntity[];
+}