@simplito/privmx-webendpoint 2.6.2 → 2.6.3

package/extra/PrivmxClient.d.ts

@@ -1,6 +1,6 @@
 import { Connection, CryptoApi, EventQueue, InboxApi, StoreApi, ThreadApi, KvdbApi, EventApi } from '../service';
 import { PublicConnection } from './PublicConnection';
-import { ConnectionEventsManager, InboxEventsManager, StoreEventsManager, ThreadEventsManager } from "./managers";
+import { ConnectionEventsManager, CustomEventsManager, InboxEventsManager, StoreEventsManager, ThreadEventsManager, UserEventsManager } from "./managers";
 import { EventManager } from "./events";
 /**
  * @class PrivmxClient
@@ -39,9 +39,11 @@ export declare class PrivmxClient {
     private kvdbApi;
     private eventApi;
     private connectionEventManager;
+    private userEventManager;
     private threadEventManager;
     private storeEventManager;
     private inboxEventManager;
+    private customEventsManager;
     /**
      * @constructor
      * @param {Connection} connection - The connection object.
@@ -123,6 +125,11 @@ export declare class PrivmxClient {
      * @returns {Promise<ConnectionEventsManager>}
      */
     getConnectionEventManager(): Promise<ConnectionEventsManager>;
+    /**
+     * @description Gets the User Event Manager.
+     * @returns {Promise<UserEventsManager>}
+     */
+    getUserEventsManager(): Promise<UserEventsManager>;
     /**
      * @description Gets the Thread Event Manager.
      * @returns {Promise<ThreadEventsManager>}
@@ -138,6 +145,11 @@ export declare class PrivmxClient {
      * @returns {Promise<InboxEventsManager>}
      */
     getInboxEventManager(): Promise<InboxEventsManager>;
