evg_observable 2.14.60 → 2.15.0

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

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderedObservable = void 0;
+const Observable_1 = require("./Observable");
+const FunctionLibs_1 = require("./FunctionLibs");
+const OrderedSubscribeObject_1 = require("./OrderedSubscribeObject");
+/**
+ * Represents an observable data structure that maintains elements in a specific order and provides
+ * methods to manipulate and subscribe to its elements.
+ *
+ * The `OrderedObservable` class supports sorting elements in ascending or descending order and allows
+ * for subscription to changes in its state. It extends the capabilities of a basic `Observable` by
+ * incorporating sorting and ordered processing mechanisms.
+ *
+ * @template T The type of data stored and handled by the observable.
+ * @extends Observable<T>
+ * @implements IOrdered<T>
+ */
+class OrderedObservable extends Observable_1.Observable {
+    /**
+     * Represents the direction in which sorting should occur.
+     * The value is expected to indicate whether the sorting
+     * should be performed in ascending or descending order.
+     *
+     * Possible values:
+     * - `sortAscending`: Sorting in ascending order.
+     * - `sortDescending`: Sorting in descending order.
+     */
+    sortDirection = FunctionLibs_1.sortAscending;
+    /**
+     * Sets the sorting order to ascending and applies the sorting.
+     *
+     * @return {boolean} Returns true if the sorting operation is successful, otherwise false.
+     */
+    setAscendingSort() {
+        this.sortDirection = FunctionLibs_1.sortAscending;
+        return this.sortByOrder();
+    }
+    /**
+     * Sets the sorting order to descending and updates the sort configuration.
+     *
+     * @return {boolean} Returns `true` if the sorting operation is configured and applied successfully, otherwise returns `false`.
+     */
+    setDescendingSort() {
+        this.sortDirection = FunctionLibs_1.sortDescending;
+        return this.sortByOrder();
+    }
+    /**
+     * Sorts the `subs` array based on the specified sort direction if the object is not in a "killed" state.
+     *
+     * @return {boolean} Returns true if the sorting was performed, false if the object is in a "killed" state.
+     */
+    sortByOrder() {
+        if (this.killed)
+            return false;
+        this.subs.sort(this.sortDirection);
+        return true;
+    }
+    /**
+     * Subscribes a listener to this instance with an optional error handler.
+     *
+     * @param {ISubscribeGroup<T>} listener - The listener object that should be notified of changes.
+     * @param {IErrorCallback} [errorHandler] - An optional handler to process errors during execution.
+     * @return {IOrderedSubscriptionLike | undefined} Returns an instance of IOrderedSubscriptionLike if the listener is valid; otherwise, returns undefined.
+     */
+    subscribe(listener, errorHandler) {
+        if (!this.isListener(listener))
+            return undefined;
+        const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, false);
+        this.addObserver(subscribeObject, listener, errorHandler);
+        return subscribeObject;
+    }
+    /**
+     * Creates and returns an instance of `OrderedSubscribeObject` tied to the current object,
+     * facilitating ordered subscription setup. If the instance is marked as killed, it returns undefined.
+     *
+     * @return {IOrderedSetup<T> | undefined} An instance of `OrderedSubscribeObject` for subscription setup,
+     *         or undefined if the operation is not allowed.
+     */
+    pipe() {
+        if (this.killed)
+            return undefined;
+        const subscribeObject = new OrderedSubscribeObject_1.OrderedSubscribeObject(this, true);
+        this.subs.push(subscribeObject);
+        return subscribeObject;
+    }
+    /**
+     * Removes a previously subscribed listener from the subscription list,
+     * preventing it from receiving further updates. If the system is in a
+     * "killed" state or specific conditions in the process flow are met,
+     * the listener may instead be added to a trash list.
+     *
+     * @param {ISubscriptionLike} listener - The subscription listener to be unsubscribed or handled accordingly.
+     * @return {void} Does not return any value.
+     */
+    unSubscribe(listener) {
+        if (this.killed)
+            return;
+        if (this.process && listener) {
+            this.trash.push(listener);
+            return;
+        }
+        this.subs && !(0, FunctionLibs_1.quickDeleteFromArray)(this.subs, listener);
+    }
+}
+exports.OrderedObservable = OrderedObservable;

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

