@simplito/privmx-webendpoint 2.1.1 → 2.2.1

package/extra/events.d.ts

@@ -0,0 +1,234 @@
+import { Types } from "..";
+export type Channel = 'inbox' | `inbox/${string}/entries` | 'store' | `store/${string}/files` | 'thread' | `thread/${string}/messages` | `connection/${string}`;
+/**
+ * Represents a generic event structure.
+ */
+export interface GenericEvent<K extends keyof EventPayload> extends Types.Event {
+    /**
+     * Type of the event.
+     */
+    type: keyof EventPayload;
+    /**
+     * The channel through which the event was emitted.
+     */
+    channel: Channel;
+    /**
+     * Data associated with the event.
+     */
+    data: EventPayload[K];
+    /**
+     * ID of connection to which the event was sent.
+     */
+    connectionId: number;
+}
+export interface EventPayload {
+    threadCreated: Types.Thread;
+    threadUpdated: Types.Thread;
+    threadDeleted: {
+        threadId: string;
+    };
+    threadStatsChanged: {
+        lastMsgDate: number;
+        messagesCount: number;
+    };
+    threadNewMessage: Types.Message;
+    threadMessageUpdated: Types.Message;
+    threadMessageDeleted: {
+        threadId: string;
+        messageId: string;
+    };
+    storeCreated: Types.Store;
+    storeUpdated: Types.Store;
+    storeDeleted: {
+        storeId: string;
+    };
+    storeStatsChanged: {
+        contextId: string;
+        storeId: string;
+        lastFileDate: number;
+        files: number;
+    };
+    storeFileCreated: Types.File;
+    storeFileUpdated: Types.File;
+    storeFileDeleted: {
+        contextId: string;
+        storeId: string;
+        fileId: string;
+    };
+    inboxDeleted: {
+        inboxId: string;
+    };
+    inboxUpdated: Types.Inbox;
+    inboxCreated: Types.Inbox;
+    inboxEntryCreated: Types.InboxEntry;
+    inboxEntryDeleted: {
+        inboxId: string;
+        entryId: string;
+    };
+    libConnected: undefined;
+    libDisconnected: undefined;
+    libPlatformDisconnected: undefined;
+    libBreak: undefined;
+}
+type EventType = keyof EventPayload;
+type EventHandler<E extends keyof EventPayload> = {
+    event: E;
+    callback: (event: GenericEvent<E>) => void;
+};
+export type OnMessageEventHandler = EventHandler<'threadMessageDeleted'> | EventHandler<'threadNewMessage'> | EventHandler<'threadMessageUpdated'>;
+export type OnThreadEventHandler = EventHandler<'threadCreated'> | EventHandler<'threadDeleted'> | EventHandler<'threadUpdated'> | EventHandler<'threadStatsChanged'>;
+export type OnFileEventHandler = EventHandler<'storeFileDeleted'> | EventHandler<'storeFileCreated'> | EventHandler<'storeFileUpdated'>;
+export type OnStoreEventHandler = EventHandler<'storeCreated'> | EventHandler<'storeStatsChanged'> | EventHandler<'storeUpdated'> | EventHandler<'storeDeleted'>;
+export type OnInboxEventHandler = EventHandler<'inboxDeleted'> | EventHandler<'inboxCreated'> | EventHandler<'inboxUpdated'>;
+export type OnEntryEventHandler = EventHandler<'inboxEntryCreated'> | EventHandler<'inboxEntryDeleted'>;
+export type OnConnectionHandler = EventHandler<'libConnected'> | EventHandler<'libDisconnected'> | EventHandler<'libBreak'> | EventHandler<'libPlatformDisconnected'>;
+export declare abstract class BaseEventManager {
+    private _listeners;
+    get listeners(): Map<string, Function[]>;
+    protected channels: Set<Channel>;
+    protected abstract subscribeForModuleEvents(): Promise<void>;
+    protected abstract subscribeForModuleElementsEvents(containerId: string): Promise<void>;
+    protected abstract unsubscribeFromModuleEvents(): Promise<void>;
+    protected abstract unsubscribeFromModuleElementsEvents(containerId: string): Promise<void>;
+    constructor();
+    /**
+     * Checks whether the user is subscribed to given channel
+     * @param channel Channel
+     * @returns {boolean} `boolean`
+     */
+    protected isSubscribedToChannel(channel: Channel): boolean;
+    protected hasEventsOnChannel(channel: Channel): boolean;
+    /**
+     * 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
+     */
+    protected removeEventListener: (channel: Channel, eventType: EventType, callback: Function) => void;
+    /**
+     * Removes all listeners from given channel
+     * @param {Channel} channel channel
+     * @returns {void}
+     */
+    removeChannelEvents: (channel: Channel) => void;
+    dispatchEvent(event: Types.Event): void;
+    /**
+     * 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
+     */
+    private addEventListener;
+    protected addContainerListener: (channel: Channel, eventType: EventType, callback: Function) => Promise<() => Promise<void>>;
+    protected addContainerElementListener: (containerId: string, channel: Channel, eventType: EventType, callback: Function) => Promise<() => Promise<void>>;
+}
+export interface SubscriberForThreadsEvents {
+    subscribeForThreadEvents(): Promise<void>;
+    /**
+     * Unsubscribes from the Thread module main events.
+     */
+    unsubscribeFromThreadEvents(): Promise<void>;
+    /**
+     * Subscribes for events in given Thread.
+     * @param {string} threadId ID of the Thread to subscribe
+     */
+    subscribeForMessageEvents(threadId: string): Promise<void>;
+    /**
+     * Unsubscribes from events in given Thread.
+     * @param {string} threadId ID of the Thread to unsubscribe
+     */
+    unsubscribeFromMessageEvents(threadId: string): Promise<void>;
+}
+export declare class ThreadEventsManager extends BaseEventManager {
+    private threadApi;
+    constructor(threadApi: SubscriberForThreadsEvents);
+    subscribeForModuleEvents(): Promise<void>;
+    subscribeForModuleElementsEvents(id: string): Promise<void>;
+    unsubscribeFromModuleEvents(): Promise<void>;
+    unsubscribeFromModuleElementsEvents(id: string): Promise<void>;
+    onThreadEvent(handler: OnThreadEventHandler): Promise<() => Promise<void>>;
+    onMessageEvent(threadId: string, handler: OnMessageEventHandler): Promise<() => Promise<void>>;
+}
+export interface SubscriberForStoreEvents {
+    subscribeForStoreEvents(): Promise<void>;
+    /**
+     * Unsubscribes from the Store module main events.
+     */
+    unsubscribeFromStoreEvents(): Promise<void>;
+    /**
+     * Subscribes for events in given Store.
+     * @param {string} storeId ID of the Store to subscribe
+     */
+    subscribeForFileEvents(storeId: string): Promise<void>;
+    /**
+     * Unsubscribes from events in given Store.
+     * @param {string} storeId ID of the Store to unsubscribe
+     */
+    unsubscribeFromFileEvents(storeId: string): Promise<void>;
+}
+export declare class StoreEventsManager extends BaseEventManager {
+    private storeApi;
+    constructor(storeApi: SubscriberForStoreEvents);
+    subscribeForModuleEvents(): Promise<void>;
+    subscribeForModuleElementsEvents(id: string): Promise<void>;
+    unsubscribeFromModuleEvents(): Promise<void>;
+    unsubscribeFromModuleElementsEvents(id: string): Promise<void>;
+    onStoreEvent(handler: OnStoreEventHandler): Promise<() => Promise<void>>;
+    onFileEvent(storeId: string, handler: OnFileEventHandler): Promise<() => Promise<void>>;
+}
+export interface SubscriberForInboxEvents {
+    subscribeForInboxEvents(): Promise<void>;
+    /**
+     * Unsubscribes from the Inbox module main events.
+     */
+    unsubscribeFromInboxEvents(): Promise<void>;
+    /**
+     * Subscribes for events in given Inbox.
+     * @param {string} inboxId ID of the Inbox to subscribe
+     */
+    subscribeForEntryEvents(inboxId: string): Promise<void>;
+    /**
+     * Unsubscribes from events in given Inbox.
+     * @param {string} inboxId ID of the Inbox to unsubscribe
+     */
+    unsubscribeFromEntryEvents(inboxId: string): Promise<void>;
+}
+export declare class InboxEventsManager extends BaseEventManager {
+    private inboxApi;
+    constructor(inboxApi: SubscriberForInboxEvents);
+    subscribeForModuleEvents(): Promise<void>;
+    subscribeForModuleElementsEvents(id: string): Promise<void>;
+    unsubscribeFromModuleEvents(): Promise<void>;
+    unsubscribeFromModuleElementsEvents(id: string): Promise<void>;
+    onInboxEvent(handler: OnInboxEventHandler): Promise<() => Promise<void>>;
+    onEntryEvent(inboxId: string, handler: OnEntryEventHandler): Promise<() => Promise<void>>;
+}
+export declare class ConnectionEventsManager extends BaseEventManager {
+    private connectionId;
+    protected subscribeForModuleEvents(): Promise<void>;
+    protected subscribeForModuleElementsEvents(): Promise<void>;
+    protected unsubscribeFromModuleEvents(): Promise<void>;
+    protected unsubscribeFromModuleElementsEvents(): Promise<void>;
+    constructor(connectionId: string);
+    onConnectionEvent(handler: OnConnectionHandler): Promise<() => Promise<void>>;
+}
+export declare class EventManager {
+    private _isEventLoopRunning;
+    dispatchers: ((event: Types.Event) => void)[];
+    private eventsQueue;
+    constructor();
+    private listenForEvents;
+    static startEventLoop(eventQueue: {
+        waitEvent: () => Promise<Types.Event>;
+    }): EventManager;
+    stopEventLoop(): void;
+    removeAllDispatchers: () => void;
+    protected onEvent(event: Types.Event): void;
+    registerDispatcher(manager: BaseEventManager): void;
+    getThreadEventManager(threadApi: SubscriberForThreadsEvents): ThreadEventsManager;
+    getStoreEventManager(storeApi: SubscriberForStoreEvents): StoreEventsManager;
+    getInboxEventManager(inboxApi: SubscriberForInboxEvents): InboxEventsManager;
+    getConnectionEventManager(connectionId: string): ConnectionEventsManager;
+}
+export {};

