@fluixi/reactive 1.0.0-alpha.53

package/dist/lib/observable/observable.js

@@ -0,0 +1,339 @@
+// import { Subscription, toPromise } from "@fluixi/reactive";
+// import { toPromise } from "./operators/index.js";
+import { Subscription } from "./subscription.js";
+/**
+ * A subscriber is both an Observer and a Subscription.
+ * This is the object that gets passed to the Observable's subscribe function.
+ *
+ * @template T - The type of values being observed
+ * @class Subscriber
+ * @extends {Subscription}
+ * @implements {Observer<T>}
+ */
+export class Subscriber extends Subscription {
+    /** @private */ isStopped = false;
+    /** @private */ destination;
+    /**
+     * Creates a new Subscriber.
+     *
+     * @param {Partial<Observer<T>>|((value: T) => void)} [destinationOrNext] -
+     *        Either an observer object or a next handler function
+     * @param {(error: any) => void} [error] - Error handler (if first param is next function)
+     * @param {() => void} [complete] - Complete handler (if first param is next function)
+     */
+    constructor(destinationOrNext, error, complete) {
+        super();
+        // Normalize arguments to observer object
+        let observer;
+        if (!destinationOrNext) {
+            observer = {};
+        }
+        else if (typeof destinationOrNext === 'object') {
+            observer = destinationOrNext;
+        }
+        else {
+            observer = {
+                next: destinationOrNext,
+                error: error,
+                complete: complete
+            };
+        }
+        this.destination = observer;
+    }
+    /**
+     * Sends the next value to the observer.
+     *
+     * @param {T} value - The value to send
+     * @returns {void}
+     */
+    next(value) {
+        if (!this.isStopped && this.destination.next) {
+            try {
+                this.destination.next(value);
+            }
+            catch (error) {
+                this.error(error);
+            }
+        }
+    }
+    /**
+     * Sends an error notification to the observer.
+     *
+     * @param {any} err - The error to send
+     * @returns {void}
+     */
+    error(err) {
+        if (!this.isStopped) {
+            this.isStopped = true;
+            if (this.destination.error) {
+                try {
+                    this.destination.error(err);
+                }
+                catch (error) {
+                    // Rethrow if error handler throws
+                    throw error;
+                }
+            }
+            else {
+                throw err;
+            }
+            this.unsubscribe();
+        }
+    }
+    /**
+     * Sends a complete notification to the observer.
+     *
+     * @returns {void}
+     */
+    complete() {
+        if (!this.isStopped) {
+            this.isStopped = true;
+            if (this.destination.complete) {
+                try {
+                    this.destination.complete();
+                }
+                catch (error) {
+                    this.error(error);
+                    return;
+                }
+            }
+            this.unsubscribe();
+        }
+    }
+    /**
+     * Unsubscribes the subscriber.
+     *
+     * @returns {void}
+     */
+    unsubscribe() {
+        if (this.closed) {
+            return;
+        }
+        this.isStopped = true;
+        super.unsubscribe();
+    }
+}
+/**
+ * SafeSubscriber adds extra safety checks to prevent reentrant calls.
+ *
+ * @template T - The type of values being observed
+ * @class SafeSubscriber
+ * @extends {Subscriber<T>}
+ */
+export class SafeSubscriber extends Subscriber {
+    /** @private */ _isUnsubscribing = false;
+    /** @private */ _parentSubscriber = null;
+    constructor(observerOrNext, error, complete, parentSubscriber) {
+        super(observerOrNext, error, complete);
+        this._parentSubscriber = parentSubscriber || null;
+    }
+    next(value) {
+        if (!this.isStopped && !this._isUnsubscribing) {
+            // Use try-catch to ensure errors don't break the subscriber
+            try {
+                super.next(value);
+            }
+            catch (error) {
+                this.error(error);
+            }
+        }
+    }
+    error(err) {
+        if (!this.isStopped && !this._isUnsubscribing) {
+            this._isUnsubscribing = true;
+            try {
+                super.error(err);
+            }
+            finally {
+                this._isUnsubscribing = false;
+            }
+        }
+    }
+    complete() {
+        if (!this.isStopped && !this._isUnsubscribing) {
+            this._isUnsubscribing = true;
+            try {
+                super.complete();
+            }
+            finally {
+                this._isUnsubscribing = false;
+            }
+        }
+    }
+    unsubscribe() {
+        if (this.closed) {
+            return;
+        }
+        this._isUnsubscribing = true;
+        super.unsubscribe();
+        this._isUnsubscribing = false;
+    }
+}
+export function operate(destination) {
+    return new Subscriber(destination.next, destination.error, destination.complete);
+}
+/**
+ * A representation of any set of values over any amount of time.
+ * This is the most basic building block of RxJS.
+ *
+ * @template T - The type of values emitted by the Observable
+ * @class Observable
+ *
+ * @example
+ * // Create an Observable from scratch
+ * const observable = new Observable<string>(subscriber => {
+ *   subscriber.next('Hello');
+ *   subscriber.next('World');
+ *   subscriber.complete();
+ *
+ *   return () => console.log('Cleanup');
+ * });
+ *
+ * @example
+ * // Subscribe to an Observable
+ * const subscription = observable.subscribe({
+ *   next: value => console.log(value),
+ *   error: err => console.error(err),
+ *   complete: () => console.log('Done')
+ * });
+ *
+ * // Later, unsubscribe
+ * subscription.unsubscribe();
+ */
+// export class Observable<T> extends Subscription {
+//     constructor(
+//         private _subscribeFn: (observer: Observer<T>) => void | (() => void) | Subscription
+//       ) {
+//         super()
+//       }
+//       subscribe(observer: Partial<Observer<T>> | ((v: T) => void)): Subscription {
+//         const finalObserver: Observer<T> =
+//           typeof observer === "function"
+//             ? { next: observer, error: () => {}, complete: () => {} }
+//             : {
+//                 next: observer.next!,
+//                 error: observer.error,
+//                 complete: observer.complete
+//               } as Observer<T>;
+//         const subscription = new Subscription();
+//         const teardown = this._subscribeFn(finalObserver);
+//         if (typeof teardown === "function") {
+//           subscription.add(teardown);
+//         }
+//         return subscription;
+//       }
+//     /** Fully dynamic variadic pipe */
+//     pipe(): Observable<T>;
+//     pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
+//     pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
+//     pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
+//     pipe<A, B, C, D>(
+//         op1: OperatorFunction<T, A>,
+//         op2: OperatorFunction<A, B>,
+//         op3: OperatorFunction<B, C>,
+//         op4: OperatorFunction<C, D>
+//     ): Observable<D>;
+//     pipe<A, B, C, D, E>(
+//         op1: OperatorFunction<T, A>,
+//         op2: OperatorFunction<A, B>,
+//         op3: OperatorFunction<B, C>,
+//         op4: OperatorFunction<C, D>,
+//         op5: OperatorFunction<D, E>
+//     ): Observable<E>;
+//     // generic fallback for >5 operators (loses some inference but keeps runtime behavior)
+//     pipe(...ops: OperatorFunction<any, any>[]): Observable<any> {
+//         if (ops.length === 0) return this;
+//         return ops.reduce((prev, fn) => fn(prev), this as any);
+//     }
+// }
+export class Observable extends Subscription {
+    /**
+     * The function that is called when the Observable is subscribed to.
+     * This function is given a Subscriber to which new values can be `next`ed,
+     * or an `error` or `complete` notification can be sent.
+     *
+     * @private
+     * @type {function(Subscriber<T>): (void | (() => void) | Subscription)}
+     */
+    _subscribe;
+    /**
+     * Creates a new Observable.
+     *
+     * @param {function(Subscriber<T>): (void | (() => void) | Subscription)} subscribe -
+     *        The function that is called when the Observable is subscribed to
+     */
+    constructor(subscribe) {
+        super();
+        if (subscribe) {
+            this._subscribe = subscribe;
+        }
+        else {
+            throw new TypeError('Observable constructor requires a subscribe function');
+        }
+    }
+    subscribe(observerOrNext, error, complete) {
+        // Create subscriber
+        let subscriber;
+        if (observerOrNext instanceof Subscriber) {
+            subscriber = observerOrNext;
+        }
+        else {
+            subscriber = new SafeSubscriber(observerOrNext, error, complete);
+        }
+        // Add finalization logic
+        const { _subscribe } = this;
+        // Call the subscribe function
+        try {
+            const result = _subscribe.call(this, subscriber);
+            // Handle return value (could be a cleanup function or subscription)
+            if (result) {
+                if (typeof result === 'function') {
+                    subscriber.add(result);
+                }
+                else if (typeof result.unsubscribe === 'function') {
+                    subscriber.add(result);
+                }
+            }
+        }
+        catch (err) {
+            // If subscribe function throws, error the subscriber
+            subscriber.error(err);
+        }
+        return subscriber;
+    }
+    pipe(...operations) {
+        if (operations.length === 0) {
+            return this;
+        }
+        // Apply operators in sequence
+        return operations.reduce((prev, fn) => fn(prev), this);
+    }
+    /**
+     * Converts the Observable to a Promise.
+     * The Promise resolves with the last emitted value when the Observable completes,
+     * or rejects if the Observable errors.
+     *
+     * @returns {Promise<T | undefined>} A Promise that resolves with the last value
+     *
+     * @example
+     * // Convert Observable to Promise
+     * const value = await of(1, 2, 3).toPromise();
+     * console.log(value); // 3
+     *
+     * @example
+     * // Handle empty Observable
+     * const value = await EMPTY.toPromise();
+     * console.log(value); // undefined
+     */
+    toPromise() {
+        return new Promise((resolve, reject) => {
+            let lastValue;
+            this.subscribe({
+                next: value => lastValue = value,
+                error: reject,
+                complete: () => resolve(lastValue)
+            });
+        });
+    }
+}
+// Observable.prototype.toPromise = toPromise;

