evg_observable 2.15.1 → 2.15.2

package/src/outLib/Pipe.d.ts

@@ -1,108 +1,20 @@
 import { ICallback, IChainCallback, IErrorCallback, IListener, IPipeCase, IPipePayload, ISetObservableValue, ISetup, ISubscribe, ISubscriptionLike } from "./Types";
 import { SwitchCase } from "./AbstractSwitchCase";
-/**
- * An abstract class that provides a flexible pipeline mechanism to process and transform streamed data.
- * The `Pipe` class allows chaining of operations, conditional transformations, and controlled subscription handling.
- *
- * @template T The type of data handled by this pipeline.
- */
 export declare abstract class Pipe<T> implements ISubscribe<T> {
     chain: IChainCallback[];
     flow: IPipePayload;
-    /**
-     * Subscribes a listener to observe changes or updates. Can optionally handle errors during the subscription process.
-     *
-     * @param {IListener<T> | ISetObservableValue} listener - The listener or handler that will receive notifications of updates.
-     * @param {IErrorCallback} [errorHandler] - An optional callback to handle errors that occur during subscription.
-     * @return {ISubscriptionLike | undefined} An object representing the subscription, or undefined if the subscription could not be created.
-     */
     abstract subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
     private push;
-    /**
-     * Subscribes to an event and ensures the listener is called only once.
-     * After the listener is invoked, it unsubscribes automatically.
-     *
-     * @return {ISubscribe<T>} The subscription instance allowing further chaining or management.
-     */
     setOnce(): ISubscribe<T>;
-    /**
-     * Unsubscribes based on a given condition. The condition is evaluated against
-     * the payload, and if the condition returns true, the subscription is marked
-     * for unsubscription.
-     *
-     * @param {ICallback<T>} condition - A callback function that determines whether a
-     * subscription should be unsubscribed. It receives the payload as an argument
-     * and should return a boolean value.
-     * @return {ISetup<T>} The current setup instance for chaining purposes.
-     */
     unsubscribeBy(condition: ICallback<T>): ISetup<T>;
-    /**
-     * Applies a refinement condition to the workflow pipeline.
-     *
-     * @param {ICallback<T>} condition - A callback function that evaluates a condition
-     *                                    on the payload data and returns a boolean.
-     * @return {ISetup<T>} Returns the updated setup with the refined condition applied.
-     */
     refine(condition: ICallback<T>): ISetup<T>;
-    /**
-     * Adds an array of conditions to be processed by the refinement function.
-     *
-     * @param {ICallback<any>[]} conditions - An array of callback functions to be refined.
-     * @return {ISetup<T>} The current setup instance after processing the conditions.
-     */
     pushRefiners(conditions: ICallback<any>[]): ISetup<T>;
-    /**
-     * Creates and returns a new instance of the PipeSwitchCase class,
-     * enabling conditional logic or case-switch handling for the current context.
-     *
-     * @return {PipeSwitchCase<T>} A new instance of PipeSwitchCase associated with the current context.
-     */
     switch(): PipeSwitchCase<T>;
-    /**
-     * Registers a condition callback to be executed within the pipeline and modifies the payload of the current data.
-     * The condition is applied to the current payload and sets a flag indicating its availability.
-     *
-     * @param {ICallback<T>} condition - The callback function to execute on the current payload. It processes the payload and returns a new value.
-     * @return {ISetup<K>} An instance of the setup interface, allowing further chaining of operations.
-     */
     then<K>(condition: ICallback<T>): ISetup<K>;
-    /**
-     * Serializes the payload of the given data object into a JSON string and
-     * sets the `isAvailable` property to true.
-     *
-     * @return {ISetup<string>} The modified setup instance with the serialized payload.
-     */
     serialize(): ISetup<string>;
-    /**
-     * Deserializes the payload of the provided data into a JavaScript object using JSON.parse
-     * and marks the data as available.
-     *
-     * @template K - The type of the setup to be returned.
-     * @return {ISetup<K>} The setup instance after deserializing the payload.
-     */
     deserialize<K>(): ISetup<K>;
-    /**
-     * Processes a chain of functions with the given listener and flow data.
-     *
-     * @param {IListener<T>} listener - The listener to be executed after the chain is processed.
-     *                                   Receives the payload of the flow data.
-     * @return {void} This method does not return a value.
-     */
     processChain(listener: IListener<T>): void;
 }
