@fluixi/reactive 1.0.0-alpha.100

package/dist/lib/observable/observable.js

@@ -0,0 +1,268 @@
+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.
+ *
+ * @class Subscriber
+ * @extends {Subscription}
+ * @implements {Observer<T>}
+ */
+export class Subscriber extends Subscription {
+    /** @private */ isStopped = false;
+    /** @private */ destination;
+    /**
+     * Creates a new Subscriber.
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    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.
+     */
+    unsubscribe() {
+        if (this.closed) {
+            return;
+        }
+        this.isStopped = true;
+        super.unsubscribe();
+    }
+}
+/**
+ * SafeSubscriber adds extra safety checks to prevent reentrant calls.
+ *
+ * @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.
+ *
+ * @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 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.
+     */
+    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.
+     *
+     * @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,361 @@
+// src/lib/predicates.ts
+function isFunction(value) {
+  return typeof value === "function" && !/^class\s/.test(Function.prototype.toString.call(value));
+}
+function isObject(value) {
+  if (value == null) return false;
+  if (Array.isArray(value)) return false;
+  if (typeof value === "function") return false;
+  if (value instanceof Date) return false;
+  if (value instanceof RegExp) return false;
+  if (value instanceof Map) return false;
+  if (value instanceof Set) return false;
+  if (value instanceof Error) return false;
+  return typeof value === "object";
+}
+
+// src/lib/observable/subscription.ts
+var Subscription = class _Subscription {
+  /**
+   * Creates a new Subscription.
+   */
+  constructor(unsubscribe) {
+    /** @private */
+    this._closed = false;
+    /** @private */
+    this._parentOrParents = null;
+    /** @private */
+    this._subscriptions = null;
+    if (unsubscribe) {
+      this._subscriptions = [unsubscribe];
+    }
+  }
+  /**
+   * Whether the subscription is closed.
+   */
+  get closed() {
+    return this._closed;
+  }
+  /**
+   * Disposes the resources held by the subscription.
+   * May be called multiple times (idempotent).
+   */
+  unsubscribe() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    const { _parentOrParents, _subscriptions } = this;
+    if (_parentOrParents instanceof _Subscription) {
+      _parentOrParents.remove(this);
+    } else if (_parentOrParents !== null) {
+      for (const parent of _parentOrParents) {
+        parent.remove(this);
+      }
+    }
+    if (_subscriptions) {
+      for (const sub of _subscriptions) {
+        if (isFunction(sub) && !(sub instanceof _Subscription)) {
+          try {
+            sub();
+          } catch (error) {
+            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.
+   *
+   * @throws {TypeError} If the argument is not a subscription-like object or function
+   */
+  add(subscription) {
+    if (!subscription || subscription === this) {
+      return this;
+    }
+    if (subscription.closed) {
+      return this;
+    }
+    let { _closed, _subscriptions } = this;
+    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;
+    }
+    if (!_subscriptions) {
+      this._subscriptions = [];
+    }
+    this._subscriptions.push(subscription);
+    if (subscription instanceof _Subscription) {
+      subscription._addParent(this);
+    }
+    return this;
+  }
+  /**
+   * Removes a child subscription from this subscription.
+   */
+  remove(subscription) {
+    const { _subscriptions } = this;
+    if (!_subscriptions) {
+      return;
+    }
+    const index = _subscriptions.indexOf(subscription);
+    if (index !== -1) {
+      _subscriptions.splice(index, 1);
+      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];
+        }
+      }
+    }
+  }
+};
+
+// src/lib/observable/observable.ts
+var Subscriber = class extends Subscription {
+  /**
+   * Creates a new Subscriber.
+   */
+  constructor(destinationOrNext, error, complete) {
+    super();
+    /** @private */
+    this.isStopped = false;
+    let observer;
+    if (!destinationOrNext) {
+      observer = {};
+    } else if (typeof destinationOrNext === "object") {
+      observer = destinationOrNext;
+    } else {
+      observer = {
+        next: destinationOrNext,
+        error,
+        complete
+      };
+    }
+    this.destination = observer;
+  }
+  /**
+   * Sends the next value to the observer.
+   */
+  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.
+   */
+  error(err) {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      if (this.destination.error) {
+        try {
+          this.destination.error(err);
+        } catch (error) {
+          throw error;
+        }
+      } else {
+        throw err;
+      }
+      this.unsubscribe();
+    }
+  }
+  /**
+   * Sends a complete notification to the observer.
+   */
+  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.
+   */
+  unsubscribe() {
+    if (this.closed) {
+      return;
+    }
+    this.isStopped = true;
+    super.unsubscribe();
+  }
+};
+var SafeSubscriber = class extends Subscriber {
+  constructor(observerOrNext, error, complete, parentSubscriber) {
+    super(observerOrNext, error, complete);
+    /** @private */
+    this._isUnsubscribing = false;
+    /** @private */
+    this._parentSubscriber = null;
+    this._parentSubscriber = parentSubscriber || null;
+  }
+  next(value) {
+    if (!this.isStopped && !this._isUnsubscribing) {
+      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;
+  }
+};
+function operate(destination) {
+  return new Subscriber(destination.next, destination.error, destination.complete);
+}
+var Observable = class extends Subscription {
+  /**
+   * Creates a new Observable.
+   */
+  constructor(subscribe) {
+    super();
+    if (subscribe) {
+      this._subscribe = subscribe;
+    } else {
+      throw new TypeError("Observable constructor requires a subscribe function");
+    }
+  }
+  subscribe(observerOrNext, error, complete) {
+    let subscriber;
+    if (observerOrNext instanceof Subscriber) {
+      subscriber = observerOrNext;
+    } else {
+      subscriber = new SafeSubscriber(observerOrNext, error, complete);
+    }
+    const { _subscribe } = this;
+    try {
+      const result = _subscribe.call(this, subscriber);
+      if (result) {
+        if (typeof result === "function") {
+          subscriber.add(result);
+        } else if (typeof result.unsubscribe === "function") {
+          subscriber.add(result);
+        }
+      }
+    } catch (err) {
+      subscriber.error(err);
+    }
+    return subscriber;
+  }
+  pipe(...operations) {
+    if (operations.length === 0) {
+      return this;
+    }
+    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.
+   *
+   * @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)
+      });
+    });
+  }
+};
+export {
+  Observable,
+  SafeSubscriber,
+  Subscriber,
+  operate
+};