package/dist/lib/observable/observable.mjs

@@ -0,0 +1 @@
+import{isObject as l}from"@fluixi/utils/object";import{isFunction as a}from"@fluixi/utils/functions";var p=class o{constructor(e){this._closed=!1;this._parentOrParents=null;this._subscriptions=null;e&&(this._subscriptions=[e])}get closed(){return this._closed}unsubscribe(){if(this._closed)return;this._closed=!0;let{_parentOrParents:e,_subscriptions:r}=this;if(e instanceof o)e.remove(this);else if(e!==null)for(let t of e)t.remove(this);if(r){for(let t of r)if(a(t)&&!(t instanceof o))try{t()}catch(i){console.error("Error in unsubscribe function:",i)}else if(l(t)&&typeof t.unsubscribe=="function")try{t.unsubscribe()}catch(i){console.error("Error unsubscribing child:",i)}this._subscriptions=null}}add(e){if(!e||e===this)return this;if(e.closed)return this;let{_closed:r,_subscriptions:t}=this;if(r){if(a(e))try{e()}catch(i){console.error("Error in unsubscribe function:",i)}else if(e.unsubscribe)try{e.unsubscribe()}catch(i){console.error("Error unsubscribing:",i)}return this}return t||(this._subscriptions=[]),this._subscriptions.push(e),e instanceof o&&e._addParent(this),this}remove(e){let{_subscriptions:r}=this;if(!r)return;let t=r.indexOf(e);t!==-1&&(r.splice(t,1),e._removeParent(this))}_addParent(e){let{_parentOrParents:r}=this;r?Array.isArray(r)?r.push(e):this._parentOrParents=[r,e]:this._parentOrParents=e}_removeParent(e){let{_parentOrParents:r}=this;if(r===e)this._parentOrParents=null;else if(Array.isArray(r)){let t=r.indexOf(e);t!==-1&&(r.splice(t,1),r.length===1&&(this._parentOrParents=r[0]))}}};var u=class extends p{constructor(r,t,i){super();this.isStopped=!1;let n;r?typeof r=="object"?n=r:n={next:r,error:t,complete:i}:n={},this.destination=n}next(r){if(!this.isStopped&&this.destination.next)try{this.destination.next(r)}catch(t){this.error(t)}}error(r){if(!this.isStopped){if(this.isStopped=!0,this.destination.error)try{this.destination.error(r)}catch(t){throw t}else throw r;this.unsubscribe()}}complete(){if(!this.isStopped){if(this.isStopped=!0,this.destination.complete)try{this.destination.complete()}catch(r){this.error(r);return}this.unsubscribe()}}unsubscribe(){this.closed||(this.isStopped=!0,super.unsubscribe())}},c=class extends u{constructor(r,t,i,n){super(r,t,i);this._isUnsubscribing=!1;this._parentSubscriber=null;this._parentSubscriber=n||null}next(r){if(!this.isStopped&&!this._isUnsubscribing)try{super.next(r)}catch(t){this.error(t)}}error(r){if(!this.isStopped&&!this._isUnsubscribing){this._isUnsubscribing=!0;try{super.error(r)}finally{this._isUnsubscribing=!1}}}complete(){if(!this.isStopped&&!this._isUnsubscribing){this._isUnsubscribing=!0;try{super.complete()}finally{this._isUnsubscribing=!1}}}unsubscribe(){this.closed||(this._isUnsubscribing=!0,super.unsubscribe(),this._isUnsubscribing=!1)}};function f(o){return new u(o.next,o.error,o.complete)}var b=class extends p{constructor(e){if(super(),e)this._subscribe=e;else throw new TypeError("Observable constructor requires a subscribe function")}subscribe(e,r,t){let i;e instanceof u?i=e:i=new c(e,r,t);let{_subscribe:n}=this;try{let s=n.call(this,i);s&&(typeof s=="function"||typeof s.unsubscribe=="function")&&i.add(s)}catch(s){i.error(s)}return i}pipe(...e){return e.length===0?this:e.reduce((r,t)=>t(r),this)}toPromise(){return new Promise((e,r)=>{let t;this.subscribe({next:i=>t=i,error:r,complete:()=>e(t)})})}};export{b as Observable,c as SafeSubscriber,u as Subscriber,f as operate};

