evg_observable 2.15.1 → 2.15.3

package/src/outLib/Observable.d.ts

@@ -1,27 +1,6 @@
 import { IAddFilter, IErrorCallback, IFilterSetup, IObserver, ISetup, IStream, ISubscribeGroup, ISubscribeObject, ISubscriptionLike } from "./Types";
 import { SubscribeObject } from "./SubscribeObject";
 import { FilterCollection } from "./FilterCollection";
-/**
- * Observable is a generic class that represents an entity capable of emitting values
- * over time to subscribers. It provides mechanisms for managing subscribers and controlling
- * the flow of emitted data through filters and utility functions.
- *
- * @template T The type of the data managed by the Observable.
- *
- * Implements:
- * - IObserver<T>: For observing value changes.
- * - IStream<T>: For emitting streams of values.
- * - IAddFilter<T>: For adding and managing filters in the value processing.
- *
- * The Observable class provides the following key features:
- *
- * - Allows subscribers to listen for emitted values.
- * - Provides methods for enabling/disabling value emissions.
- * - Supports applying filters to process or validate values before emission.
- * - Allows streaming multiple values sequentially.
- * - Supports safe termination of resources through unsubscription and destruction.
- * - Handles asynchronous cleanup when active operations are in progress.
- */
 export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilter<T> {
     protected subs: ISubscribeObject<T>[];
     protected enabled: boolean;
@@ -31,130 +10,21 @@ export declare class Observable<T> implements IObserver<T>, IStream<T>, IAddFilt
     protected filters: FilterCollection<T>;
     protected _value: T;
     constructor(value: T);
-    /**
-     * Adds an error handler filter to the current filter setup.
-     *
-     * @param {IErrorCallback} [errorHandler] - An optional error handler callback to handle errors in the filter.
-     * @return {IFilterSetup<T>} The updated filter setup object with the specified error handler added.
-     */
     addFilter(errorHandler?: IErrorCallback): IFilterSetup<T>;
-    /**
-     * Disables the current instance or functionality associated with this method.
-     * Updates the internal state to reflect that it is no longer active or enabled.
-     *
-     * @return {void} This method does not return a value.
-     */
     disable(): void;
-    /**
-     * Enables the current feature or functionality by setting its state to active.
-     * Updates the internal state to indicate that it is enabled.
-     *
-     * @return {void} No return value.
-     */
     enable(): void;
-    /**
-     * Indicates whether the current object or feature is enabled.
-     *
-     * @return {boolean} Returns true if enabled, otherwise false.
-     */
     get isEnable(): boolean;
-    /**
-     * Processes the given value and sends it to all subscribers, respecting the enabled status, filters, and processing state.
-     *
-     * @param {T} value - The value to be processed and passed to subscribers.
-     * @return {void} This method does not return a value.
-     */
     next(value: T): void;
-    /**
-     * Processes an array of values and triggers the next method for each value if the stream
-     * is not killed or disabled.
-     *
-     * @param {T[]} values - An array of values to be processed by the stream.
-     * @return {void} This method does not return a value.
-     */
     stream(values: T[]): void;
-    /**
-     * Clears all items in the `trash` array by unsubscribing each item and resetting the array length to zero.
-     *
-     * @return {void} No return value.
-     */
     private clearTrash;
-    /**
-     * Unsubscribes the provided listener by removing it from the subscribers' list
-     * or marking it for cleanup if the process is currently active.
-     *
-     * @param {ISubscriptionLike} listener - The subscription listener to be unsubscribed.
-     * @return {void} No return value.
-     */
     unSubscribe(listener: ISubscriptionLike): void;
-    /**
-     * Cleans up resources and terminates any ongoing processes or subscriptions associated with the instance.
-     *
-     * Sets the internal state to indicate it has been destroyed. If a process is associated, waits until the process is no longer active
-     * before clearing internal data and subscriptions.
-     *
-     * @return {void} Does not return any value.
-     */
     destroy(): void;
-    /**
-     * Unsubscribes from all active subscriptions by clearing the subscriptions list.
-     * Prevents further operations if the instance has already been marked as killed.
-     * Safe to call during next() - uses deferred cleanup mechanism.
-     *
-     * @return {void} Does not return a value.
-     */
     unsubscribeAll(): void;
-    /**
-     * Retrieves the current value if the instance is active.
-     * If the instance is marked as killed, undefined is returned.
-     *
-     * @return {T | undefined} The current value or undefined if the instance is killed.
-     */
     getValue(): T | undefined;
-    /**
-     * Calculates and returns the size based on the current state.
-     *
-     * @return {number} The size, which is the number of subscriptions if not killed; otherwise, 0.
-     */
     size(): number;
-    /**
-     * Subscribes an observer to this instance, monitoring its changes and handling errors if any.
-     *
-     * @param observer The observer object that implements the ISubscribeGroup interface which will be subscribed.
-     * @param errorHandler Optional callback function to handle errors encountered during the subscription process.
-     * @return An object implementing the ISubscriptionLike interface that represents the subscription,
-     *         or undefined if the subscription is not successful.
-     */
     subscribe(observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): ISubscriptionLike | undefined;
-    /**
-     * Adds an observer to the subscribe object and associates it with a potential error handler.
-     * The subscribe object is added to the list of subscriptions for tracking purposes.
-     *
-     * @param {SubscribeObject<T>} subscribeObject - The object that manages the subscription to observers.
-     * @param {ISubscribeGroup<T>} observer - The observer to be subscribed to the subscribe object.
-     * @param {IErrorCallback} [errorHandler] - Optional error handler callback to handle errors during subscription.
-     * @return {void} This method does not return a value.
-     */
     protected addObserver(subscribeObject: SubscribeObject<T>, observer: ISubscribeGroup<T>, errorHandler?: IErrorCallback): void;
-    /**
-     * Determines if the provided object is a valid listener.
-     *
-     * @param listener An instance of ISubscribeGroup of type T to validate as a listener.
-     * @return Returns true if the provided listener is valid and the object is not marked as killed; otherwise, returns false.
-     */
     protected isListener(listener: ISubscribeGroup<T>): boolean;
-    /**
-     * Handles the creation and management of a SubscribeObject if the current instance is active.
-     * It returns an `ISetup<T>` object to allow additional configurations or operations.
-     * If the instance is in a "killed" state, it will not proceed and returns undefined.
-     *
-     * @return {ISetup<T> | undefined} The created SubscribeObject wrapped in an ISetup<T> interface if the instance is active, otherwise undefined.
-     */
     pipe(): ISetup<T> | undefined;
-    /**
-     * Determines if the object has been destroyed.
-     *
-     * @return {boolean} True if the object is destroyed, false otherwise.
-     */
     get isDestroyed(): boolean;
 }