+    /**
+     * @description Gets the Custom Events Manager.
+     * @returns {Promise<CustomEventsManager>}
+     */
+    getCustomEventsManager(): Promise<CustomEventsManager>;
     /**
      * @description Disconnects from the PrivMX bridge.
      * @returns {Promise<void>}

package/extra/PrivmxClient.js

@@ -41,9 +41,11 @@ class PrivmxClient {
     kvdbApi = null;
     eventApi = null;
     connectionEventManager = null;
+    userEventManager = null;
     threadEventManager = null;
     storeEventManager = null;
     inboxEventManager = null;
+    customEventsManager = null;
     /**
      * @constructor
      * @param {Connection} connection - The connection object.
@@ -229,11 +231,25 @@ class PrivmxClient {
         this.connectionEventManager = (async () => {
             const eventManager = await PrivmxClient.getEventManager();
             const connection = this.getConnection();
-            const connectionId = (await connection.getConnectionId());
-            return eventManager.getConnectionEventManager(connectionId);
+            const connectionId = await connection.getConnectionId();
+            return eventManager.getConnectionEventManager(`${connectionId}`);
         })();
         return this.connectionEventManager;
     }
+    /**
+     * @description Gets the User Event Manager.
+     * @returns {Promise<UserEventsManager>}
+     */
+    async getUserEventsManager() {
+        if (this.userEventManager) {
+            return this.userEventManager;
+        }
+        this.userEventManager = (async () => {
+            const eventManager = await PrivmxClient.getEventManager();
+            return eventManager.getUserEventsManager(this.getConnection());
+        })();
+        return this.userEventManager;
+    }
     /**
      * @description Gets the Thread Event Manager.
      * @returns {Promise<ThreadEventsManager>}
@@ -276,6 +292,20 @@ class PrivmxClient {
         })();
         return this.inboxEventManager;
     }
+    /**
+     * @description Gets the Custom Events Manager.
+     * @returns {Promise<CustomEventsManager>}
+     */
+    async getCustomEventsManager() {
+        if (this.customEventsManager) {
+            return this.customEventsManager;
+        }
+        this.customEventsManager = (async () => {
+            const eventManager = await PrivmxClient.getEventManager();
+            return eventManager.getCustomEventsManager(await this.getEventApi());
+        })();
+        return this.customEventsManager;
+    }
     /**
      * @description Disconnects from the PrivMX bridge.
      * @returns {Promise<void>}
@@ -287,6 +317,8 @@ class PrivmxClient {
             this.storeApi = null;
             this.inboxApi = null;
             this.connectionEventManager = null;
+            this.customEventsManager = null;
+            this.userEventManager = null;
             this.threadEventManager = null;
             this.storeEventManager = null;
             this.inboxEventManager = null;

package/extra/__mocks__/constants.d.ts

@@ -1,3 +1,4 @@
+import { Types } from "../../index";
 export declare function createBaseEvent(subsId: string): {
     type: string;
     data: {};
@@ -61,3 +62,7 @@ export declare const MOCK_THREAD_MESSAGE_DELETED_EVENT: (threadID: string, subsI
     readonly version: number;
     readonly timestamp: number;
 };
+export declare const MOCK_CONNECTION_USER_ADDED_EVENT: (subsId: string) => Types.Event;
+export declare const MOCK_CONNECTION_USER_STATUS_EVENT: (subsId: string) => Types.Event;
+export declare const MOCK_LIB_CONNECTED_EVENT: (connectionId: number) => Types.Event;
+export declare const MOCK_CUSTOM_EVENT: (subsId: string, contextId?: string, channelName?: string) => Types.Event;

package/extra/__mocks__/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MOCK_THREAD_MESSAGE_DELETED_EVENT = exports.MOCK_THREAD_CREATED_EVENT = exports.MOCK_STORE_FILE_DELETED_EVENT = exports.MOCK_STORE_CREATED_EVENT = exports.MOCK_INBOX_ENTRY_DELETED_EVENT = exports.MOCK_INBOX_CREATED_EVENT = void 0;
+exports.MOCK_CUSTOM_EVENT = exports.MOCK_LIB_CONNECTED_EVENT = exports.MOCK_CONNECTION_USER_STATUS_EVENT = exports.MOCK_CONNECTION_USER_ADDED_EVENT = exports.MOCK_THREAD_MESSAGE_DELETED_EVENT = exports.MOCK_THREAD_CREATED_EVENT = exports.MOCK_STORE_FILE_DELETED_EVENT = exports.MOCK_STORE_CREATED_EVENT = exports.MOCK_INBOX_ENTRY_DELETED_EVENT = exports.MOCK_INBOX_CREATED_EVENT = void 0;
 exports.createBaseEvent = createBaseEvent;
 function createBaseEvent(subsId) {
     return {
@@ -49,3 +49,54 @@ const MOCK_THREAD_MESSAGE_DELETED_EVENT = (threadID, subsId) => ({
     channel: `thread/${threadID}/messages`,
 });
 exports.MOCK_THREAD_MESSAGE_DELETED_EVENT = MOCK_THREAD_MESSAGE_DELETED_EVENT;
+const MOCK_CONNECTION_USER_ADDED_EVENT = (subsId) => ({
+    ...createBaseEvent(subsId),
+    type: "contextUserAdded",
+    channel: "context/userAdded",
+    data: {
+        contextId: "ctx-1",
+        user: {
+            userId: "user-1",
+            pubKey: "pub-1",
+        },
+    },
+});
+exports.MOCK_CONNECTION_USER_ADDED_EVENT = MOCK_CONNECTION_USER_ADDED_EVENT;
+const MOCK_CONNECTION_USER_STATUS_EVENT = (subsId) => ({
+    ...createBaseEvent(subsId),
+    type: "contextUserStatusChanged",
+    channel: "context/userStatus",
+    data: {
+        contextId: "ctx-1",
+        users: [
+            {
+                user: {
+                    userId: "user-1",
+                    pubKey: "pub-1",
+                },
+                action: "login",
+            },
+        ],
+    },
+});
+exports.MOCK_CONNECTION_USER_STATUS_EVENT = MOCK_CONNECTION_USER_STATUS_EVENT;
+const MOCK_LIB_CONNECTED_EVENT = (connectionId) => ({
+    ...createBaseEvent("ignored"),
+    type: "libConnected",
+    channel: "channel/lib_connected",
+    connectionId,
+});
+exports.MOCK_LIB_CONNECTED_EVENT = MOCK_LIB_CONNECTED_EVENT;
+const MOCK_CUSTOM_EVENT = (subsId, contextId = "ctx-1", channelName = "custom-channel") => ({
+    ...createBaseEvent(subsId),
+    type: "contextCustom",
+    channel: `context/${contextId}/${channelName}`,
+    data: {
+        contextId,
+        userId: "user-1",
+        payload: new Uint8Array([1, 2, 3]),
+        statusCode: 0,
+        schemaVersion: 5,
+    },
+});
+exports.MOCK_CUSTOM_EVENT = MOCK_CUSTOM_EVENT;

package/extra/__tests__/connectionEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/connectionEventManager.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../__mocks__/constants");
+const utils_1 = require("../__mocks__/utils");
+const subscriptions_1 = require("../subscriptions");
+describe("Connection event manager", () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let connectionEventsManager;
+    beforeEach(() => {
+        let { q: _q, manager: _manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        manager = _manager;
+        connectionEventsManager = manager.getConnectionEventManager("1");
+    });
+    it("supports legacy lib connection events", async () => {
+        const callback = jest.fn();
+        const libSubscription = (0, subscriptions_1.createConnectionSubscription)({
+            type: subscriptions_1.ConnectionStatusEventType.LIB_CONNECTED,
+            callbacks: [callback],
+        });
+        const [libSubscriptionId] = await connectionEventsManager.subscribeFor([
+            libSubscription,
+        ]);
+        expect(libSubscriptionId).toBe("1/channel/lib_connected");
+        q.dispatchEvent((0, constants_1.MOCK_LIB_CONNECTED_EVENT)(1));
+        await (0, utils_1.waitForNextTick)();
+        expect(callback).toHaveBeenCalledTimes(1);
+    });
+});

package/extra/__tests__/customEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/customEventManager.test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+const constants_1 = require("../__mocks__/constants");
+const mockContainerSubscriber_1 = require("../__mocks__/mockContainerSubscriber");
+const utils_1 = require("../__mocks__/utils");
+const subscriptions_1 = require("../subscriptions");
+describe("Custom event manager", () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let customEventsManager = manager.getCustomEventsManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
+    beforeEach(() => {
+        let { q: _q, manager: _manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        manager = _manager;
+        customEventsManager = _manager.getCustomEventsManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
+    });
+    it("dispatches custom events to registered callbacks", async () => {
+        const subscriber = new mockContainerSubscriber_1.MockContainerSubscriber(q);
+        const buildQuerySpy = jest
+            .spyOn(subscriber, "buildSubscriptionQuery")
+            .mockImplementation(async (channel, selector, selectorId) => {
+            expect(channel).toBe("custom-channel");
+            expect(selector).toBe(index_1.Types.EventsEventSelectorType.CONTEXT_ID);
+            expect(selectorId).toBe("ctx-1");
+            return `${channel}|${selectorId}`;
+        });
+        const managerWithSpy = manager.getCustomEventsManager(subscriber);
+        const callback = jest.fn();
+        const subscription = (0, subscriptions_1.createEventSubscription)({
+            channel: "custom-channel",
+            selector: index_1.Types.EventsEventSelectorType.CONTEXT_ID,
+            id: "ctx-1",
+            callbacks: [callback],
+        });
+        const [subscriptionId] = await managerWithSpy.subscribeFor([subscription]);
+        expect(buildQuerySpy).toHaveBeenCalled();
+        q.dispatchEvent((0, constants_1.MOCK_CUSTOM_EVENT)(subscriptionId));
+        await (0, utils_1.waitForNextTick)();
+        expect(callback).toHaveBeenCalledTimes(1);
+        const eventArg = callback.mock.calls[0][0];
+        expect(eventArg.data).toEqual({
+            contextId: "ctx-1",
+            userId: "user-1",
+            payload: new Uint8Array([1, 2, 3]),
+            statusCode: 0,
+            schemaVersion: 5,
+        });
+    });
+    it("stops invoking callbacks after unsubscribe", async () => {
+        const callback = jest.fn();
+        const subscription = (0, subscriptions_1.createEventSubscription)({
+            channel: "custom-channel",
+            selector: index_1.Types.EventsEventSelectorType.CONTEXT_ID,
+            id: "ctx-1",
+            callbacks: [callback],
+        });
+        const [subscriptionId] = await customEventsManager.subscribeFor([
+            subscription,
+        ]);
+        await customEventsManager.unsubscribeFrom([subscriptionId]);
+        q.dispatchEvent((0, constants_1.MOCK_CUSTOM_EVENT)(subscriptionId));
+        await (0, utils_1.waitForNextTick)();
+        expect(callback).not.toHaveBeenCalled();
+    });
+});

package/extra/__tests__/userEventManager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/extra/__tests__/userEventManager.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../index");
+const constants_1 = require("../__mocks__/constants");
+const mockContainerSubscriber_1 = require("../__mocks__/mockContainerSubscriber");
+const utils_1 = require("../__mocks__/utils");
+const subscriptions_1 = require("../subscriptions");
+describe("User event manager", () => {
+    let { q, manager } = (0, utils_1.createTestSetup)();
+    let userEventsManager;
+    beforeEach(() => {
+        let { q: _q, manager: _manager } = (0, utils_1.createTestSetup)();
+        q = _q;
+        manager = _manager;
+        userEventsManager = manager.getUserEventsManager(new mockContainerSubscriber_1.MockContainerSubscriber(q));
+    });
+    it("dispatches user events to registered callbacks", async () => {
+        const callback = jest.fn();
+        const subscription = (0, subscriptions_1.createUserEventSubscription)({
+            type: index_1.Types.ConnectionEventType.USER_ADD,
+            selector: index_1.Types.ConnectionEventSelectorType.CONTEXT_ID,
+            id: "ctx-1",
+            callbacks: [callback],
+        });
+        const [subscriptionId] = await userEventsManager.subscribeFor([
+            subscription,
+        ]);
+        q.dispatchEvent((0, constants_1.MOCK_CONNECTION_USER_ADDED_EVENT)(subscriptionId));
+        await (0, utils_1.waitForNextTick)();
+        expect(callback).toHaveBeenCalledTimes(1);
+        expect(callback.mock.calls[0][0].data).toEqual({
+            contextId: "ctx-1",
+            user: { userId: "user-1", pubKey: "pub-1" },
+        });
+    });
+    it("stops invoking callbacks after unsubscribe", async () => {
+        const callback = jest.fn();
+        const subscription = (0, subscriptions_1.createUserEventSubscription)({
+            type: index_1.Types.ConnectionEventType.USER_STATUS,
+            selector: index_1.Types.ConnectionEventSelectorType.CONTEXT_ID,
+            id: "ctx-1",
+            callbacks: [callback],
+        });
+        const [subscriptionId] = await userEventsManager.subscribeFor([
+            subscription,
+        ]);
+        await userEventsManager.unsubscribeFrom([subscriptionId]);
+        q.dispatchEvent((0, constants_1.MOCK_CONNECTION_USER_STATUS_EVENT)(subscriptionId));
+        await (0, utils_1.waitForNextTick)();
+        expect(callback).not.toHaveBeenCalled();
+    });
+});

package/extra/events.d.ts

@@ -1,6 +1,6 @@
 import { Types } from "..";
-import { SubscriberForInboxEvents, SubscriberForKvdbEvents, SubscriberForStoreEvents, SubscriberForThreadsEvents } from "./subscriptions";
-import { BaseEventDispatcherManager, ConnectionEventsManager, InboxEventsManager, KvdbEventsManager, StoreEventsManager, ThreadEventsManager } from "./managers";
+import { SubscriberForInboxEvents, SubscriberForUserEvents, SubscriberForEvents, SubscriberForKvdbEvents, SubscriberForStoreEvents, SubscriberForThreadsEvents } from "./subscriptions";
+import { BaseEventDispatcherManager, ConnectionEventsManager, CustomEventsManager, InboxEventsManager, KvdbEventsManager, StoreEventsManager, ThreadEventsManager, UserEventsManager } from "./managers";
 export declare class EventManager {
     private _isEventLoopRunning;
     dispatchers: ((event: Types.Event) => void)[];
@@ -18,5 +18,7 @@ export declare class EventManager {
     getStoreEventManager(storeApi: SubscriberForStoreEvents): StoreEventsManager;
     getKvdbEventManager(kvdbApi: SubscriberForKvdbEvents): KvdbEventsManager;
     getInboxEventManager(inboxApi: SubscriberForInboxEvents): InboxEventsManager;
+    getCustomEventsManager(eventApi: SubscriberForEvents): CustomEventsManager;
     getConnectionEventManager(connectionId: string): ConnectionEventsManager;
+    getUserEventsManager(connectionApi: SubscriberForUserEvents): UserEventsManager;
 }

package/extra/events.js

@@ -6,11 +6,11 @@ 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]}`] };
+            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_DISCONNECTED]}`] };
         case 'libPlatformDisconnected':
-            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionEventType.LIB_PLATFORM_DISCONNECTED]}`] };
+            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_PLATFORM_DISCONNECTED]}`] };
         case 'libConnected':
-            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionEventType.LIB_CONNECTED]}`] };
+            return { ...e, subscriptions: [`${e.connectionId}/${managers_1.ConnectionChannels[subscriptions_1.ConnectionStatusEventType.LIB_CONNECTED]}`] };
         default:
             return e;
     }
@@ -73,10 +73,20 @@ class EventManager {
         this.registerDispatcher(manager);
         return manager;
     }
+    getCustomEventsManager(eventApi) {
+        const manager = new managers_1.CustomEventsManager(eventApi);
+        this.registerDispatcher(manager);
+        return manager;
+    }
     getConnectionEventManager(connectionId) {
         const manager = new managers_1.ConnectionEventsManager(connectionId);
         this.registerDispatcher(manager);
         return manager;
     }
+    getUserEventsManager(connectionApi) {
+        const manager = new managers_1.UserEventsManager(connectionApi);
+        this.registerDispatcher(manager);
+        return manager;
+    }
 }
 exports.EventManager = EventManager;

package/extra/index.d.ts

@@ -6,5 +6,5 @@ import { FileUploader, StreamReader, downloadFile } from './files';
 import { PrivmxClient } from './PrivmxClient';
 import { PublicConnection } from './PublicConnection';
 export { EventManager } from "./events";
-export { createInboxSubscription, createThreadSubscription, createConnectionSubscription, createKvdbSubscription, createStoreSubscription, EventCallback, Subscription } from "./subscriptions";
+export { createInboxSubscription, createThreadSubscription, createConnectionSubscription, createUserEventSubscription, createKvdbSubscription, createStoreSubscription, createEventSubscription, EventCallback, Subscription, ConnectionStatusEventType, ConnectionSubscription, } from "./subscriptions";
 export { Files, Inboxes, Utils, Generics, FileUploader, downloadFile, StreamReader, PrivmxClient, PublicConnection, };

package/extra/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+exports.PublicConnection = exports.PrivmxClient = exports.StreamReader = exports.downloadFile = exports.FileUploader = exports.Generics = exports.Utils = exports.Inboxes = exports.Files = exports.ConnectionStatusEventType = exports.createEventSubscription = exports.createStoreSubscription = exports.createKvdbSubscription = exports.createUserEventSubscription = exports.createConnectionSubscription = exports.createThreadSubscription = exports.createInboxSubscription = exports.EventManager = void 0;
 const Files = require("./files");
 exports.Files = Files;
 const Utils = require("./utils");
@@ -23,5 +23,8 @@ 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, "createUserEventSubscription", { enumerable: true, get: function () { return subscriptions_1.createUserEventSubscription; } });
 Object.defineProperty(exports, "createKvdbSubscription", { enumerable: true, get: function () { return subscriptions_1.createKvdbSubscription; } });
 Object.defineProperty(exports, "createStoreSubscription", { enumerable: true, get: function () { return subscriptions_1.createStoreSubscription; } });
+Object.defineProperty(exports, "createEventSubscription", { enumerable: true, get: function () { return subscriptions_1.createEventSubscription; } });
+Object.defineProperty(exports, "ConnectionStatusEventType", { enumerable: true, get: function () { return subscriptions_1.ConnectionStatusEventType; } });

package/extra/managers.d.ts

@@ -1,5 +1,5 @@
 import { Types } from "..";
-import { ConnectionEventType, EventCallback, SubscriberForInboxEvents, SubscriberForKvdbEvents, SubscriberForStoreEvents, SubscriberForThreadsEvents, Subscription } from "./subscriptions";
+import { ConnectionStatusEventType, ConnectionSubscription, EventCallback, SubscriberForEvents, SubscriberForInboxEvents, SubscriberForKvdbEvents, SubscriberForStoreEvents, SubscriberForThreadsEvents, SubscriberForUserEvents, Subscription } from "./subscriptions";
 /**
  *
  * General usage
@@ -33,7 +33,7 @@ import { ConnectionEventType, EventCallback, SubscriberForInboxEvents, Subscribe
  *
  * await manager.removeCallback(subscriptionA.callbacks[0])
  */
