evg_observable 2.15.0 → 2.15.2

package/src/outLib/SubscribeObject.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubscribeObject = void 0;
+const Pipe_1 = require("./Pipe");
+const FunctionLibs_1 = require("./FunctionLibs");
+class SubscribeObject extends Pipe_1.Pipe {
+    observer;
+    listener;
+    errorHandler = (errorData, errorMessage) => {
+        console.log(`(Unit of SubscribeObject).send(${errorData}) ERROR:`, errorMessage);
+    };
+    _order = 0;
+    paused = false;
+    piped = false;
+    constructor(observable, isPipe) {
+        super();
+        this.observer = observable;
+        this.piped = !!isPipe;
+    }
+    subscribe(observer, errorHandler) {
+        this.listener = (0, FunctionLibs_1.getListener)(observer);
+        errorHandler && (this.errorHandler = errorHandler);
+        return this;
+    }
+    unsubscribe() {
+        if (!this.observer)
+            return;
+        this.observer.unSubscribe(this);
+        this.observer = null;
+        this.listener = null;
+        this.chain.length = 0;
+    }
+    send(value) {
+        const listener = this.listener;
+        if (!listener) {
+            this.unsubscribe();
+            return;
+        }
+        if (!this.observer || this.paused)
+            return;
+        if (!this.piped) {
+            try {
+                listener(value);
+            }
+            catch (err) {
+                this.errorHandler(value, err);
+            }
+            return;
+        }
+        try {
+            this.flow.payload = value;
+            this.flow.isBreak = false;
+            this.processChain(listener);
+        }
+        catch (err) {
+            this.errorHandler(value, err);
+        }
+    }
+    resume() {
+        this.paused = false;
+    }
+    pause() {
+        this.paused = true;
+    }
+    get order() {
+        return this._order;
+    }
+    set order(value) {
+        this._order = value;
+    }
+}
+exports.SubscribeObject = SubscribeObject;

package/src/outLib/Types.d.ts