package/dist/lib/observable/subscription.cjs

@@ -0,0 +1 @@
+"use strict";var n=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var f=(t,r)=>{for(var s in r)n(t,s,{get:r[s],enumerable:!0})},h=(t,r,s,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let e of l(r))!b.call(t,e)&&e!==s&&n(t,e,{get:()=>r[e],enumerable:!(i=a(r,e))||i.enumerable});return t};var p=t=>h(n({},"__esModule",{value:!0}),t);var d={};f(d,{Subscription:()=>c});module.exports=p(d);var u=require("@fluixi/utils/object"),o=require("@fluixi/utils/functions"),c=class t{constructor(r){this._closed=!1;this._parentOrParents=null;this._subscriptions=null;r&&(this._subscriptions=[r])}get closed(){return this._closed}unsubscribe(){if(this._closed)return;this._closed=!0;let{_parentOrParents:r,_subscriptions:s}=this;if(r instanceof t)r.remove(this);else if(r!==null)for(let i of r)i.remove(this);if(s){for(let i of s)if((0,o.isFunction)(i)&&!(i instanceof t))try{i()}catch(e){console.error("Error in unsubscribe function:",e)}else if((0,u.isObject)(i)&&typeof i.unsubscribe=="function")try{i.unsubscribe()}catch(e){console.error("Error unsubscribing child:",e)}this._subscriptions=null}}add(r){if(!r||r===this)return this;if(r.closed)return this;let{_closed:s,_subscriptions:i}=this;if(s){if((0,o.isFunction)(r))try{r()}catch(e){console.error("Error in unsubscribe function:",e)}else if(r.unsubscribe)try{r.unsubscribe()}catch(e){console.error("Error unsubscribing:",e)}return this}return i||(this._subscriptions=[]),this._subscriptions.push(r),r instanceof t&&r._addParent(this),this}remove(r){let{_subscriptions:s}=this;if(!s)return;let i=s.indexOf(r);i!==-1&&(s.splice(i,1),r._removeParent(this))}_addParent(r){let{_parentOrParents:s}=this;s?Array.isArray(s)?s.push(r):this._parentOrParents=[s,r]:this._parentOrParents=r}_removeParent(r){let{_parentOrParents:s}=this;if(s===r)this._parentOrParents=null;else if(Array.isArray(s)){let i=s.indexOf(r);i!==-1&&(s.splice(i,1),s.length===1&&(this._parentOrParents=s[0]))}}};

