@simplito/privmx-webendpoint 2.5.1 → 2.6.0

package/extra/events.js

@@ -1,219 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventManager = exports.ConnectionEventsManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.BaseEventManager = void 0;
-class BaseEventManager {
-    _listeners; // event tag - "event@channel"
-    get listeners() {
-        return this._listeners;
-    }
-    channels;
-    constructor() {
-        this._listeners = new Map();
-        this.channels = new Set();
-    }
-    /**
-     * Checks whether the user is subscribed to given channel
-     * @param channel Channel
-     * @returns {boolean} `boolean`
-     */
-    isSubscribedToChannel(channel) {
-        return this.channels.has(channel);
-    }
-    hasEventsOnChannel(channel) {
-        return (Array.from(this._listeners.keys()).findIndex((listenerTag) => listenerTag.split('@')[1] === channel) !== -1);
-    }
-    /**
-     * Removes an event listeners from given `channel` and `eventType`
-     * @param {Channel} channel channel
-     * @param {string} eventType type of the event
-     * @param {function} callback callback function
-     */
-    removeEventListener = (channel, eventType, callback) => {
-        const eventTag = `${eventType}@${channel}`;
-        if (this._listeners.has(eventTag)) {
-            const channelCallbacks = this._listeners.get(eventTag);
-            const newCallback = channelCallbacks.filter((cb) => cb !== callback);
-            if (newCallback.length === 0) {
-                this._listeners.delete(eventTag);
-            }
-            else {
-                this._listeners.set(eventTag, newCallback);
-            }
-            if (!this.hasEventsOnChannel(channel)) {
-                this.channels.delete(channel);
-            }
-        }
-    };
-    /**
-     * Removes all listeners from given channel
-     * @param {Channel} channel channel
-     * @returns {void}
-     */
-    removeChannelEvents = (channel) => {
-        const listenersToRemove = Array.from(this._listeners.keys()).filter((listenerTag) => listenerTag.split('@')[1] === channel);
-        listenersToRemove.forEach((listenerTag) => {
-            this._listeners.delete(listenerTag);
-        });
-    };
-    dispatchEvent(event) {
-        if (event.type == 'libConnected' ||
-            event.type == 'libDisconnected' ||
-            event.type == 'libPlatformDisconnected') {
-            event.channel = `connection/${event.connectionId}`;
-        }
-        const eventTag = `${event.type}@${event.channel}`;
-        if (this._listeners.has(eventTag)) {
-            const callbacks = this._listeners.get(eventTag);
-            if (callbacks) {
-                callbacks.forEach((callback) => callback(event));
-            }
-        }
-    }
-    /**
-     * Add an event listeners on given channel and eventType
-     * @param {Channel} channel channel
-     * @param {string} eventType type of the event
-     * @param {function} callback callback function
-     * @returns {function} function to remove the event listeners
-     */
-    addEventListener = (channel, eventType, callback) => {
-        const eventTag = `${eventType}@${channel}`;
-        if (this._listeners.has(eventTag)) {
-            this._listeners.get(eventTag).push(callback);
-        }
-        else {
-            this._listeners.set(eventTag, [callback]);
-        }
-        this.channels.add(channel);
-        return () => {
-            this.removeEventListener(channel, eventType, callback);
-        };
-    };
-    addContainerListener = async (channel, eventType, callback) => {
-        if (!this.isSubscribedToChannel(channel)) {
-            await this.subscribeForModuleEvents();
-        }
-        const removeListener = this.addEventListener(channel, eventType, callback);
-        return async () => {
-            removeListener();
-            if (!this.hasEventsOnChannel(channel)) {
-                await this.unsubscribeFromModuleEvents();
-            }
-        };
-    };
-    addContainerElementListener = async (containerId, channel, eventType, callback) => {
-        if (!this.isSubscribedToChannel(channel)) {
-            await this.subscribeForModuleElementsEvents(containerId);
-        }
-        const removeListener = this.addEventListener(channel, eventType, callback);
-        return async () => {
-            removeListener();
-            if (!this.hasEventsOnChannel(channel)) {
-                await this.unsubscribeFromModuleElementsEvents(containerId);
-            }
-        };
-    };
-}
-exports.BaseEventManager = BaseEventManager;
-class ThreadEventsManager extends BaseEventManager {
-    threadApi;
-    constructor(threadApi) {
-        super();
-        this.threadApi = threadApi;
-    }
-    subscribeForModuleEvents() {
-        return this.threadApi.subscribeForThreadEvents();
-    }
-    subscribeForModuleElementsEvents(id) {
-        return this.threadApi.subscribeForMessageEvents(id);
-    }
-    unsubscribeFromModuleEvents() {
-        return this.threadApi.unsubscribeFromThreadEvents();
-    }
-    unsubscribeFromModuleElementsEvents(id) {
-        return this.threadApi.unsubscribeFromMessageEvents(id);
-    }
-    async onThreadEvent(handler) {
-        const channel = 'thread';
-        return this.addContainerListener(channel, handler.event, handler.callback);
-    }
-    async onMessageEvent(threadId, handler) {
-        const channel = `thread/${threadId}/messages`;
-        return this.addContainerElementListener(threadId, channel, handler.event, handler.callback);
-    }
-}
-exports.ThreadEventsManager = ThreadEventsManager;
-class StoreEventsManager extends BaseEventManager {
-    storeApi;
-    constructor(storeApi) {
-        super();
-        this.storeApi = storeApi;
-    }
-    subscribeForModuleEvents() { return this.storeApi.subscribeForStoreEvents(); }
-    subscribeForModuleElementsEvents(id) { return this.storeApi.subscribeForFileEvents(id); }
-    unsubscribeFromModuleEvents() { return this.storeApi.unsubscribeFromStoreEvents(); }
-    unsubscribeFromModuleElementsEvents(id) { return this.storeApi.unsubscribeFromFileEvents(id); }
-    async onStoreEvent(handler) {
-        const channel = 'store';
-        return this.addContainerListener(channel, handler.event, handler.callback);
-    }
-    async onFileEvent(storeId, handler) {
-        const channel = `store/${storeId}/files`;
-        return this.addContainerElementListener(storeId, channel, handler.event, handler.callback);
-    }
-}
-exports.StoreEventsManager = StoreEventsManager;
-class InboxEventsManager extends BaseEventManager {
-    inboxApi;
-    constructor(inboxApi) {
-        super();
-        this.inboxApi = inboxApi;
-    }
-    subscribeForModuleEvents() { return this.inboxApi.subscribeForInboxEvents(); }
-    subscribeForModuleElementsEvents(id) { return this.inboxApi.subscribeForEntryEvents(id); }
-    unsubscribeFromModuleEvents() { return this.inboxApi.unsubscribeFromInboxEvents(); }
-    unsubscribeFromModuleElementsEvents(id) { return this.inboxApi.unsubscribeFromEntryEvents(id); }
-    async onInboxEvent(handler) {
-        const channel = 'inbox';
-        return this.addContainerListener(channel, handler.event, handler.callback);
-    }
-    async onEntryEvent(inboxId, handler) {
-        const channel = `inbox/${inboxId}/entries`;
-        return this.addContainerElementListener(inboxId, channel, handler.event, handler.callback);
+exports.EventManager = void 0;
+const subscriptions_1 = require("./subscriptions");
+const managers_1 = require("./managers");
+function normalizeConnectionEvent(e) {
+    switch (e.type) {
+        case 'libDisconnected':
+            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionEventType.LIB_DISCONNECTED]}`] };
+        case 'libPlatformDisconnected':
+            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionEventType.LIB_PLATFORM_DISCONNECTED]}`] };
+        case 'libConnected':
+            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionEventType.LIB_CONNECTED]}`] };
+        default:
+            return e;
     }
 }
-exports.InboxEventsManager = InboxEventsManager;
-class ConnectionEventsManager extends BaseEventManager {
-    connectionId;
-    //Connection events don't have subscribe functions
-    subscribeForModuleEvents() {
-        return new Promise((resolve) => resolve());
-    }
-    subscribeForModuleElementsEvents() {
-        return new Promise((resolve) => resolve());
-    }
-    unsubscribeFromModuleEvents() {
-        return new Promise((resolve) => resolve());
-    }
-    unsubscribeFromModuleElementsEvents() {
-        return new Promise((resolve) => resolve());
-    }
-    constructor(connectionId) {
-        super();
-        this.connectionId = connectionId;
-    }
-    async onConnectionEvent(handler) {
-        const channel = `connection/${this.connectionId}`;
-        const removeListener = this.addContainerListener(channel, handler.event, handler.callback);
-        return removeListener;
-    }
-}
-exports.ConnectionEventsManager = ConnectionEventsManager;
 class EventManager {
     _isEventLoopRunning = false;
     dispatchers = [];
     eventsQueue = null;
-    constructor() { }
+    constructor() {
+    }
     listenForEvents() {
         if (this.eventsQueue) {
             this.eventsQueue.waitEvent().then((event) => {
@@ -241,28 +48,33 @@ class EventManager {
         this.dispatchers = [];
     };
     onEvent(event) {
-        this.dispatchers.forEach((cb) => cb(event));
+        this.dispatchers.forEach((cb) => cb(normalizeConnectionEvent(event)));
     }
     registerDispatcher(manager) {
         this.dispatchers.push((e) => manager.dispatchEvent(e));
     }
     getThreadEventManager(threadApi) {
-        const manager = new ThreadEventsManager(threadApi);
+        const manager = new managers_1.ThreadEventsManager(threadApi);
         this.registerDispatcher(manager);
         return manager;
     }
     getStoreEventManager(storeApi) {
-        const manager = new StoreEventsManager(storeApi);
+        const manager = new managers_1.StoreEventsManager(storeApi);
+        this.registerDispatcher(manager);
+        return manager;
+    }
+    getKvdbEventManager(kvdbApi) {
+        const manager = new managers_1.KvdbEventsManager(kvdbApi);
         this.registerDispatcher(manager);
         return manager;
     }
     getInboxEventManager(inboxApi) {
-        const manager = new InboxEventsManager(inboxApi);
+        const manager = new managers_1.InboxEventsManager(inboxApi);
         this.registerDispatcher(manager);
         return manager;
     }
     getConnectionEventManager(connectionId) {
-        const manager = new ConnectionEventsManager(connectionId);
+        const manager = new managers_1.ConnectionEventsManager(connectionId);
         this.registerDispatcher(manager);
         return manager;
     }

package/extra/files.d.ts

@@ -22,9 +22,9 @@ export declare class StreamReader {
      *
      * @returns {Promise<boolean>} A promise that resolves to true if there are more chunks to read, or false if the end of the file is reached.
      */
-    [Symbol.asyncIterator](): AsyncGenerator<readonly [Uint8Array, number], void, unknown>;
+    [Symbol.asyncIterator](): AsyncGenerator<readonly [Uint8Array<ArrayBufferLike>, number], void, unknown>;
     readNextChunk(): Promise<Uint8Array>;
-    getFileContent(): Promise<Uint8Array>;
+    getFileContent(): Promise<Uint8Array<ArrayBuffer>>;
     /**
      * Aborts the reading process and closes the file handle.
      *

package/extra/files.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadFile = exports.FileUploader = exports.StreamReader = exports.FILE_DEFAULT_CHUNK_SIZE = void 0;
+exports.FileUploader = exports.StreamReader = exports.FILE_DEFAULT_CHUNK_SIZE = void 0;
+exports.downloadFile = downloadFile;
 exports.FILE_DEFAULT_CHUNK_SIZE = 1_048_576;
 class StreamReader {
     _handle;
@@ -213,4 +214,3 @@ async function downloadFile(api, fileId, targetFileName) {
         reader.readAsDataURL(new Blob([fileBuffer]));
     }
 }
-exports.downloadFile = downloadFile;

package/extra/inbox.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendEntry = void 0;
+exports.sendEntry = sendEntry;
 const files_1 = require("./files");
 /**
  * Sends an entry to the specified inbox.
@@ -32,4 +32,3 @@ async function sendEntry(inboxApi, inboxId, payload) {
     await Promise.all(uploaders.map((uploader) => uploader.uploadFileContent()));
     await inboxApi.sendEntry(inboxEntryHandle);
 }
-exports.sendEntry = sendEntry;

package/extra/index.d.ts

@@ -1,10 +1,10 @@
 import * as Files from './files';
-import * as Events from './events';
-import { EventManager, ThreadEventsManager, StoreEventsManager, InboxEventsManager, BaseEventManager, ConnectionEventsManager, Channel, EventPayload, GenericEvent } from './events';
 import * as Utils from './utils';
 import * as Generics from './generics';
 import * as Inboxes from './inbox';
 import { FileUploader, StreamReader, downloadFile } from './files';
 import { PrivmxClient } from './PrivmxClient';
 import { PublicConnection } from './PublicConnection';
-export { Files, Inboxes, Events, Utils, Generics, FileUploader, downloadFile, EventManager, ThreadEventsManager, StoreEventsManager, InboxEventsManager, BaseEventManager, StreamReader, PrivmxClient, PublicConnection, Channel, ConnectionEventsManager, EventPayload, GenericEvent, };
+export { EventManager } from "./events";
+export { createInboxSubscription, createThreadSubscription, createConnectionSubscription, createKvdbSubscription, createStoreSubscription, EventCallback, Subscription } from "./subscriptions";
+export { Files, Inboxes, Utils, Generics, FileUploader, downloadFile, StreamReader, PrivmxClient, PublicConnection, };

package/extra/index.js

@@ -1,17 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionEventsManager = exports.PublicConnection = exports.PrivmxClient = exports.StreamReader = exports.BaseEventManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.EventManager = exports.downloadFile = exports.FileUploader = exports.Generics = exports.Utils = exports.Events = exports.Inboxes = exports.Files = void 0;
+exports.PublicConnection = exports.PrivmxClient = exports.StreamReader = exports.downloadFile = exports.FileUploader = exports.Generics = exports.Utils = exports.Inboxes = exports.Files = exports.createStoreSubscription = exports.createKvdbSubscription = exports.createConnectionSubscription = exports.createThreadSubscription = exports.createInboxSubscription = exports.EventManager = void 0;
 const Files = require("./files");
 exports.Files = Files;
-const Events = require("./events");
-exports.Events = Events;
-const events_1 = require("./events");
-Object.defineProperty(exports, "EventManager", { enumerable: true, get: function () { return events_1.EventManager; } });
-Object.defineProperty(exports, "ThreadEventsManager", { enumerable: true, get: function () { return events_1.ThreadEventsManager; } });
-Object.defineProperty(exports, "StoreEventsManager", { enumerable: true, get: function () { return events_1.StoreEventsManager; } });
-Object.defineProperty(exports, "InboxEventsManager", { enumerable: true, get: function () { return events_1.InboxEventsManager; } });
-Object.defineProperty(exports, "BaseEventManager", { enumerable: true, get: function () { return events_1.BaseEventManager; } });
-Object.defineProperty(exports, "ConnectionEventsManager", { enumerable: true, get: function () { return events_1.ConnectionEventsManager; } });
 const Utils = require("./utils");
 exports.Utils = Utils;
 const Generics = require("./generics");
@@ -26,3 +17,11 @@ const PrivmxClient_1 = require("./PrivmxClient");
 Object.defineProperty(exports, "PrivmxClient", { enumerable: true, get: function () { return PrivmxClient_1.PrivmxClient; } });
 const PublicConnection_1 = require("./PublicConnection");
 Object.defineProperty(exports, "PublicConnection", { enumerable: true, get: function () { return PublicConnection_1.PublicConnection; } });
+var events_1 = require("./events");
+Object.defineProperty(exports, "EventManager", { enumerable: true, get: function () { return events_1.EventManager; } });
+var subscriptions_1 = require("./subscriptions");
+Object.defineProperty(exports, "createInboxSubscription", { enumerable: true, get: function () { return subscriptions_1.createInboxSubscription; } });
+Object.defineProperty(exports, "createThreadSubscription", { enumerable: true, get: function () { return subscriptions_1.createThreadSubscription; } });
+Object.defineProperty(exports, "createConnectionSubscription", { enumerable: true, get: function () { return subscriptions_1.createConnectionSubscription; } });
+Object.defineProperty(exports, "createKvdbSubscription", { enumerable: true, get: function () { return subscriptions_1.createKvdbSubscription; } });
+Object.defineProperty(exports, "createStoreSubscription", { enumerable: true, get: function () { return subscriptions_1.createStoreSubscription; } });

package/extra/managers.d.ts

@@ -0,0 +1,98 @@
+import { Types } from "..";
+import { ConnectionEventType, EventCallback, SubscriberForInboxEvents, SubscriberForKvdbEvents, SubscriberForStoreEvents, SubscriberForThreadsEvents, Subscription } from "./subscriptions";
+/**
+ *
+ * General usage
+ *
+ * const fn1 = () =>{}
+ * const fn2 = () =>{}
+ *
+ * const fn3 = () =>{}
+ *
+ *
+ * const subscriptionA = createSubscription({
+ *  type: Types.ThreadEventType.THREAD_CREATE,
+ *  selector: Types.ThreadEventSelectorType.THREAD_CONTAINER,
+ *  selectorId: "s0dvos0div0smidvmsd"
+ *  callbacks: [fn1,fn2]
+ * })
+ *
+ * const subscriptionB = createThreadSubscribtion({
+ *  type: Types.ThreadEventType.MESSAGE_CREATED,
+ *  selector: Types.ThreadEventSelectorType.CONTEXT_CONTAINER,
+ *  selectorId: "s0dvos0div0smidvmsd"
+ *  callbacks: [fn3]
+ * })
+ *
+ * await manager.subscribeFor([subscriptionA, subscriptionB])
+ *
+ *
+ * await manager.unsubscribeFrom(subscriptionB)
+ *
+ * --- or ---
+ *
+ * await manager.removeCallback(subscriptionA.callbacks[0])
+ */
+export type Channel = "inbox" | `inbox/${string}/entries` | "store" | `store/${string}/files` | "thread" | `thread/${string}/messages` | `connection/${string}`;
+export interface GenericEvent<K> extends Types.Event {
+    /**
+     * Data associated with the event.
+     */
+    data: K;
+}
+export declare abstract class BaseEventDispatcherManager {
+    private _listenersSymbols;
+    private _listeners;
+    get listeners(): Map<string, EventCallback[]>;
+    protected abstract apiSubscribeFor(strings: string[]): Promise<string[]>;
+    protected abstract apiUnsubscribeFrom(strings: string[]): Promise<void>;
+    dispatchEvent(event: Types.Event): void;
+    unregisterCallback(symbol: Symbol): void;
+    protected prepareSubscription(channelList: string[], subscriptions: {
+        callbacks: EventCallback[];
+    }[]): Promise<string[]>;
+    unsubscribeFrom(subscriptionsId: string[]): Promise<void>;
+}
+export declare class ThreadEventsManager extends BaseEventDispatcherManager {
+    private threadApi;
+    constructor(threadApi: SubscriberForThreadsEvents);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(subscriptionId: string[]): Promise<void>;
+    subscribeFor(subscriptions: Subscription<Types.ThreadEventType, Types.ThreadEventSelectorType>[]): Promise<string[]>;
+}
+export declare class StoreEventsManager extends BaseEventDispatcherManager {
+    private storeApi;
+    constructor(storeApi: SubscriberForStoreEvents);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(subscriptionId: string[]): Promise<void>;
+    subscribeFor(subscriptions: Subscription<Types.StoreEventType, Types.StoreEventSelectorType>[]): Promise<string[]>;
+}
+export declare class InboxEventsManager extends BaseEventDispatcherManager {
+    private inboxApi;
+    constructor(inboxApi: SubscriberForInboxEvents);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(subscriptionId: string[]): Promise<void>;
+    subscribeFor(subscriptions: Subscription<Types.InboxEventType, Types.InboxEventSelectorType>[]): Promise<string[]>;
+}
+export declare class KvdbEventsManager extends BaseEventDispatcherManager {
+    private kvdbApi;
+    constructor(kvdbApi: SubscriberForKvdbEvents);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(subscriptionId: string[]): Promise<void>;
+    subscribeFor(subscriptions: Subscription<Types.KvdbEventType, Types.KvdbEventSelectorType>[]): Promise<string[]>;
+}
+export declare const ConnectionChannels: {
+    2: string;
+    0: string;
+    1: string;
+};
+export declare class ConnectionEventsManager extends BaseEventDispatcherManager {
+    private connectionId;
+    constructor(connectionId: string);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(): Promise<void>;
+    subscribeFor(subscriptions: {
+        type: ConnectionEventType;
+        callbacks: EventCallback[];
+    }[]): Promise<string[]>;
+}

package/extra/managers.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionEventsManager = exports.ConnectionChannels = exports.KvdbEventsManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.BaseEventDispatcherManager = void 0;
+const subscriptions_1 = require("./subscriptions");
+class BaseEventDispatcherManager {
+    _listenersSymbols = new Map();
+    _listeners = new Map();
+    get listeners() {
+        return this._listeners;
+    }
+    dispatchEvent(event) {
+        const callbacks = event.subscriptions.flatMap((s) => this._listeners.get(s));
+        for (const listener of callbacks) {
+            listener.callback(event);
+        }
+    }
+    unregisterCallback(symbol) {
+        this._listenersSymbols.delete(symbol);
+        for (const keys of this._listeners.keys()) {
+            const listeners = this._listeners.get(keys);
+            if (listeners) {
+                this._listeners.set(keys, listeners.filter((x) => x.symbol !== symbol));
+                if (this._listeners.get(keys).length === 0) {
+                    this._listeners.delete(keys);
+                }
+            }
+        }
+    }
+    async prepareSubscription(channelList, subscriptions) {
+        const subscriptionIds = await this.apiSubscribeFor(channelList);
+        subscriptionIds.forEach((id, i) => {
+            const subscription = subscriptions[i];
+            this._listeners.set(id, subscription.callbacks);
+            for (const cb of subscription.callbacks) {
+                this._listenersSymbols.set(cb.symbol, id);
+            }
+            return subscription;
+        });
+        return subscriptionIds;
+    }
+    async unsubscribeFrom(subscriptionsId) {
+        for (const subscriptionId of subscriptionsId) {
+            for (const [key, callbackSubscription,] of this._listenersSymbols.entries()) {
+                if (callbackSubscription === subscriptionId) {
+                    this.unregisterCallback(key);
+                }
+            }
+        }
+        return this.apiUnsubscribeFrom(subscriptionsId);
+    }
+}
+exports.BaseEventDispatcherManager = BaseEventDispatcherManager;
+class ThreadEventsManager extends BaseEventDispatcherManager {
+    threadApi;
+    constructor(threadApi) {
+        super();
+        this.threadApi = threadApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.threadApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.threadApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.threadApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.ThreadEventsManager = ThreadEventsManager;
+class StoreEventsManager extends BaseEventDispatcherManager {
+    storeApi;
+    constructor(storeApi) {
+        super();
+        this.storeApi = storeApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.storeApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.storeApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.storeApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.StoreEventsManager = StoreEventsManager;
+class InboxEventsManager extends BaseEventDispatcherManager {
+    inboxApi;
+    constructor(inboxApi) {
+        super();
+        this.inboxApi = inboxApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.inboxApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.inboxApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.inboxApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.InboxEventsManager = InboxEventsManager;
+class KvdbEventsManager extends BaseEventDispatcherManager {
+    kvdbApi;
+    constructor(kvdbApi) {
+        super();
+        this.kvdbApi = kvdbApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.kvdbApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.kvdbApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.kvdbApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.KvdbEventsManager = KvdbEventsManager;
+exports.ConnectionChannels = {
+    [subscriptions_1.ConnectionEventType.LIB_CONNECTED]: "channel/lib_connected",
+    [subscriptions_1.ConnectionEventType.LIB_DISCONNECTED]: "channel/lib_disconnected",
+    [subscriptions_1.ConnectionEventType.LIB_PLATFORM_DISCONNECTED]: "channel/lib_platform_disconnected",
+};
+class ConnectionEventsManager extends BaseEventDispatcherManager {
+    connectionId;
+    constructor(connectionId) {
+        super();
+        this.connectionId = connectionId;
+    }
+    apiSubscribeFor(channels) {
+        return Promise.resolve(channels);
+    }
+    apiUnsubscribeFrom() {
+        return Promise.resolve();
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = subscriptions.map((x) => {
+            return `${this.connectionId}/${subscriptions_1.ConnectionEventType[x.type]}`;
+        });
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.ConnectionEventsManager = ConnectionEventsManager;