evg_observable 2.15.1 → 2.15.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "evg_observable",
-  "version": "2.15.1",
+  "version": "2.15.3",
   "description": "Alternative fast and light library version - observable.",
   "main": "src/outLib/index.js",
   "types": "src/outLib/index.d.ts",

package/src/outLib/AbstractSwitchCase.d.ts

@@ -1,37 +1,8 @@
 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/AbstractSwitchCase.js

@@ -1,35 +1,13 @@
 "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;
@@ -43,13 +21,6 @@ class SwitchCase {
         });
         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;

package/src/outLib/Collector.d.ts

@@ -1,56 +1,11 @@
 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/Collector.js

@@ -2,48 +2,19 @@
 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;
@@ -52,33 +23,17 @@ class Collector {
             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;
     }

package/src/outLib/FilterCollection.d.ts

@@ -1,70 +1,17 @@
 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/FilterCollection.js

@@ -2,51 +2,21 @@
 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;
@@ -54,20 +24,9 @@ class FilterCollection {
             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;
@@ -100,23 +59,11 @@ class FilterCollection {
         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;

package/src/outLib/FunctionLibs.d.ts

@@ -1,48 +1,6 @@
 import { IListener, ISubscribeGroup, ISubscribeObject } from "./Types";
-/**
- * Compares two ISubscribeObject items based on their `order` property
- * and sorts them in ascending order.
- *
- * @param {ISubscribeObject<any>} a - The first object to compare.
- * @param {ISubscribeObject<any>} b - The second object to compare.
- * @return {number} - Returns 1 if the `order` property of `a` is greater than `b`,
- *                    -1 if the `order` property of `a` is less than `b`,
- *                     or 0 if they are equal.
- */
 export declare function sortAscending(a: ISubscribeObject<any>, b: ISubscribeObject<any>): number;
-/**
- * Compares two objects based on their `order` property for descending sorting.
- *
- * @param {ISubscribeObject<any>} a - The first object to compare, expected to have an `order` property.
- * @param {ISubscribeObject<any>} b - The second object to compare, expected to have an `order` property.
- * @return {number} - Returns -1 if `a.order` is greater than `b.order`, 1 if `a.order` is less than `b.order`, and 0 if they are equal.
- */
 export declare function sortDescending(a: ISubscribeObject<any>, b: ISubscribeObject<any>): number;
-/**
- * Removes the specified component from the provided array if it exists.
- *
- * @param {T[]} arr - The array from which the component will be removed.
- * @param {T} component - The component to be removed from the array.
- * @return {boolean} Returns true if the component was successfully removed, false otherwise.
- */
 export declare function deleteFromArray<T>(arr: T[], component: T): boolean;
-/**
- * Removes a specified element from an array by replacing it with the last element
- * and reducing the array's length. This method avoids maintaining order but performs
- * the deletion operation efficiently.
- *
- * @param {T[]} arr - The array from which the element will be removed.
- * @param {T} component - The element to be removed from the array.
- * @return {boolean} - Returns true if the element was found and removed;
- *                     otherwise, returns false.
- */
 export declare function quickDeleteFromArray<T>(arr: T[], component: T): boolean;
-/**
- * Returns a listener function based on the provided listener group.
- *
- * @param {ISubscribeGroup<T>} listenerGroup - The group of listener(s). It can be a single listener
- *        or an array of listeners that are invoked when the returned listener is called.
- * @return {IListener<T>} A single listener function that wraps the provided listener or group of listeners
- *         and invokes them with the provided data.
- */
 export declare function getListener<T>(listenerGroup: ISubscribeGroup<T>): IListener<T>;

package/src/outLib/FunctionLibs.js

@@ -5,16 +5,6 @@ exports.sortDescending = sortDescending;
 exports.deleteFromArray = deleteFromArray;
 exports.quickDeleteFromArray = quickDeleteFromArray;
 exports.getListener = getListener;
-/**
- * Compares two ISubscribeObject items based on their `order` property
- * and sorts them in ascending order.
- *
- * @param {ISubscribeObject<any>} a - The first object to compare.
- * @param {ISubscribeObject<any>} b - The second object to compare.
- * @return {number} - Returns 1 if the `order` property of `a` is greater than `b`,
- *                    -1 if the `order` property of `a` is less than `b`,
- *                     or 0 if they are equal.
- */
 function sortAscending(a, b) {
     if (a.order > b.order)
         return 1;
@@ -22,13 +12,6 @@ function sortAscending(a, b) {
         return -1;
     return 0;
 }
-/**
- * Compares two objects based on their `order` property for descending sorting.
- *
- * @param {ISubscribeObject<any>} a - The first object to compare, expected to have an `order` property.
- * @param {ISubscribeObject<any>} b - The second object to compare, expected to have an `order` property.
- * @return {number} - Returns -1 if `a.order` is greater than `b.order`, 1 if `a.order` is less than `b.order`, and 0 if they are equal.
- */
 function sortDescending(a, b) {
     if (a.order > b.order)
         return -1;
@@ -36,13 +19,6 @@ function sortDescending(a, b) {
         return 1;
     return 0;
 }
-/**
- * Removes the specified component from the provided array if it exists.
- *
- * @param {T[]} arr - The array from which the component will be removed.
- * @param {T} component - The component to be removed from the array.
- * @return {boolean} Returns true if the component was successfully removed, false otherwise.
- */
 function deleteFromArray(arr, component) {
     const index = arr.indexOf(component);
     if (index === -1)
@@ -50,16 +26,6 @@ function deleteFromArray(arr, component) {
     arr.splice(index, 1);
     return true;
 }
-/**
- * Removes a specified element from an array by replacing it with the last element
- * and reducing the array's length. This method avoids maintaining order but performs
- * the deletion operation efficiently.
- *
- * @param {T[]} arr - The array from which the element will be removed.
- * @param {T} component - The element to be removed from the array.
- * @return {boolean} - Returns true if the element was found and removed;
- *                     otherwise, returns false.
- */
 function quickDeleteFromArray(arr, component) {
     const index = arr.indexOf(component);
     if (index === -1)
@@ -68,14 +34,6 @@ function quickDeleteFromArray(arr, component) {
     arr.length--;
     return true;
 }
-/**
- * Returns a listener function based on the provided listener group.
- *
- * @param {ISubscribeGroup<T>} listenerGroup - The group of listener(s). It can be a single listener
- *        or an array of listeners that are invoked when the returned listener is called.
- * @return {IListener<T>} A single listener function that wraps the provided listener or group of listeners
- *         and invokes them with the provided data.
- */
 function getListener(listenerGroup) {
     if (Array.isArray(listenerGroup)) {
         const group = [];
@@ -88,12 +46,6 @@ function getListener(listenerGroup) {
     }
     return wrapListener(listenerGroup);
 }
-/**
- * Wraps the provided listener, ensuring it conforms to the IListener<T> interface.
- *
- * @param listener The listener to be wrapped. Can be either an IListener<T> or an ISetObservableValue.
- * @return Returns a listener that adheres to the IListener<T> interface.
- */
 function wrapListener(listener) {
     if ("next" in listener)
         return (value) => listener.next(value);