package/dist/lib/observable/subscription.d.ts

@@ -0,0 +1,70 @@
+import { SubscriptionLike, Unsubscribable } from './types.js';
+/**
+ * Represents a disposable resource, such as the execution of an Observable.
+ * This is the primary mechanism for cleaning up Observable executions.
+ *
+ * @class Subscription
+ * @implements {SubscriptionLike}
+ *
+ * @example
+ * // Basic usage
+ * const subscription = new Subscription();
+ * subscription.add(() => console.log('Cleanup'));
+ * subscription.unsubscribe(); // Logs: Cleanup
+ *
+ * @example
+ * // Adding child subscriptions
+ * const parent = new Subscription();
+ * const child = new Subscription();
+ * parent.add(child);
+ *
+ * // Unsubscribing parent also unsubscribes child
+ * parent.unsubscribe();
+ * console.log(child.closed); // true
+ */
+export declare class Subscription implements SubscriptionLike {
+    /** @private */ private _closed;
+    /** @private */ private _parentOrParents;
+    /** @private */ private _subscriptions;
+    /**
+     * Creates a new Subscription.
+     *
+     * @param {Unsubscribable} [unsubscribe] - Optional cleanup function to call on unsubscribe
+     */
+    constructor(unsubscribe?: Unsubscribable);
+    /**
+     * Whether the subscription is closed.
+     *
+     * @returns {boolean} True if the subscription is closed
+     */
+    get closed(): boolean;
+    /**
+     * Disposes the resources held by the subscription.
+     * May be called multiple times (idempotent).
+     *
+     * @returns {void}
+     */
+    unsubscribe(): void;
+    /**
+     * Adds a child subscription or cleanup function to this subscription.
+     * When this subscription is unsubscribed, all added subscriptions/functions will be unsubscribed/called.
+     *
+     * @param {SubscriptionLike|Unsubscribable} subscription - Subscription or cleanup function to add
+     * @returns {Subscription} This subscription for chaining
+     *
+     * @throws {TypeError} If the argument is not a subscription-like object or function
+     */
+    add(subscription: SubscriptionLike | Unsubscribable): this;
+    /**
+     * Removes a child subscription from this subscription.
+     *
+     * @param {Subscription} subscription - Subscription to remove
+     * @returns {void}
+     */
+    remove(subscription: Subscription): void;
+    /** @private */
+    private _addParent;
+    /** @private */
+    private _removeParent;
+}
+//# sourceMappingURL=subscription.d.ts.map