package/src/outLib/Observable.js

@@ -4,27 +4,6 @@ exports.Observable = void 0;
 const FunctionLibs_1 = require("./FunctionLibs");
 const SubscribeObject_1 = require("./SubscribeObject");
 const FilterCollection_1 = require("./FilterCollection");
-/**
- * Observable is a generic class that represents an entity capable of emitting values
- * over time to subscribers. It provides mechanisms for managing subscribers and controlling
- * the flow of emitted data through filters and utility functions.
- *
- * @template T The type of the data managed by the Observable.
- *
- * Implements:
- * - IObserver<T>: For observing value changes.
- * - IStream<T>: For emitting streams of values.
- * - IAddFilter<T>: For adding and managing filters in the value processing.
- *
- * The Observable class provides the following key features:
- *
- * - Allows subscribers to listen for emitted values.
- * - Provides methods for enabling/disabling value emissions.
- * - Supports applying filters to process or validate values before emission.
- * - Allows streaming multiple values sequentially.
- * - Supports safe termination of resources through unsubscription and destruction.
- * - Handles asynchronous cleanup when active operations are in progress.
- */
 class Observable {
     subs = [];
     enabled = true;
@@ -36,49 +15,20 @@ class Observable {
     constructor(value) {
         this._value = value;
     }
-    /**
-     * Adds an error handler filter to the current filter setup.
-     *
-     * @param {IErrorCallback} [errorHandler] - An optional error handler callback to handle errors in the filter.
-     * @return {IFilterSetup<T>} The updated filter setup object with the specified error handler added.
-     */
     addFilter(errorHandler) {
         if (errorHandler)
             this.filters.addErrorHandler(errorHandler);
         return this.filters;
     }
-    /**
-     * Disables the current instance or functionality associated with this method.
-     * Updates the internal state to reflect that it is no longer active or enabled.
-     *
-     * @return {void} This method does not return a value.
-     */
     disable() {
         this.enabled = false;
     }
-    /**
-     * Enables the current feature or functionality by setting its state to active.
-     * Updates the internal state to indicate that it is enabled.
-     *
-     * @return {void} No return value.
-     */
     enable() {
         this.enabled = true;
     }
-    /**
-     * Indicates whether the current object or feature is enabled.
-     *
-     * @return {boolean} Returns true if enabled, otherwise false.
-     */
     get isEnable() {
         return this.enabled;
     }
-    /**
-     * Processes the given value and sends it to all subscribers, respecting the enabled status, filters, and processing state.
-     *
-     * @param {T} value - The value to be processed and passed to subscribers.
-     * @return {void} This method does not return a value.
-     */
     next(value) {
         if (this.killed)
             return;
@@ -97,13 +47,6 @@ class Observable {
         this.process = false;
         this.trash.length && this.clearTrash();
     }
-    /**
-     * Processes an array of values and triggers the next method for each value if the stream
-     * is not killed or disabled.
-     *
-     * @param {T[]} values - An array of values to be processed by the stream.
-     * @return {void} This method does not return a value.
-     */
     stream(values) {
         if (this.killed)
             return;
@@ -112,24 +55,12 @@ class Observable {
         for (let i = 0; i < values.length; i++)
             this.next(values[i]);
     }
-    /**
-     * Clears all items in the `trash` array by unsubscribing each item and resetting the array length to zero.
-     *
-     * @return {void} No return value.
-     */
     clearTrash() {
         const length = this.trash.length;
         for (let i = 0; i < length; i++)
             this.unSubscribe(this.trash[i]);
         this.trash.length = 0;
     }
-    /**
-     * Unsubscribes the provided listener by removing it from the subscribers' list
-     * or marking it for cleanup if the process is currently active.
-     *
-     * @param {ISubscriptionLike} listener - The subscription listener to be unsubscribed.
-     * @return {void} No return value.
-     */
     unSubscribe(listener) {
         if (this.killed)
             return;
@@ -139,14 +70,6 @@ class Observable {
         }
         this.subs && !(0, FunctionLibs_1.quickDeleteFromArray)(this.subs, listener);
     }
-    /**
-     * Cleans up resources and terminates any ongoing processes or subscriptions associated with the instance.
-     *
-     * Sets the internal state to indicate it has been destroyed. If a process is associated, waits until the process is no longer active
-     * before clearing internal data and subscriptions.
-     *
-     * @return {void} Does not return any value.
-     */
     destroy() {
         if (this.killed)
             return;
@@ -161,18 +84,10 @@ class Observable {
             this.subs.length = 0;
         });
     }
-    /**
-     * Unsubscribes from all active subscriptions by clearing the subscriptions list.
-     * Prevents further operations if the instance has already been marked as killed.
-     * Safe to call during next() - uses deferred cleanup mechanism.
-     *
-     * @return {void} Does not return a value.
-     */
     unsubscribeAll() {
         if (this.killed)
             return;
         if (this.process) {
-            // Defer removal until next() completes
             const subs = this.subs;
             for (let i = 0; i < subs.length; i++)
                 this.trash.push(subs[i]);
@@ -180,35 +95,16 @@ class Observable {
         }
         this.subs.length = 0;
     }
-    /**
-     * Retrieves the current value if the instance is active.
-     * If the instance is marked as killed, undefined is returned.
-     *
-     * @return {T | undefined} The current value or undefined if the instance is killed.
-     */
     getValue() {
         if (this.killed)
             return undefined;
         return this._value;
     }
-    /**
-     * Calculates and returns the size based on the current state.
-     *
-     * @return {number} The size, which is the number of subscriptions if not killed; otherwise, 0.
-     */
     size() {
         if (this.killed)
             return 0;
         return this.subs.length;
     }
-    /**
-     * Subscribes an observer to this instance, monitoring its changes and handling errors if any.
-     *
-     * @param observer The observer object that implements the ISubscribeGroup interface which will be subscribed.
-     * @param errorHandler Optional callback function to handle errors encountered during the subscription process.
-     * @return An object implementing the ISubscriptionLike interface that represents the subscription,
-     *         or undefined if the subscription is not successful.
-     */
     subscribe(observer, errorHandler) {
         if (this.killed)
             return undefined;
@@ -218,37 +114,15 @@ class Observable {
         this.addObserver(subscribeObject, observer, errorHandler);
         return subscribeObject;
     }
-    /**
-     * Adds an observer to the subscribe object and associates it with a potential error handler.
-     * The subscribe object is added to the list of subscriptions for tracking purposes.
-     *
-     * @param {SubscribeObject<T>} subscribeObject - The object that manages the subscription to observers.
-     * @param {ISubscribeGroup<T>} observer - The observer to be subscribed to the subscribe object.
-     * @param {IErrorCallback} [errorHandler] - Optional error handler callback to handle errors during subscription.
-     * @return {void} This method does not return a value.
-     */
     addObserver(subscribeObject, observer, errorHandler) {
         subscribeObject.subscribe(observer, errorHandler);
         this.subs.push(subscribeObject);
     }
-    /**
-     * Determines if the provided object is a valid listener.
-     *
-     * @param listener An instance of ISubscribeGroup of type T to validate as a listener.
-     * @return Returns true if the provided listener is valid and the object is not marked as killed; otherwise, returns false.
-     */
     isListener(listener) {
         if (this.killed)
             return false;
         return !!listener;
     }
-    /**
-     * Handles the creation and management of a SubscribeObject if the current instance is active.
-     * It returns an `ISetup<T>` object to allow additional configurations or operations.
-     * If the instance is in a "killed" state, it will not proceed and returns undefined.
-     *
-     * @return {ISetup<T> | undefined} The created SubscribeObject wrapped in an ISetup<T> interface if the instance is active, otherwise undefined.
-     */
     pipe() {
         if (this.killed)
             return undefined;
@@ -256,11 +130,6 @@ class Observable {
         this.subs.push(subscribeObject);
         return subscribeObject;
     }
-    /**
-     * Determines if the object has been destroyed.
-     *
-     * @return {boolean} True if the object is destroyed, false otherwise.
-     */
     get isDestroyed() {
         return this.killed;
     }

package/src/outLib/OrderedObservable.d.ts

@@ -1,70 +1,11 @@
 import { Observable } from "./Observable";
 import { IErrorCallback, IOrdered, IOrderedSetup, IOrderedSubscriptionLike, ISubscribeGroup, ISubscriptionLike } from "./Types";
-/**
- * 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>
- */
 export declare class OrderedObservable<T> extends Observable<T> implements IOrdered<T> {
-    /**
-     * 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.
-     */
     private sortDirection;
-    /**
-     * Sets the sorting order to ascending and applies the sorting.
-     *
-     * @return {boolean} Returns true if the sorting operation is successful, otherwise false.
-     */
     setAscendingSort(): boolean;
-    /**
-     * 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(): boolean;
-    /**
-     * 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(): boolean;
-    /**
-     * 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: ISubscribeGroup<T>, errorHandler?: IErrorCallback): IOrderedSubscriptionLike | undefined;
-    /**
-     * 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(): IOrderedSetup<T> | undefined;
-    /**
-     * 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: ISubscriptionLike): void;
 }

package/src/outLib/OrderedObservable.js

@@ -4,65 +4,22 @@ 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;
@@ -70,13 +27,6 @@ class OrderedObservable extends Observable_1.Observable {
         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;
@@ -84,15 +34,6 @@ class OrderedObservable extends Observable_1.Observable {
         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;

package/src/outLib/OrderedSubscribeObject.d.ts

@@ -1,53 +1,10 @@
 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/OrderedSubscribeObject.js

@@ -2,43 +2,13 @@
 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)) {
@@ -48,23 +18,10 @@ class OrderedSubscribeObject extends SubscribeObject_1.SubscribeObject {
         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();
     }