nope-js-browser/dist-browser/pubSub/nopePubSubSystem.d.ts

NoPE Runtime for the Browser. For nodejs please use nope-js-node

/**
 * @author Martin Karkowski
 * @email m.karkowski@zema.de
 */
import { TcomparePatternAndPathFunc } from "../helpers/pathMatchingMethods";
import { IEventCallback, IEventOptions, IIncrementalChange, INopeDescriptor, INopeEventEmitter, INopeObserver, INopeTopic, IPubSubEmitterOptions, IPubSubOptions, IPubSubSystem, ITopicSetContentOptions } from "../types/nope/index";
import { IMapBasedMergeData } from "../types/nope/nopeHelpers.interface";
type TMatchting<O extends INopeTopic = INopeTopic> = {
    dataPull: Map<string, Set<O>>;
    dataQuery: Map<string, Set<O>>;
};
/**
 * Default implementation of a {@link IPubSubSystem}.
 *
 */
export declare class PubSubSystemBase<AD extends ITopicSetContentOptions & {
    pubSubUpdate?: boolean;
} = ITopicSetContentOptions, I extends INopeEventEmitter<unknown, unknown, unknown, AD> = INopeEventEmitter<unknown, unknown, unknown, AD>, O extends INopeTopic = INopeTopic> implements IPubSubSystem<AD, I, O> {
    _options: IPubSubOptions;
    get options(): IPubSubOptions;
    readonly onIncrementalDataChange: INopeEventEmitter<IIncrementalChange>;
    readonly subscriptions: IMapBasedMergeData<O, IPubSubEmitterOptions<AD>, O, string>;
    readonly publishers: IMapBasedMergeData<O, IPubSubEmitterOptions<AD>, O, string>;
    protected _comparePatternAndPath: TcomparePatternAndPathFunc;
    /**
     * The internal used object to store the data.
     *
     * @author M.Karkowski
     * @type {unknown}
     * @memberof PubSubSystemBase
     */
    protected _data: unknown;
    protected _sendCurrentDataOnSubscription: boolean;
    protected _id: string;
    /**
     * List of all Properties. For every property, we store the
     * PropertyOptions. Then, we know, what elements should be
     * subscribed and which not.
     *
     * @author M.Karkowski
     * @protected
     * @memberof PubSubSystemBase
     */
    protected _emitters: Map<O, {
        options: IEventOptions;
        subTopic: string | false;
        pubTopic: string | false;
        callback?: IEventCallback<unknown, AD>;
        observer?: INopeObserver;
    }>;
    protected _emittersToObservers: Map<O, INopeObserver>;
    protected _matched: Map<string, TMatchting<INopeTopic<any, any, any>>>;
    protected _generateEmitterType: () => I;
    protected _disposing: boolean;
    constructor(options?: Partial<IPubSubOptions> & {
        generateEmitterType?: () => I;
    });
    register(emitter: I, options: IEventOptions): O;
    updateOptions(emitter: I, options: IEventOptions): void;
    unregister(emitter: I): boolean;
    registerSubscription<T = unknown>(topic: string, subscription: IEventCallback<T, AD>): INopeObserver;
    get emitters(): {
        publishers: {
            name: string;
            schema: INopeDescriptor;
        }[];
        subscribers: {
            name: string;
            schema: INopeDescriptor;
        }[];
    };
    /**
     * Internal Match-Making Algorithm. This allowes to Create a predefined
     * List between Publishers and Subscribers. Thereby the Process is speed
     * up, by utilizing this Look-Up-Table
     *
     * @author M.Karkowski
     * @memberof PubSubSystemBase
     */
    updateMatching(): void;
    private __deleteMatchingEntry;
    private __addMatchingEntryIfRequired;
    /**
     * Helper, to update the Matching. But, we are just considering
     * @param mode
     * @param _emitter
     * @param _pubTopic
     * @param _subTopic
     */
    protected _updatePartialMatching(mode: "add" | "remove", _emitter: I, _pubTopic: string | false, _subTopic: string | false): void;
    emit(eventName: string, data: any, options?: AD): void;
    /**
     * Unregisters all Emitters and removes all subscriptions of the
     * "onIncrementalDataChange", "publishers" and "subscriptions"
     *
     * @author M.Karkowski
     * @memberof PubSubSystemBase
     */
    dispose(): void;
    /**
     * Internal Helper to lazy update the Matching.
     * @param entry
     * @param topicOfChange
     * @param pathOrPattern
     * @param emitter
     */
    protected __addToMatchingStructure(entry: keyof TMatchting, topicOfChange: string, pathOrPattern: string, emitter: O): void;
    /** Function to Interanlly add a new Match
     *
     * @export
     * @param {string} topicOfChange
     */
    protected _updateMatchingForTopic(topicOfChange: string): void;
    /**
     * Internal Function to notify Asynchronous all Subscriptions
     *
     * @author M.Karkowski
     * @private
     * @param {string} topicOfContent
     *  @param {string} topicOfChange
     * @param {*} content
     * @memberof PubSubSystemBase
     */
    protected _notify(topicOfContent: string, topicOfChange: string, options: Partial<AD>, emitter?: O): void;
    protected _updateOptions(options: Partial<AD>): AD;
    /**
     * Internal helper to push data to the data property. This
     * results in informing the subscribers.
     *
     * @param path Path, that is used for pushing the data.
     * @param data The data to push
     * @param options Options used during pushing
     */
    protected _pushData<T = unknown>(pathOfContent: string, pathOfChange: string, data: T, options?: Partial<AD>, quiet?: boolean, emitter?: O): void;
    protected _pullData<T = unknown, D = null>(topic: string, _default?: D): T;
    /**
     * Helper, which enable to perform a pattern based pull.
     * The code receives a pattern, and matches the existing
     * content (by using there path attributes) and return the
     * corresponding data.
     * @param pattern The Patterin
     * @param _default The Default Value.
     * @returns
     */
    protected _patternbasedPullData<T = unknown, D = null>(pattern: string, _default?: D): {
        path: string;
        data: T;
    }[];
    /**
     * Describes the Data.
     * @returns
     */
    toDescription(): {
        publishers: {
            name: string;
            schema: INopeDescriptor;
        }[];
        subscribers: {
            name: string;
            schema: INopeDescriptor;
        }[];
    };
}
export {};