package/dist/lib/observable/subscription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../src/lib/observable/subscription.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAiB,cAAc,EAAE,MAAM,YAAY,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,YAAa,YAAW,gBAAgB;IACnD,eAAe,CAAC,OAAO,CAAC,OAAO,CAAS;IACxC,eAAe,CAAC,OAAO,CAAC,gBAAgB,CAGxB;IAChB,eAAe,CAAC,OAAO,CAAC,cAAc,CAEtB;IAEhB;;;;OAIG;gBACS,WAAW,CAAC,EAAE,cAAc;IAMxC;;;;OAIG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;;;OAKG;IACH,WAAW,IAAI,IAAI;IAuCnB;;;;;;;;OAQG;IACH,GAAG,CAAC,YAAY,EAAE,gBAAgB,GAAG,cAAc,GAAG,IAAI;IA8C1D;;;;;OAKG;IACH,MAAM,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;IAexC,eAAe;IACf,OAAO,CAAC,UAAU;IAWlB,eAAe;IACf,OAAO,CAAC,aAAa;CActB"}

package/dist/lib/observable/subscription.js

@@ -0,0 +1,190 @@
+import { isObject } from '@fluixi/utils/object';
+import { isFunction } from '@fluixi/utils/functions';
+/**
+ * Represents a disposable resource, such as the execution of an Observable.
+ * This is the primary mechanism for cleaning up Observable executions.
+ *
+ * @class Subscription
+ * @implements {SubscriptionLike}
+ *
+ * @example
+ * // Basic usage
+ * const subscription = new Subscription();
+ * subscription.add(() => console.log('Cleanup'));
+ * subscription.unsubscribe(); // Logs: Cleanup
+ *
+ * @example
+ * // Adding child subscriptions
+ * const parent = new Subscription();
+ * const child = new Subscription();
+ * parent.add(child);
+ *
+ * // Unsubscribing parent also unsubscribes child
+ * parent.unsubscribe();
+ * console.log(child.closed); // true
+ */
+export class Subscription {
+    /** @private */ _closed = false;
+    /** @private */ _parentOrParents = null;
+    /** @private */ _subscriptions = null;
+    /**
+     * Creates a new Subscription.
+     *
+     * @param {Unsubscribable} [unsubscribe] - Optional cleanup function to call on unsubscribe
+     */
+    constructor(unsubscribe) {
+        if (unsubscribe) {
+            this._subscriptions = [unsubscribe];
+        }
+    }
+    /**
+     * Whether the subscription is closed.
+     *
+     * @returns {boolean} True if the subscription is closed
+     */
+    get closed() {
+        return this._closed;
+    }
+    /**
+     * Disposes the resources held by the subscription.
+     * May be called multiple times (idempotent).
+     *
+     * @returns {void}
+     */
+    unsubscribe() {
+        if (this._closed) {
+            return;
+        }
+        this._closed = true;
+        const { _parentOrParents, _subscriptions } = this;
+        // Remove from parent
+        if (_parentOrParents instanceof Subscription) {
+            _parentOrParents.remove(this);
+        }
+        else if (_parentOrParents !== null) {
+            for (const parent of _parentOrParents) {
+                parent.remove(this);
+            }
+        }
+        // Unsubscribe all child subscriptions
+        if (_subscriptions) {
+            for (const sub of _subscriptions) {
+                if (isFunction(sub) && !(sub instanceof Subscription)) {
+                    try {
+                        sub();
+                    }
+                    catch (error) {
+                        // Don't let errors in cleanup functions break unsubscribe chain
+                        console.error('Error in unsubscribe function:', error);
+                    }
+                }
+                else if (isObject(sub) && typeof sub.unsubscribe === 'function') {
+                    try {
+                        sub.unsubscribe();
+                    }
+                    catch (error) {
+                        console.error('Error unsubscribing child:', error);
+                    }
+                }
+            }
+            this._subscriptions = null;
+        }
+    }
+    /**
+     * Adds a child subscription or cleanup function to this subscription.
+     * When this subscription is unsubscribed, all added subscriptions/functions will be unsubscribed/called.
+     *
+     * @param {SubscriptionLike|Unsubscribable} subscription - Subscription or cleanup function to add
+     * @returns {Subscription} This subscription for chaining
+     *
+     * @throws {TypeError} If the argument is not a subscription-like object or function
+     */
+    add(subscription) {
+        if (!subscription || subscription === this) {
+            return this;
+        }
+        // If subscription is already closed, do nothing
+        if (subscription.closed) {
+            return this;
+        }
+        let { _closed, _subscriptions } = this;
+        // If this subscription is already closed, unsubscribe the added subscription immediately
+        if (_closed) {
+            if (isFunction(subscription)) {
+                try {
+                    subscription();
+                }
+                catch (error) {
+                    console.error('Error in unsubscribe function:', error);
+                }
+            }
+            else if (subscription.unsubscribe) {
+                try {
+                    subscription.unsubscribe();
+                }
+                catch (error) {
+                    console.error('Error unsubscribing:', error);
+                }
+            }
+            return this;
+        }
+        // Initialize subscriptions array if needed
+        if (!_subscriptions) {
+            this._subscriptions = [];
+        }
+        // Add to subscriptions array
+        this._subscriptions.push(subscription);
+        // Set parent reference
+        if (subscription instanceof Subscription) {
+            subscription._addParent(this);
+        }
+        return this;
+    }
+    /**
+     * Removes a child subscription from this subscription.
+     *
+     * @param {Subscription} subscription - Subscription to remove
+     * @returns {void}
+     */
+    remove(subscription) {
+        const { _subscriptions } = this;
+        if (!_subscriptions) {
+            return;
+        }
+        const index = _subscriptions.indexOf(subscription);
+        if (index !== -1) {
+            _subscriptions.splice(index, 1);
+            // Remove parent reference
+            subscription._removeParent(this);
+        }
+    }
+    /** @private */
+    _addParent(parent) {
+        const { _parentOrParents } = this;
+        if (!_parentOrParents) {
+            this._parentOrParents = parent;
+        }
+        else if (Array.isArray(_parentOrParents)) {
+            _parentOrParents.push(parent);
+        }
+        else {
+            this._parentOrParents = [_parentOrParents, parent];
+        }
+    }
+    /** @private */
+    _removeParent(parent) {
+        const { _parentOrParents } = this;
+        if (_parentOrParents === parent) {
+            this._parentOrParents = null;
+        }
+        else if (Array.isArray(_parentOrParents)) {
+            const index = _parentOrParents.indexOf(parent);
+            if (index !== -1) {
+                _parentOrParents.splice(index, 1);
+                if (_parentOrParents.length === 1) {
+                    this._parentOrParents = _parentOrParents[0];
+                }
+            }
+        }
+    }
+}