-export type Channel = "inbox" | `inbox/${string}/entries` | "store" | `store/${string}/files` | "thread" | `thread/${string}/messages` | `connection/${string}`;
+export type Channel = "inbox" | `inbox/${string}/entries` | "store" | `store/${string}/files` | "thread" | `thread/${string}/messages` | `connection/${string}` | "context/userAdded" | "context/userRemoved" | "context/userStatus" | `context/${string}/${string}`;
 export interface GenericEvent<K> extends Types.Event {
     /**
      * Data associated with the event.
@@ -81,18 +81,25 @@ export declare class KvdbEventsManager extends BaseEventDispatcherManager {
     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 CustomEventsManager extends BaseEventDispatcherManager {
+    private eventsApi;
+    constructor(eventsApi: SubscriberForEvents);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(subscriptionId: string[]): Promise<void>;
+    subscribeFor(subscriptions: Subscription<string, Types.EventsEventSelectorType>[]): Promise<string[]>;
+}
+export declare const ConnectionChannels: Record<ConnectionStatusEventType, 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[]>;
+    subscribeFor(subscriptions: ConnectionSubscription[]): Promise<string[]>;
+}
+export declare class UserEventsManager extends BaseEventDispatcherManager {
+    private userEventsApi;
+    constructor(userEventsApi: SubscriberForUserEvents);
+    protected apiSubscribeFor(channels: string[]): Promise<string[]>;
+    protected apiUnsubscribeFrom(subscriptionId: string[]): Promise<void>;
+    subscribeFor(subscriptions: Subscription<Types.ConnectionEventType, Types.ConnectionEventSelectorType>[]): Promise<string[]>;
 }

package/extra/managers.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectionEventsManager = exports.ConnectionChannels = exports.KvdbEventsManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.BaseEventDispatcherManager = void 0;
+exports.UserEventsManager = exports.ConnectionEventsManager = exports.ConnectionChannels = exports.CustomEventsManager = exports.KvdbEventsManager = exports.InboxEventsManager = exports.StoreEventsManager = exports.ThreadEventsManager = exports.BaseEventDispatcherManager = void 0;
 const subscriptions_1 = require("./subscriptions");
 class BaseEventDispatcherManager {
     _listenersSymbols = new Map();
@@ -9,7 +9,10 @@ class BaseEventDispatcherManager {
         return this._listeners;
     }
     dispatchEvent(event) {
-        const callbacks = event.subscriptions.flatMap((s) => this._listeners.get(s));
+        const callbacks = event.subscriptions.flatMap((s) => {
+            const listeners = this._listeners.get(s);
+            return listeners ?? [];
+        });
         for (const listener of callbacks) {
             listener.callback(event);
         }
@@ -39,14 +42,19 @@ class BaseEventDispatcherManager {
         return subscriptionIds;
     }
     async unsubscribeFrom(subscriptionsId) {
+        const knownIds = [];
         for (const subscriptionId of subscriptionsId) {
             for (const [key, callbackSubscription,] of this._listenersSymbols.entries()) {
                 if (callbackSubscription === subscriptionId) {
+                    knownIds.push(subscriptionId);
                     this.unregisterCallback(key);
                 }
             }
         }
-        return this.apiUnsubscribeFrom(subscriptionsId);
+        if (knownIds.length === 0) {
+            return Promise.resolve();
+        }
+        return this.apiUnsubscribeFrom(knownIds);
     }
 }
 exports.BaseEventDispatcherManager = BaseEventDispatcherManager;
@@ -130,10 +138,30 @@ class KvdbEventsManager extends BaseEventDispatcherManager {
     }
 }
 exports.KvdbEventsManager = KvdbEventsManager;
+class CustomEventsManager extends BaseEventDispatcherManager {
+    eventsApi;
+    constructor(eventsApi) {
+        super();
+        this.eventsApi = eventsApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.eventsApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.eventsApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.eventsApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.CustomEventsManager = CustomEventsManager;
 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",
+    [subscriptions_1.ConnectionStatusEventType.LIB_CONNECTED]: "channel/lib_connected",
+    [subscriptions_1.ConnectionStatusEventType.LIB_DISCONNECTED]: "channel/lib_disconnected",
+    [subscriptions_1.ConnectionStatusEventType.LIB_PLATFORM_DISCONNECTED]: "channel/lib_platform_disconnected",
 };
 class ConnectionEventsManager extends BaseEventDispatcherManager {
     connectionId;
@@ -149,9 +177,29 @@ class ConnectionEventsManager extends BaseEventDispatcherManager {
     }
     async subscribeFor(subscriptions) {
         const subscriptionChannels = subscriptions.map((x) => {
-            return `${this.connectionId}/${subscriptions_1.ConnectionEventType[x.type]}`;
+            return `${this.connectionId}/${exports.ConnectionChannels[x.type]}`;
         });
         return this.prepareSubscription(subscriptionChannels, subscriptions);
     }
 }
 exports.ConnectionEventsManager = ConnectionEventsManager;
+class UserEventsManager extends BaseEventDispatcherManager {
+    userEventsApi;
+    constructor(userEventsApi) {
+        super();
+        this.userEventsApi = userEventsApi;
+    }
+    apiSubscribeFor(channels) {
+        return this.userEventsApi.subscribeFor(channels);
+    }
+    apiUnsubscribeFrom(subscriptionId) {
+        return this.userEventsApi.unsubscribeFrom(subscriptionId);
+    }
+    async subscribeFor(subscriptions) {
+        const subscriptionChannels = await Promise.all(subscriptions.map((s) => {
+            return this.userEventsApi.buildSubscriptionQuery(s.type, s.selector, s.id);
+        }));
+        return this.prepareSubscription(subscriptionChannels, subscriptions);
+    }
+}
+exports.UserEventsManager = UserEventsManager;