@@ -0,0 +1,165 @@
+import { PipeSwitchCase } from "./Pipe";
+import { FilterSwitchCase } from "./FilterCollection";
+export type ICallback<T> = (value?: T) => any;
+export type IErrorCallback = (errorData: any, errorMessage: any) => void;
+export type ISubscribe<T> = {
+    subscribe(listener: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
+};
+export type IListener<T> = ICallback<T>;
+export type IDestroy = {
+    destroy(): void;
+    isDestroyed: boolean;
+};
+export type IOrder = {
+    order: number;
+};
+export type ISwitch<T> = {
+    switch(): PipeSwitchCase<T>;
+};
+export type IOrderedSwitch<T> = {
+    switch(): PipeSwitchCase<T>;
+};
+export type IOnce<T> = {
+    setOnce(): ISubscribe<T>;
+};
+export type IOrderedOnce<T> = {
+    setOnce(): IOrderedSubscribe<T>;
+};
+export type ISetObservableValue = {
+    next(value: any): void;
+};
+export type ISubscriptionLike = {
+    unsubscribe(): void;
+};
+export type ISetup<T> = IUnsubscribeByPositive<T> & IEmitByPositive<T> & IOnce<T> & ISwitch<T> & ITransform<T> & ISerialisation & ISubscribe<T>;
+export type IOrderedSetup<T> = IOrderedUnsubscribeByPositive<T> & IOrderedEmitByPositive<T> & IOrderedOnce<T> & IOrderedSwitch<T> & IOrderedTransform<T> & IOrderedSerialisation & IOrderedSubscribe<T>;
+export type ISubscribeObject<T> = ISubscriptionLike & IPause & IOrder & ISend<T> & ISetup<T>;
+export type ISubscribeCounter = {
+    size(): number;
+};
+export type ISubscriber<T> = {
+    getValue(): T | undefined;
+    isEnable: boolean;
+} & ISubscribe<T>;
+export type IObserver<T> = ISetObservableValue & ISubscriber<T> & IDestroy & ISubscribeCounter & IObservablePipe<T> & {
+    unSubscribe(subscriber: ISubscriptionLike): void;
+    unsubscribeAll(): void;
+    disable(): void;
+    enable(): void;
+};
+export type IStream<T> = {
+    stream(value: T[]): void;
+};
+export type IPause = {
+    pause(): void;
+    resume(): void;
+};
+export type IObservablePipe<T> = {
+    pipe(): ISetup<T> | undefined;
+};
+export type IOrderedObservablePipe<T> = {
+    pipe(): ISetup<T> | undefined;
+};
+export type ISend<T> = {
+    send(value: T): void;
+};
+export type IUnsubscribeByNegative<T> = {
+    unsubscribeByNegative(condition: ICallback<T>): ISetup<T>;
+};
+export type IOrderedUnsubscribeByNegative<T> = {
+    unsubscribeByNegative(condition: ICallback<T>): IOrderedSetup<T>;
+};
+export type IUnsubscribeByPositive<T> = {
+    unsubscribeBy(condition: ICallback<T>): ISetup<T>;
+};
+export type IOrderedUnsubscribeByPositive<T> = {
+    unsubscribeBy(condition: ICallback<T>): ISetup<T>;
+};
+export type IEmitByNegative<T> = {
+    emitByNegative(condition: ICallback<T>): ISetup<T>;
+};
+export type IOrderedEmitByNegative<T> = {
+    emitByNegative(condition: ICallback<T>): IOrderedSetup<T>;
+};
+export type IEmitByPositive<T> = {
+    refine(condition: ICallback<T>): ISetup<T>;
+    pushRefiners(conditions: ICallback<T>[]): ISetup<T>;
+};
+export type ITransform<T> = {
+    then<K>(condition: ICallback<T>): ISetup<K>;
+};
+export type ISerialisation = {
+    serialize(): ISetup<string>;
+    deserialize<K>(): ISetup<K>;
+};
+export type IOrderedEmitByPositive<T> = {
+    refine(condition: ICallback<any>): ISetup<T>;
+    pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
+};
+export type IOrderedTransform<T> = {
+    then<K>(condition: ICallback<T>): ISetup<K>;
+};
+export type IOrderedSerialisation = {
+    serialize(): ISetup<string>;
+    deserialize<K>(): ISetup<K>;
+};
+export type IEmitMatchCondition<T> = {
+    emitMatch(condition: ICallback<any>): ISetup<T>;
+};
+export type IOrderedEmitMatchCondition<T> = {
+    emitMatch(condition: ICallback<any>): IOrderedSetup<T>;
+};
+export type ICollector = IDestroy & ISubscribeCounter & {
+    collect(...subscriptionLikeList: ISubscriptionLike[]): void;
+    unsubscribe(subscriptionLike: ISubscriptionLike): void;
+    unsubscribeAll(): void;
+};
+export type IOrderedObservable = {
+    sortByOrder(): boolean;
+};
+export type IOrdered<T> = IObserver<T> & IOrderedObservable & IOrderedObservablePipe<T>;
+export type IOrderedSubscriptionLike = (ISubscriptionLike & IOrder);
+export type IOrderedSubscribe<T> = {
+    subscribe(listener: IListener<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
+};
+export type IChainContainer = {
+    chain: any[];
+};
+export type IPipePayload = {
+    isBreak: boolean;
+    isUnsubscribe: boolean;
+    isAvailable: boolean;
+    payload: any;
+};
+export type IChainCallback = (data: IPipePayload) => void;
+export type IPipeCase<T> = ISubscribe<T> & {
+    case(condition: ICallback<any>): IPipeCase<T> & ISubscribe<T>;
+    pushCases(conditions: ICallback<any>[]): IPipeCase<T> & ISubscribe<T>;
+};
+export type ICombinedSubscriber<T> = IListener<T> | ISetObservableValue;
+export type ISubscribeGroup<T> = ICombinedSubscriber<T> | ICombinedSubscriber<T>[];
+export type IAddFilter<T> = {
+    addFilter(): IFilterSetup<T>;
+};
+export type IFilterSetup<T> = IFilter<T> & IFilterSwitch<T>;
+export type IFilter<T> = {
+    filter(condition: ICallback<any>): IFilterSetup<T>;
+    pushFilters(conditions: ICallback<any>[]): IFilterSetup<T>;
+};
+export type IFilterSwitch<T> = {
+    switch(): FilterSwitchCase<T>;
+};
+export type IFilterCase<T> = {
+    case(condition: ICallback<any>): IFilterCase<T>;
+    pushCases(conditions: ICallback<any>[]): IFilterCase<T>;
+};
+export type IFilterPayload = {
+    isBreak: boolean;
+    isAvailable: boolean;
+    payload: any;
+};
+export type IFilterChainCallback = (data: IFilterPayload) => void;
+export type IFilterResponse = {
+    isOK: boolean;
+    payload: any;
+};

package/src/outLib/src/Libraries/Observables/AbstractSwitchCase.d.ts

@@ -1,37 +0,0 @@
-import { ICallback, IChainContainer } from "./Types";
-/**
- * Abstract class representing a Switch-Case control structure for handling
- * conditional chains of operations.
- *
- * @template T - The type of the input payload expected by the conditions.
- * @template P - The type extending IChainContainer, representing the container for the chain of operations.
- * @template W - The type of the subclass or the expected return type for method chaining.
- */
-export declare abstract class SwitchCase<T, P extends IChainContainer, W> {
-    protected pipe: P;
-    protected counter: number;
-    /**
-     * Creates an instance of the class and initializes the pipe and counter.
-     *
-     * @param {P} pipe - The pipe object used for initialization.
-     * @return {void}
-     */
-    constructor(pipe: P);
-    /**
-     * Adds a conditional case to the processing chain. The case determines
-     * whether further processing should continue based on the provided condition.
-     *
-     * @param {ICallback<any>} condition - A callback function that takes a payload
-     * and evaluates a condition. If the condition is met, further processing may be stopped.
-     * @return {W} Returns the current instance for method chaining.
-     */
-    case(condition: ICallback<any>): W;
-    /**
-     * Adds an array of conditions to the current instance by iterating through the provided array
-     * and adding each individual condition using the `case` method of the instance.
-     *
-     * @param {ICallback<any>[]} conditions - An array of callback functions representing conditions to be added.
-     * @return {W} The current instance after all conditions have been added.
-     */
-    pushCases(conditions: ICallback<any>[]): W;
-}

package/src/outLib/src/Libraries/Observables/AbstractSwitchCase.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SwitchCase = void 0;
-/**
- * Abstract class representing a Switch-Case control structure for handling
- * conditional chains of operations.
- *
- * @template T - The type of the input payload expected by the conditions.
- * @template P - The type extending IChainContainer, representing the container for the chain of operations.
- * @template W - The type of the subclass or the expected return type for method chaining.
- */
-class SwitchCase {
-    pipe;
-    counter;
-    /**
-     * Creates an instance of the class and initializes the pipe and counter.
-     *
-     * @param {P} pipe - The pipe object used for initialization.
-     * @return {void}
-     */
-    constructor(pipe) {
-        this.pipe = pipe;
-        this.counter = pipe.chain.length ? pipe.chain.length : 0;
-    }
-    /**
-     * Adds a conditional case to the processing chain. The case determines
-     * whether further processing should continue based on the provided condition.
-     *
-     * @param {ICallback<any>} condition - A callback function that takes a payload
-     * and evaluates a condition. If the condition is met, further processing may be stopped.
-     * @return {W} Returns the current instance for method chaining.
-     */
-    case(condition) {
-        this.counter++;
-        const id = this.counter;
-        const chain = this.pipe.chain;
-        chain.push((data) => {
-            data.isAvailable = true;
-            if (condition(data.payload))
-                data.isBreak = true;
-            if (id === chain.length && !data.isBreak)
-                data.isAvailable = false;
-        });
-        return this;
-    }
-    /**
-     * Adds an array of conditions to the current instance by iterating through the provided array
-     * and adding each individual condition using the `case` method of the instance.
-     *
-     * @param {ICallback<any>[]} conditions - An array of callback functions representing conditions to be added.
-     * @return {W} The current instance after all conditions have been added.
-     */
-    pushCases(conditions) {
-        if (!Array.isArray(conditions))
-            return this;
-        for (let i = 0; i < conditions.length; i++)
-            this.case(conditions[i]);
-        return this;
-    }
-}
-exports.SwitchCase = SwitchCase;

package/src/outLib/src/Libraries/Observables/Collector.d.ts

@@ -1,56 +0,0 @@
-import { ICollector, ISubscriptionLike } from "./Types";
-/**
- * The Collector class is responsible for managing a collection of resources or subscription-like objects
- * that need to be cleaned up or unsubscribed from, ensuring proper resource management.
- * Implements the ICollector interface.
- *
- * The typical lifecycle of a Collector involves collecting subscription-like items, optionally
- * unsubscribing from specific ones, unsubscribing from all resources, and destroying the collector
- * when it's no longer needed.
- */
-export declare class Collector implements ICollector {
-    protected arr: ISubscriptionLike[];
-    private killed;
-    /**
-     * Adds one or more subscription-like objects to the internal collection.
-     * Ensures the subscriptions are saved for future management if the object
-     * is not in a "killed" state.
-     *
-     * @param {ISubscriptionLike[]} subscriptionLikeList - The subscription-like objects to be collected.
-     * @return {void} This method does not return a value.
-     */
-    collect(...subscriptionLikeList: ISubscriptionLike[]): void;
-    /**
-     * Unsubscribes a given subscription and removes it from the internal array.
-     *
-     * @param {ISubscriptionLike | undefined} subscriptionLike - The subscription to unsubscribe and remove. If undefined, no action is taken.
-     * @return {void} This method does not return a value.
-     */
-    unsubscribe(subscriptionLike: ISubscriptionLike | undefined): void;
-    /**
-     * Unsubscribes from all the currently active subscriptions managed by this instance.
-     * If the instance is marked as killed, the method will exit without performing any action.
-     *
-     * @return {void | null} Returns `null` if the instance is killed, otherwise does not return a value.
-     */
-    unsubscribeAll(): void | null;
-    /**
-     * Determines the size of the array managed by the instance.
-     * If the instance is marked as killed, the size is returned as 0.
-     *
-     * @return {number} The number of elements in the array, or 0 if the instance is killed.
-     */
-    size(): number;
-    /**
-     * Cleans up resources by unsubscribing from all subscriptions, clearing the array, and marking the instance as destroyed.
-     *
-     * @return {void} Does not return any value.
-     */
-    destroy(): void;
-    /**
-     * Checks if the object is destroyed.
-     *
-     * @return {boolean} Returns true if the object is destroyed, otherwise false.
-     */
-    get isDestroyed(): boolean;
-}

package/src/outLib/src/Libraries/Observables/Collector.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Collector = void 0;
-const FunctionLibs_1 = require("./FunctionLibs");
-/**
- * The Collector class is responsible for managing a collection of resources or subscription-like objects
- * that need to be cleaned up or unsubscribed from, ensuring proper resource management.
- * Implements the ICollector interface.
- *
- * The typical lifecycle of a Collector involves collecting subscription-like items, optionally
- * unsubscribing from specific ones, unsubscribing from all resources, and destroying the collector
- * when it's no longer needed.
- */
-class Collector {
-    arr = [];
-    killed = false;
-    /**
-     * Adds one or more subscription-like objects to the internal collection.
-     * Ensures the subscriptions are saved for future management if the object
-     * is not in a "killed" state.
-     *
-     * @param {ISubscriptionLike[]} subscriptionLikeList - The subscription-like objects to be collected.
-     * @return {void} This method does not return a value.
-     */
-    collect(...subscriptionLikeList) {
-        if (!this.killed)
-            this.arr.push(...subscriptionLikeList);
-    }
-    /**
-     * Unsubscribes a given subscription and removes it from the internal array.
-     *
-     * @param {ISubscriptionLike | undefined} subscriptionLike - The subscription to unsubscribe and remove. If undefined, no action is taken.
-     * @return {void} This method does not return a value.
-     */
-    unsubscribe(subscriptionLike) {
-        if (this.killed)
-            return;
-        subscriptionLike?.unsubscribe();
-        (0, FunctionLibs_1.quickDeleteFromArray)(this.arr, subscriptionLike);
-    }
-    /**
-     * Unsubscribes from all the currently active subscriptions managed by this instance.
-     * If the instance is marked as killed, the method will exit without performing any action.
-     *
-     * @return {void | null} Returns `null` if the instance is killed, otherwise does not return a value.
-     */
-    unsubscribeAll() {
-        if (this.killed)
-            return;
-        const arr = this.arr;
-        for (let i = 0; i < arr.length; i++)
-            arr[i].unsubscribe();
-        arr.length = 0;
-    }
-    /**
-     * Determines the size of the array managed by the instance.
-     * If the instance is marked as killed, the size is returned as 0.
-     *
-     * @return {number} The number of elements in the array, or 0 if the instance is killed.
-     */
-    size() {
-        if (this.killed)
-            return 0;
-        return this.arr.length;
-    }
-    /**
-     * Cleans up resources by unsubscribing from all subscriptions, clearing the array, and marking the instance as destroyed.
-     *
-     * @return {void} Does not return any value.
-     */
-    destroy() {
-        this.unsubscribeAll();
-        this.arr.length = 0;
-        this.arr = 0;
-        this.killed = true;
-    }
-    /**
-     * Checks if the object is destroyed.
-     *
-     * @return {boolean} Returns true if the object is destroyed, otherwise false.
-     */
-    get isDestroyed() {
-        return this.killed;
-    }
-}
-exports.Collector = Collector;

package/src/outLib/src/Libraries/Observables/FilterCollection.d.ts

@@ -1,70 +0,0 @@
-import { ICallback, IErrorCallback, IFilter, IFilterCase, IFilterChainCallback, IFilterPayload, IFilterResponse, IFilterSetup, IFilterSwitch } from "./Types";
-import { SwitchCase } from "./AbstractSwitchCase";
-/**
- * FilterCollection is a generic class implementing the IFilter and IFilterSwitch interfaces.
- * It is designed to handle a series of filtering operations on a given payload, structured as a chain of filter methods.
- * The class allows addition of filters, chaining of multiple filters, and provides mechanisms for handling payload processing flow.
- *
- * @template T The type of data that the filters will operate upon.
- */
-export declare class FilterCollection<T> implements IFilter<T>, IFilterSwitch<T> {
-    chain: IFilterChainCallback[];
-    flow: IFilterPayload;
-    response: IFilterResponse;
-    private errHandler;
-    /**
-     * Determines whether the chain is empty.
-     * @return {boolean} Returns true if the chain contains no elements, otherwise false.
-     */
-    get isEmpty(): boolean;
-    /**
-     * Adds a callback to the filter chain and returns the current instance.
-     *
-     * @param {IFilterChainCallback} callback - The callback function to be added to the filter chain.
-     * @return {IFilterSetup<T>} The current instance of IFilterSetup.
-     */
-    private push;
-    /**
-     * Filters the data based on the given condition.
-     *
-     * @param {ICallback<any>} condition - A callback function that determines whether a data item should be included.
-     *                                      Should return a truthy value to include the item.
-     * @return {IFilterSetup<T>} - The updated filter setup after applying the condition.
-     */
-    filter(condition: ICallback<any>): IFilterSetup<T>;
-    /**
-     * Adds an array of filter conditions to the current filter setup.
-     *
-     * @param {ICallback<any>[]} conditions - An array of callback functions representing filter conditions.
-     * @return {IFilterSetup<T>} The updated filter setup instance.
-     */
-    pushFilters(conditions: ICallback<any>[]): IFilterSetup<T>;
-    /**
-     * Creates and returns a new instance of the `FilterSwitchCase` class to handle switch case logic with the current context.
-     *
-     * @return {FilterSwitchCase<T>} A new instance of `FilterSwitchCase` initialized with the current context.
-     */
-    switch(): FilterSwitchCase<T>;
-    /**
-     * Processes a chain of functions with the given input value and manages the execution flow through the chain.
-     *
-     * @param {T} value - The input value to be processed through the chain.
-     * @return {IFilterResponse} The final response containing the processing status and payload.
-     */
-    processChain(value: T): IFilterResponse;
-    /**
-     * Assigns an error handler function to manage errors within the application.
-     *
-     * @param {IErrorCallback} errorHandler - A callback function that will handle error events.
-     * @return {void}
-     */
-    addErrorHandler(errorHandler: IErrorCallback): void;
-}
-/**
- * The FilterSwitchCase class extends the SwitchCase class and represents a specific type of switch case
- * logic applied to a collection of filters. It is used for branching logic based on filter cases.
- *
- * @template T - The type of the elements being processed by the filters.
- */
-export declare class FilterSwitchCase<T> extends SwitchCase<T, FilterCollection<T>, IFilterCase<T>> {
-}

package/src/outLib/src/Libraries/Observables/FilterCollection.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterSwitchCase = exports.FilterCollection = void 0;
-const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
-/**
- * FilterCollection is a generic class implementing the IFilter and IFilterSwitch interfaces.
- * It is designed to handle a series of filtering operations on a given payload, structured as a chain of filter methods.
- * The class allows addition of filters, chaining of multiple filters, and provides mechanisms for handling payload processing flow.
- *
- * @template T The type of data that the filters will operate upon.
- */
-class FilterCollection {
-    chain = [];
-    flow = { isBreak: false, isAvailable: false, payload: null };
-    response = { isOK: false, payload: undefined };
-    errHandler;
-    /**
-     * Determines whether the chain is empty.
-     * @return {boolean} Returns true if the chain contains no elements, otherwise false.
-     */
-    get isEmpty() {
-        return !this.chain.length;
-    }
-    /**
-     * Adds a callback to the filter chain and returns the current instance.
-     *
-     * @param {IFilterChainCallback} callback - The callback function to be added to the filter chain.
-     * @return {IFilterSetup<T>} The current instance of IFilterSetup.
-     */
-    push(callback) {
-        this.chain.push(callback);
-        return this;
-    }
-    /**
-     * Filters the data based on the given condition.
-     *
-     * @param {ICallback<any>} condition - A callback function that determines whether a data item should be included.
-     *                                      Should return a truthy value to include the item.
-     * @return {IFilterSetup<T>} - The updated filter setup after applying the condition.
-     */
-    filter(condition) {
-        return this.push((data) => condition(data.payload) && (data.isAvailable = true));
-    }
-    /**
-     * Adds an array of filter conditions to the current filter setup.
-     *
-     * @param {ICallback<any>[]} conditions - An array of callback functions representing filter conditions.
-     * @return {IFilterSetup<T>} The updated filter setup instance.
-     */
-    pushFilters(conditions) {
-        if (!Array.isArray(conditions))
-            return this;
-        for (let i = 0; i < conditions.length; i++)
-            this.filter(conditions[i]);
-        return this;
-    }
-    /**
-     * Creates and returns a new instance of the `FilterSwitchCase` class to handle switch case logic with the current context.
-     *
-     * @return {FilterSwitchCase<T>} A new instance of `FilterSwitchCase` initialized with the current context.
-     */
-    switch() {
-        return new FilterSwitchCase(this);
-    }
-    /**
-     * Processes a chain of functions with the given input value and manages the execution flow through the chain.
-     *
-     * @param {T} value - The input value to be processed through the chain.
-     * @return {IFilterResponse} The final response containing the processing status and payload.
-     */
-    processChain(value) {
-        const chain = this.chain;
-        const data = this.flow;
-        const response = this.response;
-        response.isOK = false;
-        response.payload = undefined;
-        data.payload = value;
-        data.isBreak = false;
-        try {
-            const len = chain.length;
-            for (let i = 0; i < len; i++) {
-                data.isAvailable = false;
-                chain[i](data);
-                if (!data.isAvailable)
-                    return response;
-                if (data.isBreak)
-                    break;
-            }
-        }
-        catch (err) {
-            if (this.errHandler) {
-                this.errHandler(err, "Filter.processChain ERROR:");
-            }
-            else {
-                console.log("Filter.processChain ERROR:", err);
-            }
-            return response;
-        }
-        response.isOK = true;
-        response.payload = data.payload;
-        return response;
-    }
-    /**
-     * Assigns an error handler function to manage errors within the application.
-     *
-     * @param {IErrorCallback} errorHandler - A callback function that will handle error events.
-     * @return {void}
-     */
-    addErrorHandler(errorHandler) {
-        this.errHandler = errorHandler;
-    }
-}
-exports.FilterCollection = FilterCollection;
-/**
- * The FilterSwitchCase class extends the SwitchCase class and represents a specific type of switch case
- * logic applied to a collection of filters. It is used for branching logic based on filter cases.
- *
- * @template T - The type of the elements being processed by the filters.
- */
-class FilterSwitchCase extends AbstractSwitchCase_1.SwitchCase {
-}
-exports.FilterSwitchCase = FilterSwitchCase;