package/dist/lib/observable/subscription.mjs

@@ -0,0 +1 @@
+import{isObject as c}from"@fluixi/utils/object";import{isFunction as n}from"@fluixi/utils/functions";var o=class t{constructor(r){this._closed=!1;this._parentOrParents=null;this._subscriptions=null;r&&(this._subscriptions=[r])}get closed(){return this._closed}unsubscribe(){if(this._closed)return;this._closed=!0;let{_parentOrParents:r,_subscriptions:s}=this;if(r instanceof t)r.remove(this);else if(r!==null)for(let i of r)i.remove(this);if(s){for(let i of s)if(n(i)&&!(i instanceof t))try{i()}catch(e){console.error("Error in unsubscribe function:",e)}else if(c(i)&&typeof i.unsubscribe=="function")try{i.unsubscribe()}catch(e){console.error("Error unsubscribing child:",e)}this._subscriptions=null}}add(r){if(!r||r===this)return this;if(r.closed)return this;let{_closed:s,_subscriptions:i}=this;if(s){if(n(r))try{r()}catch(e){console.error("Error in unsubscribe function:",e)}else if(r.unsubscribe)try{r.unsubscribe()}catch(e){console.error("Error unsubscribing:",e)}return this}return i||(this._subscriptions=[]),this._subscriptions.push(r),r instanceof t&&r._addParent(this),this}remove(r){let{_subscriptions:s}=this;if(!s)return;let i=s.indexOf(r);i!==-1&&(s.splice(i,1),r._removeParent(this))}_addParent(r){let{_parentOrParents:s}=this;s?Array.isArray(s)?s.push(r):this._parentOrParents=[s,r]:this._parentOrParents=r}_removeParent(r){let{_parentOrParents:s}=this;if(s===r)this._parentOrParents=null;else if(Array.isArray(s)){let i=s.indexOf(r);i!==-1&&(s.splice(i,1),s.length===1&&(this._parentOrParents=s[0]))}}};export{o as Subscription};