package/extra/events.js

@@ -0,0 +1,270 @@
+"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.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() { }
+    listenForEvents() {
+        if (this.eventsQueue) {
+            this.eventsQueue.waitEvent().then((event) => {
+                this.onEvent(event);
+                this.listenForEvents();
+            });
+        }
+    }
+    static startEventLoop(eventQueue) {
+        const manager = new EventManager();
+        manager.eventsQueue = eventQueue;
+        manager._isEventLoopRunning = true;
+        manager.eventsQueue.waitEvent().then((event) => {
+            if (!manager._isEventLoopRunning)
+                return;
+            manager.onEvent(event);
+            manager.listenForEvents();
+        });
+        return manager;
+    }
+    stopEventLoop() {
+        this._isEventLoopRunning = false;
+    }
+    removeAllDispatchers = () => {
+        this.dispatchers = [];
+    };
+    onEvent(event) {
+        this.dispatchers.forEach((cb) => cb(event));
+    }
+    registerDispatcher(manager) {
+        this.dispatchers.push((e) => manager.dispatchEvent(e));
+    }
+    getThreadEventManager(threadApi) {
+        const manager = new ThreadEventsManager(threadApi);
+        this.registerDispatcher(manager);
+        return manager;
+    }
+    getStoreEventManager(storeApi) {
+        const manager = new StoreEventsManager(storeApi);
+        this.registerDispatcher(manager);
+        return manager;
+    }
+    getInboxEventManager(inboxApi) {
+        const manager = new InboxEventsManager(inboxApi);
+        this.registerDispatcher(manager);
+        return manager;
+    }
+    getConnectionEventManager(connectionId) {
+        const manager = new ConnectionEventsManager(connectionId);
+        this.registerDispatcher(manager);
+        return manager;
+    }
+}
+exports.EventManager = EventManager;

