hamok/lib/collections/HamokEmitter.d.ts

Lightweight Distributed Object Storage on RAFT consensus algorithm

import { EventEmitter } from 'events';
import { HamokConnection } from './HamokConnection';
import { HamokEmitterSnapshot } from '../HamokSnapshot';
export interface HamokEmitterEventMap extends Record<string, unknown[]> {
}
export type HamokEmitterStats = {
    numberOfSubscriptions: number;
    numberOfReceivedEventInvocations: number;
    numberOfSentEventInvocations: number;
};
export declare class HamokEmitter<T extends HamokEmitterEventMap, M extends Record<string, unknown> = Record<string, unknown>> {
    readonly connection: HamokConnection<string, string>;
    readonly payloadsCodec?: Map<keyof T, {
        encode: (...args: unknown[]) => string;
        decode: (data: string) => unknown[];
    }> | undefined;
    readonly autoClean?: boolean | undefined;
    readonly subscriptions: HamokEmitterSubscriptions<T, M>;
    private readonly _emitter;
    private _initializing?;
    private _closed;
    stats: HamokEmitterStats;
    constructor(connection: HamokConnection<string, string>, payloadsCodec?: Map<keyof T, {
        encode: (...args: unknown[]) => string;
        decode: (data: string) => unknown[];
    }> | undefined, autoClean?: boolean | undefined);
    get id(): string;
    get empty(): boolean;
    get ready(): Promise<this>;
    get closed(): boolean;
    close(): void;
    /**
     * This method is used to cleanup the subscriptions by removing the endpoints that are not in the grid anymore.
     */
    cleanup(): Promise<ReadonlySet<string> | undefined>;
    hasSubscribers<K extends keyof T>(event: K, filterByLocalNode?: boolean): Promise<boolean>;
    subscribe<K extends keyof T>(event: K, listener: (...args: T[K]) => void, metaData?: M | null): Promise<void>;
    updateSubscriptionMetaData<K extends keyof T>(event: K, newMetaData: M, prevMetaData?: M | null): Promise<boolean>;
    unsubscribe<K extends keyof T>(event: K, listener: (...args: T[K]) => void): Promise<void>;
    clear(): void;
    publish<K extends keyof T>(event: K, ...args: T[K]): Promise<string[]>;
    notify<K extends keyof T>(event: K, ...args: T[K]): boolean;
    export(): HamokEmitterSnapshot;
    import(snapshot: HamokEmitterSnapshot): void;
    private _import;
    private _startInitializing;
}
type HamokSubscriptionsEmitterEventMap<EventMap extends HamokEmitterEventMap, M extends Record<string, unknown> = Record<string, unknown>> = {
    'added': [
        event: keyof EventMap,
        peerId: string,
        metaData: M | null
    ];
    'updated': [
        event: keyof EventMap,
        peerId: string,
        newMetaData: M,
        prevMetaData?: M | null
    ];
    'removed': [
        event: keyof EventMap,
        peerId: string,
        metaData: M | null
    ];
    'debug': [
        log: string
    ];
};
declare class HamokEmitterSubscriptions<EventMap extends HamokEmitterEventMap, M extends Record<string, unknown> = Record<string, unknown>> extends EventEmitter<HamokSubscriptionsEmitterEventMap<EventMap, M>> {
    private readonly _map;
    hasEvent<K extends keyof EventMap>(event: K): boolean;
    addPeer<K extends keyof EventMap>(event: K, peerId: string, metaData?: M | null): boolean;
    updatePeer<K extends keyof EventMap>(event: K, peerId: string, metaData: M, prevMetaData?: M | null): boolean;
    removePeer<K extends keyof EventMap>(event: K, peerId: string): boolean;
    removePeerFromAllEvent(peerId: string): boolean;
    getEventPeersMap<K extends keyof EventMap>(event: K): Map<string, M | null> | undefined;
    entries(): IterableIterator<[keyof EventMap, Map<string, M | null>]>;
    events(): IterableIterator<keyof EventMap>;
    hasPeerOnEvent<K extends keyof EventMap>(event: K, peerId: string): boolean;
    getPeerIds<K extends keyof EventMap>(event: K): Set<string> | undefined;
    getAllPeerIds(): Set<string>;
    get [Symbol.toStringTag](): string;
    get size(): number;
    get [Symbol.species](): typeof HamokEmitterSubscriptions;
}
export {};
//# sourceMappingURL=HamokEmitter.d.ts.map