@@ -0,0 +1,53 @@
+import { SubscribeObject } from "./SubscribeObject";
+import { IErrorCallback, IListener, IOrdered, IOrderedSetup, IOrderedSubscribe, IOrderedSubscriptionLike, ISetObservableValue } from "./Types";
+import { OrderedObservable } from "./OrderedObservable";
+/**
+ * Represents an ordered subscription object, extending the functionality
+ * of the SubscribeObject to include ordering and the ability to manage
+ * subscriptions based on a given order.
+ *
+ * This class is designed to work with observables that support ordering
+ * functionality. It implements the `IOrderedSetup` interface to manage
+ * ordering behavior and sorting operations.
+ *
+ * @template T The type of the data managed by the subscription.
+ */
+export declare class OrderedSubscribeObject<T> extends SubscribeObject<T> implements IOrderedSetup<T> {
+    /**
+     * Creates an instance of the constructor with the specified observable and pipe flag.
+     *
+     * @param {OrderedObservable<T> | IOrdered<T>} observable - The ordered observable or IOrdered instance to attach to this instance.
+     * @param {boolean} [isPipe] - Optional flag indicating if the stream is part of a piping sequence.
+     * @return {void}
+     */
+    constructor(observable: OrderedObservable<T> | IOrdered<T>, isPipe?: boolean);
+    /**
+     * Retrieves the order value.
+     *
+     * @return {number} The current order value.
+     */
+    get order(): number;
+    /**
+     * Sets the order value for this object. If the observer is not defined or is destroyed,
+     * the order value is reset to undefined. Otherwise, the order value is updated, and
+     * the observer is instructed to sort items by the updated order.
+     *
+     * @param {number} value - The new order value to be set.
+     */
+    set order(value: number);
+    /**
+     * Subscribes an observer to the observable, allowing it to receive updates.
+     *
+     * @param {IListener<T> | ISetObservableValue} observer - The observer that will receive updates. It can be either a listener function or a setter for the observable value.
+     * @param {IErrorCallback} [errorHandler] - An optional error callback that will be invoked if an error occurs during the subscription process.
+     * @return {IOrderedSubscriptionLike} The current subscription instance for chaining purposes.
+     */
+    subscribe(observer: IListener<T> | ISetObservableValue, errorHandler?: IErrorCallback): IOrderedSubscriptionLike;
+    /**
+     * Sets the subscription to be invoked only once. After the subscription
+     * is called for the first time, it will be automatically removed.
+     *
+     * @return {IOrderedSubscribe<T>} The subscription instance configured to execute only once.
+     */
+    setOnce(): IOrderedSubscribe<T>;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OrderedSubscribeObject = void 0;
+const SubscribeObject_1 = require("./SubscribeObject");
+/**
+ * Represents an ordered subscription object, extending the functionality
+ * of the SubscribeObject to include ordering and the ability to manage
+ * subscriptions based on a given order.
+ *
+ * This class is designed to work with observables that support ordering
+ * functionality. It implements the `IOrderedSetup` interface to manage
+ * ordering behavior and sorting operations.
+ *
+ * @template T The type of the data managed by the subscription.
+ */
+class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
+    /**
+     * Creates an instance of the constructor with the specified observable and pipe flag.
+     *
+     * @param {OrderedObservable<T> | IOrdered<T>} observable - The ordered observable or IOrdered instance to attach to this instance.
+     * @param {boolean} [isPipe] - Optional flag indicating if the stream is part of a piping sequence.
+     * @return {void}
+     */
+    constructor(observable, isPipe) {
+        super(observable, isPipe);
+    }
+    /**
+     * Retrieves the order value.
+     *
+     * @return {number} The current order value.
+     */
+    get order() {
+        return this._order;
+    }
+    /**
+     * Sets the order value for this object. If the observer is not defined or is destroyed,
+     * the order value is reset to undefined. Otherwise, the order value is updated, and
+     * the observer is instructed to sort items by the updated order.
+     *
+     * @param {number} value - The new order value to be set.
+     */
+    set order(value) {
+        if (!this.observer ||
+            (this.observer && this.observer.isDestroyed)) {
+            this._order = undefined;
+            return;
+        }
+        this._order = value;
+        this.observer.sortByOrder();
+    }
+    /**
+     * Subscribes an observer to the observable, allowing it to receive updates.
+     *
+     * @param {IListener<T> | ISetObservableValue} observer - The observer that will receive updates. It can be either a listener function or a setter for the observable value.
+     * @param {IErrorCallback} [errorHandler] - An optional error callback that will be invoked if an error occurs during the subscription process.
+     * @return {IOrderedSubscriptionLike} The current subscription instance for chaining purposes.
+     */
+    subscribe(observer, errorHandler) {
+        super.subscribe(observer, errorHandler);
+        return this;
+    }
+    /**
+     * Sets the subscription to be invoked only once. After the subscription
+     * is called for the first time, it will be automatically removed.
+     *
+     * @return {IOrderedSubscribe<T>} The subscription instance configured to execute only once.
+     */
+    setOnce() {
+        return super.setOnce();
+    }
+}
+exports.OrderedSubscribeObject = OrderedSubscribeObject;

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

@@ -0,0 +1,108 @@
+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/src/Libraries/Observables/Pipe.js

@@ -0,0 +1,161 @@
+"use strict";
+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 };
+    push(callback) {
+        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;
+            if (condition(data.payload))
+                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;
+        for (let i = 0; i < conditions.length; i++)
+            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;
+        const len = chain.length;
+        for (let i = 0; i < len; i++) {
+            data.isUnsubscribe = false;
+            data.isAvailable = false;
+            chain[i](data);
+            if (data.isUnsubscribe)
+                return this.unsubscribe();
+            if (!data.isAvailable)
+                return;
+            if (data.isBreak)
+                break;
+        }
+        return listener(data.payload);
+    }
+}
+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);
+    }
+}
+exports.PipeSwitchCase = PipeSwitchCase;

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

@@ -0,0 +1,83 @@
+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);
+}