package/extra/files.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Represents a stream reader for reading a file in chunks.
+ */
+import { InboxApi, StoreApi } from '..';
+export declare const FILE_DEFAULT_CHUNK_SIZE = 1048576;
+export declare class StreamReader {
+    private _handle;
+    private _offset;
+    private _api;
+    private readonly chunkSize;
+    hasDataToRead: boolean;
+    /**
+     * Creates an instance of StreamReader.
+     *
+     * @param {number} handle - The file handle.
+     * @param {StoreApi} api {@link StoreApi `StoreApi`} instance
+     */
+    constructor(handle: number, api: StoreApi | InboxApi, chunkSize?: number);
+    static readFile(api: InboxApi | StoreApi, fileID: string, chunkSize?: number): Promise<StreamReader>;
+    /**
+     * Reads the next chunk of the file.
+     *
+     * @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>;
+    readNextChunk(): Promise<Uint8Array>;
+    getFileContent(): Promise<Uint8Array>;
+    /**
+     * Aborts the reading process and closes the file handle.
+     *
+     * @returns {Promise<string>} A promise that resolves when the file handle is closed.
+     */
+    abort(): Promise<string>;
+    /**
+     * Closes the file handle.
+     *
+     * @returns {Promise<string>} A promise that resolves when the file handle is closed and returns file ID.
+     */
+    close(): Promise<string>;
+}
+/**
+ * Represents a file stream uploader for uploading a Browser FileHandle in chunks.
+ */
+interface FileContainerApi {
+    writeToFile: (chunk: Uint8Array) => Promise<void>;
+    closeFile: () => Promise<string>;
+}
+export declare class FileUploader {
+    private readonly _size;
+    private offset;
+    private readonly _api;
+    private _reader;
+    /**
+     * Creates an instance of FileUploader.
+     *
+     * @param {number} handle - The file handle.
+     * @param {File} file - The data (file content) to upload.
+     * @param {StoreApi} api {@link StoreApi `StoreApi`} instance
+     */
+    constructor(file: File, api: FileContainerApi);
+    static uploadStoreFile({ storeApi, storeId, file, privateMeta, publicMeta }: {
+        storeId: string;
+        file: File;
+        storeApi: StoreApi;
+        publicMeta?: Uint8Array;
+        privateMeta?: Uint8Array;
+    }): Promise<FileUploader>;
+    static uploadInboxFile({ inboxApi, inboxHandle, preparedFileUpload }: {
+        inboxHandle: number;
+        preparedFileUpload: {
+            file: File;
+            handle: number;
+        };
+        inboxApi: InboxApi;
+    }): Promise<FileUploader>;
+    static prepareInboxUpload({ inboxApi, file, privateMeta, publicMeta }: {
+        inboxApi: InboxApi;
+        file: File;
+        publicMeta?: Uint8Array;
+        privateMeta?: Uint8Array;
+    }): Promise<{
+        file: File;
+        handle: number;
+    }>;
+    /**
+     * Gets the progress of uploading the file as a percentage.
+     *
+     * @returns {number} The progress percentage.
+     */
+    get progress(): number;
+    /**
+     * Sends the next chunk of the file data to the server.
+     *
+     * @returns {Promise<boolean>} A promise that resolves to true if there are more chunks to send, or false if all data has been sent.
+     */
+    sendNextChunk(): Promise<boolean>;
+    uploadFileContent(): Promise<string>;
+    /**
+     * Aborts the uploading process, closes the file handle, and deletes the uploaded part of the file.
+     *
+     * @returns {Promise<void>} A promise that resolves when the file handle is closed and the uploaded part is deleted.
+     */
+    abort(): Promise<void>;
+    /**
+     * Closes the file handle.
+     *
+     * @returns {Promise<string>} A promise that resolves when the file handle is closed and returns file ID.
+     */
+    close(): Promise<string>;
+}
+/**
+ * Downloads a file from the server.
+ *
+ * @param {StoreApi|InboxApi} api - The API instance used for file operations.
+ * @param {string} fileId - The ID of the file to download.
+ * @param {string} [targetFileName] - The target file name for saving the downloaded file.
+ * @returns {Promise<void>} A promise that resolves when the download is complete.
+ */
+export declare function downloadFile(api: StoreApi | InboxApi, fileId: string, targetFileName?: string): Promise<void>;
+export {};