@simplito/privmx-webendpoint/dist/extra/managers.js

PrivMX Web Endpoint library

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
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();
    _listeners = new Map();
    get listeners() {
        return this._listeners;
    }
    dispatchEvent(event) {
        const callbacks = event.subscriptions.flatMap((s) => {
            const listeners = this._listeners.get(s);
            return listeners ?? [];
        });
        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) {
        const knownIds = [];
        for (const subscriptionId of subscriptionsId) {
            for (const [key, callbackSubscription] of this._listenersSymbols.entries()) {
                if (callbackSubscription === subscriptionId) {
                    knownIds.push(subscriptionId);
                    this.unregisterCallback(key);
                }
            }
        }
        if (knownIds.length === 0) {
            return Promise.resolve();
        }
        return this.apiUnsubscribeFrom(knownIds);
    }
}
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;
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.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;
    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}/${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;