-/**
- * The `PipeSwitchCase` class extends the functionality of the `SwitchCase`
- * class, tailored for use with `Pipe` objects. It provides a mechanism for
- * managing and subscribing to a pipeline of transformations or processes
- * conditioned by specific cases.
- *
- * This class also implements `ISubscribe` to allow subscription to the
- * underlying pipeline for observing or reacting to its events or values.
- *
- * @template T The type of the data being handled by the `PipeSwitchCase`.
- * @extends {SwitchCase<T, Pipe<T>, IPipeCase<T>>}
- * @implements {ISubscribe<T>}
- */
 export declare class PipeSwitchCase<T> extends SwitchCase<T, Pipe<T>, IPipeCase<T>> implements ISubscribe<T> {
     subscribe(listener: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
 }

package/src/outLib/Pipe.js

@@ -2,12 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PipeSwitchCase = exports.Pipe = void 0;
 const AbstractSwitchCase_1 = require("./AbstractSwitchCase");
-/**
- * An abstract class that provides a flexible pipeline mechanism to process and transform streamed data.
- * The `Pipe` class allows chaining of operations, conditional transformations, and controlled subscription handling.
- *
- * @template T The type of data handled by this pipeline.
- */
 class Pipe {
     chain = [];
     flow = { isBreak: false, isUnsubscribe: false, isAvailable: false, payload: null };
@@ -15,28 +9,12 @@ class Pipe {
         this.chain.push(callback);
         return this;
     }
-    /**
-     * Subscribes to an event and ensures the listener is called only once.
-     * After the listener is invoked, it unsubscribes automatically.
-     *
-     * @return {ISubscribe<T>} The subscription instance allowing further chaining or management.
-     */
     setOnce() {
         return this.push((data) => {
             this.listener(data.payload);
             data.isUnsubscribe = true;
         });
     }
-    /**
-     * Unsubscribes based on a given condition. The condition is evaluated against
-     * the payload, and if the condition returns true, the subscription is marked
-     * for unsubscription.
-     *
-     * @param {ICallback<T>} condition - A callback function that determines whether a
-     * subscription should be unsubscribed. It receives the payload as an argument
-     * and should return a boolean value.
-     * @return {ISetup<T>} The current setup instance for chaining purposes.
-     */
     unsubscribeBy(condition) {
         return this.push((data) => {
             data.isAvailable = true;
@@ -44,22 +22,9 @@ class Pipe {
                 data.isUnsubscribe = true;
         });
     }
-    /**
-     * Applies a refinement condition to the workflow pipeline.
-     *
-     * @param {ICallback<T>} condition - A callback function that evaluates a condition
-     *                                    on the payload data and returns a boolean.
-     * @return {ISetup<T>} Returns the updated setup with the refined condition applied.
-     */
     refine(condition) {
         return this.push((data) => condition(data.payload) && (data.isAvailable = true));
     }
-    /**
-     * Adds an array of conditions to be processed by the refinement function.
-     *
-     * @param {ICallback<any>[]} conditions - An array of callback functions to be refined.
-     * @return {ISetup<T>} The current setup instance after processing the conditions.
-     */
     pushRefiners(conditions) {
         if (!Array.isArray(conditions))
             return this;
@@ -67,60 +32,27 @@ class Pipe {
             this.refine(conditions[i]);
         return this;
     }
-    /**
-     * Creates and returns a new instance of the PipeSwitchCase class,
-     * enabling conditional logic or case-switch handling for the current context.
-     *
-     * @return {PipeSwitchCase<T>} A new instance of PipeSwitchCase associated with the current context.
-     */
     switch() {
         return new PipeSwitchCase(this);
     }
-    /**
-     * Registers a condition callback to be executed within the pipeline and modifies the payload of the current data.
-     * The condition is applied to the current payload and sets a flag indicating its availability.
-     *
-     * @param {ICallback<T>} condition - The callback function to execute on the current payload. It processes the payload and returns a new value.
-     * @return {ISetup<K>} An instance of the setup interface, allowing further chaining of operations.
-     */
     then(condition) {
         return this.push((data) => {
             data.payload = condition(data.payload);
             data.isAvailable = true;
         });
     }
-    /**
-     * Serializes the payload of the given data object into a JSON string and
-     * sets the `isAvailable` property to true.
-     *
-     * @return {ISetup<string>} The modified setup instance with the serialized payload.
-     */
     serialize() {
         return this.push((data) => {
             data.payload = JSON.stringify(data.payload);
             data.isAvailable = true;
         });
     }
-    /**
-     * Deserializes the payload of the provided data into a JavaScript object using JSON.parse
-     * and marks the data as available.
-     *
-     * @template K - The type of the setup to be returned.
-     * @return {ISetup<K>} The setup instance after deserializing the payload.
-     */
     deserialize() {
         return this.push((data) => {
             data.payload = JSON.parse(data.payload);
             data.isAvailable = true;
         });
     }
-    /**
-     * Processes a chain of functions with the given listener and flow data.
-     *
-     * @param {IListener<T>} listener - The listener to be executed after the chain is processed.
-     *                                   Receives the payload of the flow data.
-     * @return {void} This method does not return a value.
-     */
     processChain(listener) {
         const chain = this.chain;
         const data = this.flow;
@@ -140,19 +72,6 @@ class Pipe {
     }
 }
 exports.Pipe = Pipe;
-/**
- * The `PipeSwitchCase` class extends the functionality of the `SwitchCase`
- * class, tailored for use with `Pipe` objects. It provides a mechanism for
- * managing and subscribing to a pipeline of transformations or processes
- * conditioned by specific cases.
- *
- * This class also implements `ISubscribe` to allow subscription to the
- * underlying pipeline for observing or reacting to its events or values.
- *
- * @template T The type of the data being handled by the `PipeSwitchCase`.
- * @extends {SwitchCase<T, Pipe<T>, IPipeCase<T>>}
- * @implements {ISubscribe<T>}
- */
 class PipeSwitchCase extends AbstractSwitchCase_1.SwitchCase {
     subscribe(listener, errorHandler) {
         return this.pipe.subscribe(listener, errorHandler);

package/src/outLib/SubscribeObject.d.ts

@@ -1,83 +1,18 @@
 import { IErrorCallback, IListener, IObserver, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
 import { Pipe } from "./Pipe";
-/**
- * A class that represents an observable object with subscription, pausing,
- * and piping functionalities. It allows subscribing to updates, handling errors,
- * and processing values through a chain.
- *
- * @template T The type of values handled by SubscribeObject.
- * @extends Pipe<T>
- * @implements ISubscribeObject<T>
- */
 export declare class SubscribeObject<T> extends Pipe<T> implements ISubscribeObject<T> {
     observer: IObserver<T> | undefined;
     listener: IListener<T> | undefined;
-    /**
-     * A callback function used for handling errors in the context of the SubscribeObject.
-     * This function logs the provided error data and error message to the console for debugging purposes.
-     *
-     * @type {IErrorCallback}
-     * @param {any} errorData - The data related to the error encountered.
-     * @param {any} errorMessage - A descriptive message detailing the error.
-     */
     errorHandler: IErrorCallback;
     _order: number;
     paused: boolean;
     piped: boolean;
-    /**
-     * Constructs an instance of the class.
-     *
-     * @param {IObserver<T>} [observable] - The observer instance to be assigned. Optional parameter.
-     * @param {boolean} [isPipe=false] - Determines whether the instance is piped. Defaults to false.
-     * @return {void}
-     */
     constructor(observable?: IObserver<T>, isPipe?: boolean);
-    /**
-     * Subscribes an observer to the current instance and optionally assigns an error handler.
-     *
-     * @param {ISubscribeGroup<T>} observer - The observer group to subscribe.
-     * @param {IErrorCallback} [errorHandler] - Optional callback to handle errors.
-     * @return {ISubscriptionLike} An instance representing the subscription.
-     */
     subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike;
-    /**
-     * Unsubscribes the current instance from the associated observer, clears the listener,
-     * and resets the internal chain.
-     * This method ensures that the instance is properly cleaned up and no longer receives updates.
-     *
-     * @return {void} Does not return a value.
-     */
     unsubscribe(): void;
-    /**
-     * Sends the specified value for processing and updates the flow state.
-     *
-     * @param {T} value - The value to be sent and processed.
-     * @return {void} Does not return a value.
-     */
     send(value: T): void;
-    /**
-     * Resumes the current process or operation from a paused state.
-     * Updates the internal state to indicate that it is no longer paused.
-     *
-     * @return {void} Does not return a value.
-     */
     resume(): void;
-    /**
-     * Pauses the current operation or process by setting the paused state to true.
-     *
-     * @return {void} No value is returned.
-     */
     pause(): void;
-    /**
-     * Retrieves the current order value.
-     *
-     * @return {number} The current value of the order.
-     */
     get order(): number;
-    /**
-     * Sets the order value.
-     *
-     * @param {number} value - The numerical value to set as the order.
-     */
     set order(value: number);
 }

package/src/outLib/SubscribeObject.js

@@ -3,63 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SubscribeObject = void 0;
 const Pipe_1 = require("./Pipe");
 const FunctionLibs_1 = require("./FunctionLibs");
-/**
- * A class that represents an observable object with subscription, pausing,
- * and piping functionalities. It allows subscribing to updates, handling errors,
- * and processing values through a chain.
- *
- * @template T The type of values handled by SubscribeObject.
- * @extends Pipe<T>
- * @implements ISubscribeObject<T>
- */
 class SubscribeObject extends Pipe_1.Pipe {
     observer;
     listener;
-    /**
-     * A callback function used for handling errors in the context of the SubscribeObject.
-     * This function logs the provided error data and error message to the console for debugging purposes.
-     *
-     * @type {IErrorCallback}
-     * @param {any} errorData - The data related to the error encountered.
-     * @param {any} errorMessage - A descriptive message detailing the error.
-     */
     errorHandler = (errorData, errorMessage) => {
         console.log(`(Unit of SubscribeObject).send(${errorData}) ERROR:`, errorMessage);
     };
     _order = 0;
     paused = false;
     piped = false;
-    /**
-     * Constructs an instance of the class.
-     *
-     * @param {IObserver<T>} [observable] - The observer instance to be assigned. Optional parameter.
-     * @param {boolean} [isPipe=false] - Determines whether the instance is piped. Defaults to false.
-     * @return {void}
-     */
     constructor(observable, isPipe) {
         super();
         this.observer = observable;
         this.piped = !!isPipe;
     }
-    /**
-     * Subscribes an observer to the current instance and optionally assigns an error handler.
-     *
-     * @param {ISubscribeGroup<T>} observer - The observer group to subscribe.
-     * @param {IErrorCallback} [errorHandler] - Optional callback to handle errors.
-     * @return {ISubscriptionLike} An instance representing the subscription.
-     */
     subscribe(observer, errorHandler) {
         this.listener = (0, FunctionLibs_1.getListener)(observer);
         errorHandler && (this.errorHandler = errorHandler);
         return this;
     }
-    /**
-     * Unsubscribes the current instance from the associated observer, clears the listener,
-     * and resets the internal chain.
-     * This method ensures that the instance is properly cleaned up and no longer receives updates.
-     *
-     * @return {void} Does not return a value.
-     */
     unsubscribe() {
         if (!this.observer)
             return;
@@ -68,12 +30,6 @@ class SubscribeObject extends Pipe_1.Pipe {
         this.listener = null;
         this.chain.length = 0;
     }
-    /**
-     * Sends the specified value for processing and updates the flow state.
-     *
-     * @param {T} value - The value to be sent and processed.
-     * @return {void} Does not return a value.
-     */
     send(value) {
         const listener = this.listener;
         if (!listener) {
@@ -82,7 +38,6 @@ class SubscribeObject extends Pipe_1.Pipe {
         }
         if (!this.observer || this.paused)
             return;
-        // Fast path (no pipe)
         if (!this.piped) {
             try {
                 listener(value);
@@ -92,7 +47,6 @@ class SubscribeObject extends Pipe_1.Pipe {
             }
             return;
         }
-        // Slow path (with pipe)
         try {
             this.flow.payload = value;
             this.flow.isBreak = false;
@@ -102,36 +56,15 @@ class SubscribeObject extends Pipe_1.Pipe {
             this.errorHandler(value, err);
         }
     }
-    /**
-     * Resumes the current process or operation from a paused state.
-     * Updates the internal state to indicate that it is no longer paused.
-     *
-     * @return {void} Does not return a value.
-     */
     resume() {
         this.paused = false;
     }
-    /**
-     * Pauses the current operation or process by setting the paused state to true.
-     *
-     * @return {void} No value is returned.
-     */
     pause() {
         this.paused = true;
     }
-    /**
-     * Retrieves the current order value.
-     *
-     * @return {number} The current value of the order.
-     */
     get order() {
         return this._order;
     }
-    /**
-     * Sets the order value.
-     *
-     * @param {number} value - The numerical value to set as the order.
-     */
     set order(value) {
         this._order = value;
     }