package/dist/lib/observable/types.cjs

@@ -0,0 +1 @@
+"use strict";var t=Object.defineProperty;var v=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var c=(r,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of p(e))!b.call(r,o)&&o!==n&&t(r,o,{get:()=>e[o],enumerable:!(i=v(e,o))||i.enumerable});return r};var d=r=>c(t({},"__esModule",{value:!0}),r);var a={};module.exports=d(a);

package/dist/lib/observable/types.d.ts

@@ -0,0 +1,44 @@
+import { Subscription } from "./subscription.js";
+/**
+ * Type representing a function that can be called to unsubscribe from an Observable.
+ *
+ * @typedef {function(): void} Unsubscribable
+ */
+export type Unsubscribable = () => void;
+/**
+ * Type representing any object that can be unsubscribed.
+ *
+ * @interface SubscriptionLike
+ * @property {boolean} closed - Whether the subscription is closed
+ * @property {function(): void} unsubscribe - Function to unsubscribe
+ */
+export interface SubscriptionLike {
+    closed: boolean;
+    unsubscribe(): void;
+}
+export type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
+/**
+ * Next observer in a chain
+ */
+export interface NextObserver<T> {
+    next: (value: T) => void;
+    error?: (error: any) => void;
+    complete?: () => void;
+}
+/**
+ * Error observer in a chain
+ */
+export interface ErrorObserver<T> {
+    next?: (value: T) => void;
+    error: (error: any) => void;
+    complete?: () => void;
+}
+/**
+ * Completion observer in a chain
+ */
+export interface CompletionObserver<T> {
+    next?: (value: T) => void;
+    error?: (error: any) => void;
+    complete: () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/observable/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/observable/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,IAAI,CAAC;AAExC;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,IAAI,IAAI,CAAC;CACvB;AAGD,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,cAAc,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;AAG9E;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC;IAC7B,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACzB,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC;IACnC,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC1B,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAC;IAC7B,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB"}

package/dist/lib/observable/types.js

@@ -0,0 +1 @@
+export {};