@fncts/observable 0.0.25 → 0.0.27

package/_src/Observable/definition.ts

@@ -19,7 +19,6 @@ export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A>
   readonly [ObservableTypeId]: ObservableTypeId = ObservableTypeId;
 
   protected source: Observable<any, any, any> | undefined;
-  protected operator: Operator<E, A> | undefined;
   protected environment: Environment<any> = Environment();
 
   constructor(
@@ -80,19 +79,11 @@ export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A>
     };
   }
 
-  lift<R1, E1, A1>(operator: Operator<E1, A1>): Observable<R1, E1, A1> {
-    const observable    = new Observable<R1, E1, A1>();
-    observable.source   = this;
-    observable.operator = operator;
-    return observable;
-  }
-
   provideEnvironment(environment: Environment<R>): Observable<never, E, A>;
   provideEnvironment<In>(environment: Environment<In>): Observable<Exclude<R, In>, E, A>;
   provideEnvironment<In>(environment: Environment<In>): Observable<Exclude<R, In>, E, A> {
     const observable       = new Observable<never, E, A>(this.subscribeInternal);
     observable.source      = this.source;
-    observable.operator    = this.operator;
     observable.environment = this.environment.union(environment);
     return observable;
   }
@@ -104,15 +95,9 @@ export class Observable<R, E, A> implements Subscribable<E, A>, AsyncIterable<A>
     this: Observable<never, E, A>,
     observer?: Partial<Observer<E, A>> | ((value: A) => void),
   ): Subscription {
-    const subscriber: Subscriber<E, A> = isSubscriber(observer) ? observer : new SafeSubscriber(observer);
+    const subscriber: Subscriber<E, A> = isSubscriber(observer) ? observer : new Subscriber(observer);
 
-    subscriber.add(
-      this.operator
-        ? this.operator.call(subscriber, this.source, this.environment)
-        : this.source
-          ? this.subscribeInternal(subscriber, this.environment)
-          : this.trySubscribe(subscriber, this.environment),
-    );
+    subscriber.add(this.trySubscribe(subscriber, this.environment));
 
     return subscriber;
   }

package/_src/Observable/dom/animationFrames.ts

@@ -31,7 +31,7 @@ function animationFramesInternal(timestampProvider?: TimestampProvider): Observa
         timestamp: timestampProvider ? now : timestamp,
         elapsed: now - start,
       });
-      if (!subscriber.closed) {
+      if (!subscriber._closed) {
         subscription.add(schedule(run));
       }
     };

package/_src/Observable.ts

@@ -1,28 +1,27 @@
-/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Observable/*.ts }
-export * from "./Observable/instances.js";
-export * from "./Observable/definition.js";
 export * from "./Observable/api.js";
+export * from "./Observable/definition.js";
+export * from "./Observable/instances.js";
 // codegen:end
-/* eslint-disable simple-import-sort/exports */
+
 // codegen:start { preset: barrel, include: Observable/api/*.ts }
-export * from "./Observable/api/windowWhen.js";
-export * from "./Observable/api/windowToggle.js";
-export * from "./Observable/api/windowTime.js";
-export * from "./Observable/api/windowCount.js";
-export * from "./Observable/api/window.js";
-export * from "./Observable/api/share.js";
-export * from "./Observable/api/retryWhen.js";
-export * from "./Observable/api/repeatWhen.js";
-export * from "./Observable/api/raceWith.js";
-export * from "./Observable/api/race.js";
-export * from "./Observable/api/index.js";
-export * from "./Observable/api/fromEvent.js";
-export * from "./Observable/api/fromCallback.js";
-export * from "./Observable/api/connectable.js";
 export * from "./Observable/api/connect.js";
+export * from "./Observable/api/connectable.js";
+export * from "./Observable/api/fromCallback.js";
+export * from "./Observable/api/fromEvent.js";
+export * from "./Observable/api/index.js";
+export * from "./Observable/api/race.js";
+export * from "./Observable/api/raceWith.js";
+export * from "./Observable/api/repeatWhen.js";
+export * from "./Observable/api/retryWhen.js";
+export * from "./Observable/api/share.js";
+export * from "./Observable/api/window.js";
+export * from "./Observable/api/windowCount.js";
+export * from "./Observable/api/windowTime.js";
+export * from "./Observable/api/windowToggle.js";
+export * from "./Observable/api/windowWhen.js";
 // codegen:end
-/* eslint-disable simple-import-sort/exports */
+
 // codegen:start { preset: barrel, include: Observable/dom/*.ts }
 export * from "./Observable/dom/animationFrames.js";
 // codegen:end

package/_src/ObservableRef.ts

@@ -1,6 +1,5 @@
-/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./ObservableRef/*.ts }
-export * from "./ObservableRef/definition.js";
-export * from "./ObservableRef/atomic.js";
 export * from "./ObservableRef/api.js";
+export * from "./ObservableRef/atomic.js";
+export * from "./ObservableRef/definition.js";
 // codegen:end

package/_src/Operator.ts

@@ -1,3 +1,5 @@
+import type { SubscriberOverrides } from "./Subscriber.js";
+
 export interface Operator<E, A> {
   call(subscriber: Subscriber<E, A>, source: any, environment: Environment<any>): Finalizer;
 }
@@ -44,7 +46,7 @@ export class OperatorSubscriber<E, A> extends Subscriber<E, A> {
       : super.complete;
   }
   unsubscribe() {
-    const { closed } = this;
+    const { _closed: closed } = this;
     super.unsubscribe();
     !closed && this.onFinalize?.();
   }
@@ -56,27 +58,13 @@ export function operatorSubscriber<E, A, E1, A1>(
 ): OperatorSubscriber<E, A> {
   return new OperatorSubscriber(destination, observer, onFinalize);
 }
+
 /**
- * @tsplus pipeable fncts.observable.Observable operate
+ * @tsplus pipeable fncts.observable.Subscriber operate
  */
-export function operate_<R, E, A, R1, E1, A1>(
-  f: (
-    source: Observable<R, E, A>,
-    subscriber: Subscriber<E1, A1>,
-    environment: Environment<R | R1>,
-  ) => (() => void) | void,
-) {
-  return (source: Observable<R, E, A>): Observable<R1, E1, A1> => {
-    return source.lift(function (
-      this: Subscriber<E1, A1>,
-      liftedSource: Observable<R, E, A>,
-      environment: Environment<R | R1>,
-    ) {
-      try {
-        f(liftedSource, this, environment);
-      } catch (err) {
-        this.error(Cause.halt(err));
-      }
-    });
+export function operate_<E1, A1>(config: SubscriberOverrides<E1, A1>) {
+  return <E, A>(destination: Subscriber<E, A>): Subscriber<E1, A1> => {
+    // @ts-expect-error
+    return new Subscriber<E1, A1>(destination, config);
   };
 }

package/_src/Subject.ts

@@ -1,11 +1,19 @@
-import { arrayRemove } from "@fncts/observable/internal/util";
-
 export interface SubjectLike<E, A> extends Observer<E, A>, Subscribable<E, A> {}
 
+/**
+ * A Subject is a special type of Observable that allows values to be
+ * multicasted to many Observers. Subjects are like EventEmitters.
+ *
+ * Every Subject is an Observable and an Observer. You can subscribe to a
+ * Subject, and you can call next to feed values as well as error and complete.
+ */
 export class Subject<R, E, A> extends Observable<R, E, A> implements SubscriptionLike {
-  closed = false;
-  protected observers: Array<Observer<E, A>> = [];
-  protected isStopped             = false;
+  _closed = false;
+
+  protected currentObservers = new Map<number, Observer<E, A>>();
+  private observersCount     = 0;
+  private observerSnapshot: Array<Observer<E, A>> | undefined;
+
   protected hasError              = false;
   protected thrownError: Cause<E> = null!;
 
@@ -13,83 +21,102 @@ export class Subject<R, E, A> extends Observable<R, E, A> implements Subscriptio
     super();
   }
 
-  lift<R1, E1, B>(operator: Operator<E1, B>): Observable<R1, E1, B> {
-    const subject    = new AnonymousSubject(this, this);
-    subject.operator = operator as any;
-    return subject as any;
+  get closed() {
+    return this._closed;
+  }
+
+  get observers(): Array<Observer<E, A>> {
+    return (this.observerSnapshot ??= Array.from(this.currentObservers.values()));
   }
 
   next(value: A) {
-    this.throwIfClosed();
-    if (!this.isStopped) {
-      const copy = this.observers.slice();
-      for (const observer of copy) {
-        observer.next(value);
+    if (!this._closed) {
+      const { observers } = this;
+      const len           = observers.length;
+      for (let i = 0; i < len; i++) {
+        observers[i].next(value);
       }
     }
   }
 
   error(err: Cause<E>) {
-    this.throwIfClosed();
-    if (!this.isStopped) {
-      this.hasError       = this.isStopped = true;
+    if (!this._closed) {
+      this.hasError       = this._closed = true;
       this.thrownError    = err;
       const { observers } = this;
-      while (observers.length) {
-        observers.shift()!.error(err);
+      const len           = observers.length;
+      for (let i = 0; i < len; i++) {
+        observers[i].error(err);
       }
+      this.clearObservers();
     }
   }
 
   complete() {
-    this.throwIfClosed();
-    if (!this.isStopped) {
-      this.isStopped      = true;
+    if (!this._closed) {
+      this._closed        = true;
       const { observers } = this;
-      while (observers.length) {
-        observers.shift()!.complete();
+      const len           = observers.length;
+      for (let i = 0; i < len; i++) {
+        observers[i].complete();
       }
+      this.clearObservers();
     }
   }
 
   unsubscribe() {
-    this.isStopped = this.closed = true;
-    this.observers = null!;
+    this._closed = true;
+    this.clearObservers();
   }
 
   get observed() {
-    return this.observers?.length > 0;
+    return this.currentObservers.size > 0;
   }
 
   protected throwIfClosed() {
-    if (this.closed) {
+    if (this._closed) {
       throw new Error("Object Unsubscribed");
     }
   }
 
+  protected clearObservers() {
+    this.currentObservers.clear();
+    this.observerSnapshot = undefined;
+  }
+
   protected trySubscribe(subscriber: Subscriber<E, A>, environment: Environment<R>): Finalizer {
     this.throwIfClosed();
     return super.trySubscribe(subscriber, environment);
   }
 
   protected subscribeInternal(subscriber: Subscriber<E, A>): Subscription {
-    this.throwIfClosed();
     this.checkFinalizedStatuses(subscriber);
     return this.innerSubscribe(subscriber);
   }
 
   protected innerSubscribe(subscriber: Subscriber<E, A>): Subscription {
-    const { hasError, isStopped, observers } = this;
-    return hasError || isStopped
-      ? Subscription.empty
-      : (observers.push(subscriber), new Subscription(() => arrayRemove(observers, subscriber)));
+    const { hasError, _closed: closed } = this;
+    if (hasError || closed) {
+      return Subscription.empty;
+    }
+
+    const { currentObservers } = this;
+
+    const observerId = this.observersCount++;
+    currentObservers.set(observerId, subscriber);
+    this.observerSnapshot = undefined;
+    subscriber.add(() => {
+      currentObservers.delete(observerId);
+      this.observerSnapshot = undefined;
+    });
+    return subscriber;
   }
 
   protected checkFinalizedStatuses(subscriber: Subscriber<any, any>) {
-    const { hasError, thrownError, isStopped } = this;
+    const { hasError, thrownError, _closed: closed } = this;
     if (hasError) {
       subscriber.error(thrownError);
-    } else if (isStopped) {
+    } else if (closed) {
       subscriber.complete();
     }
   }
@@ -132,10 +159,10 @@ export class AsyncSubject<R, E, A> extends Subject<R, E, A> {
 
   /** @internal */
   protected checkFinalizedStatuses(subscriber: Subscriber<E, A>) {
-    const { hasError, hasValue, value, thrownError, isStopped, isComplete } = this;
+    const { hasError, hasValue, value, thrownError, _closed: closed, isComplete } = this;
     if (hasError) {
       subscriber.error(thrownError);
-    } else if (isStopped || isComplete) {
+    } else if (closed || isComplete) {
       hasValue &&
         value!.match(
           (e) => subscriber.error(e),
@@ -146,14 +173,14 @@ export class AsyncSubject<R, E, A> extends Subject<R, E, A> {
   }
 
   next(value: A) {
-    if (!this.isStopped) {
+    if (!this._closed) {
       this.value    = Either.right(value);
       this.hasValue = true;
     }
   }
 
   error(err: Cause<E>) {
-    if (!this.isStopped) {
+    if (!this._closed) {
       this.value    = Either.left(err);
       this.hasValue = true;
     }

package/_src/Subscriber.ts

@@ -1,55 +1,92 @@
+import { Cause } from "@fncts/base/data/Cause";
+import { isFunction } from "@fncts/base/util/predicates";
+
+import { config } from "./config.js";
+import { reportUnhandledError } from "./internal/util.js";
+import { Notification } from "./Notification.js";
+
 export const SubscriberTypeId = Symbol.for("fncts.observable.Subscriber");
 export type SubscriberTypeId = typeof SubscriberTypeId;
 
+export interface SubscriberOverrides<E, A> {
+  next?: (value: A) => void;
+  error?: (error: Cause<E>) => void;
+  complete?: () => void;
+  finalize?: () => void;
+}
+
+/**
+ * @tsplus type fncts.observable.Subscriber
+ */
 export class Subscriber<E, A> extends Subscription implements Observer<E, A> {
   readonly [SubscriberTypeId]: SubscriberTypeId = SubscriberTypeId;
 
   private isStopped = false;
-  protected observer: Subscriber<E, A> | Observer<E, A> | null;
-
-  constructor(observer?: Subscriber<E, A> | Observer<E, A>) {
-    super();
-    if (observer) {
-      this.observer = observer;
-      if (isSubscription(observer)) {
-        observer.add(this);
-      }
-    } else {
-      this.observer = EMPTY_OBSERVER;
+  protected destination: Subscriber<E, A> | Observer<E, A> | null;
+
+  protected readonly nextOverride: ((value: A) => void) | null       = null;
+  protected readonly errorOverride: ((err: Cause<E>) => void) | null = null;
+  protected readonly completeOverride: (() => void) | null           = null;
+
+  constructor(
+    destination?: Subscriber<E, A> | Partial<Observer<E, A>> | ((value: A) => void) | null,
+    overrides?: SubscriberOverrides<E, A>,
+  ) {
+    super(overrides?.finalize);
+
+    this.destination = destination instanceof Subscriber ? destination : createSafeObserver(destination);
+
+    this.nextOverride     = overrides?.next ?? null;
+    this.errorOverride    = overrides?.error ?? null;
+    this.completeOverride = overrides?.complete ?? null;
+
+    this.next     = this.nextOverride ? overrideNext : this.next;
+    this.error    = this.errorOverride ? overrideError : this.error;
+    this.complete = this.completeOverride ? overrideComplete : this.complete;
+
+    if (hasAddAndUnsubscribe(destination)) {
+      destination.add(this);
     }
   }
+
   next(value: A) {
-    if (!this.isStopped) {
+    if (this.isStopped) {
+      handleStoppedNotification(Notification.next(value), this);
+    } else {
       this._next(value);
     }
   }
   error(err: Cause<E>) {
-    if (!this.isStopped) {
+    if (this.isStopped) {
+      handleStoppedNotification(Notification.error(err), this);
+    } else {
       this.isStopped = true;
       this._error(err);
     }
   }
   complete() {
-    if (!this.isStopped) {
+    if (this.isStopped) {
+      handleStoppedNotification(Notification.complete(), this);
+    } else {
       this.isStopped = true;
       this._complete();
     }
   }
   unsubscribe(): void {
-    if (!this.closed) {
+    if (!this._closed) {
       this.isStopped = true;
       super.unsubscribe();
-      this.observer = null;
+      this.destination = null;
     }
   }
 
   _next(value: A) {
-    this.observer!.next(value);
+    this.destination!.next(value);
   }
 
   _error(err: Cause<E>) {
     try {
-      this.observer!.error(err);
+      this.destination!.error(err);
     } finally {
       this.unsubscribe();
     }
@@ -57,60 +94,89 @@ export class Subscriber<E, A> extends Subscription implements Observer<E, A> {
 
   _complete() {
     try {
-      this.observer!.complete();
+      this.destination!.complete();
     } finally {
       this.unsubscribe();
     }
   }
 }
-export class SafeSubscriber<E, A> extends Subscriber<E, A> {
-  constructor(observer?: Partial<Observer<E, A>> | ((value: A) => void)) {
-    super();
-    let next: ((value: A) => void) | undefined       = undefined;
-    let error: ((err: Cause<E>) => void) | undefined = undefined;
-    let complete: (() => void) | undefined           = undefined;
-    if (isFunction(observer)) {
-      next = observer;
-    } else if (observer) {
-      ({ next, error, complete } = observer);
-      next     = next?.bind(observer);
-      error    = error?.bind(observer);
-      complete = complete?.bind(observer);
+
+function createSafeObserver<E, A>(
+  observerOrNext?: Partial<Observer<E, A>> | ((value: A) => void) | null,
+): Observer<E, A> {
+  return new ConsumerObserver(
+    !observerOrNext || isFunction(observerOrNext) ? { next: observerOrNext ?? undefined } : observerOrNext,
+  );
+}
+
+export class ConsumerObserver<E, A> implements Observer<E, A> {
+  private onError: (error: Cause<E>) => void = reportUnhandledError;
+  constructor(private partialObserver: Partial<Observer<E, A>>) {
+    this.onError = partialObserver.error ?? reportUnhandledError;
+  }
+
+  next(value: A): void {
+    const { partialObserver } = this;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        this.onError(Cause.halt(error));
+      }
     }
-    if (error) {
-      this.observer = {
-        next: next ? wrapDefectHandler(next, error) : noop,
-        error: error ? wrapDefectHandler(error, error) : noop,
-        complete: complete ? wrapDefectHandler(complete, error) : noop,
-      };
+  }
+
+  error(err: Cause<E>): void {
+    const { partialObserver } = this;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        this.onError(Cause.halt(error));
+      }
     } else {
-      this.observer = {
-        next: next ? wrapThrowHandler(next) : noop,
-        error: wrapThrowHandler(error ?? defaultErrorHandler),
-        complete: complete ? wrapThrowHandler(complete) : noop,
-      };
+      this.onError(err);
     }
   }
-}
 
-function wrapDefectHandler<E>(handler: (arg?: any) => void, onDefect: (err: Cause<E>) => void) {
-  return (...args: any[]) => {
-    try {
-      handler(...args);
-    } catch (err) {
-      onDefect(Cause.halt(err));
+  complete(): void {
+    const { partialObserver } = this;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        this.onError(Cause.halt(error));
+      }
     }
-  };
+  }
 }
 
-function wrapThrowHandler(handler: (arg?: any) => void) {
-  return (...args: any[]) => {
-    try {
-      handler(...args);
-    } catch (err) {
-      reportUnhandledError(err);
-    }
-  };
+function overrideNext<E, A>(this: Subscriber<E, A>, value: A): void {
+  try {
+    this.nextOverride!(value);
+  } catch (error) {
+    this.destination!.error(Cause.halt(error));
+  }
+}
+
+function overrideError<E, A>(this: Subscriber<E, A>, err: Cause<E>): void {
+  try {
+    this.errorOverride!(err);
+  } catch (error) {
+    this.destination!.error(Cause.halt(error));
+  } finally {
+    this.unsubscribe();
+  }
+}
+
+function overrideComplete<E, A>(this: Subscriber<E, A>): void {
+  try {
+    this.completeOverride!();
+  } catch (error) {
+    this.destination!.error(Cause.halt(error));
+  } finally {
+    this.unsubscribe();
+  }
 }
 
 function defaultErrorHandler(error: any) {
@@ -126,6 +192,15 @@ export const EMPTY_OBSERVER: Readonly<Observer<any, any>> & {
   complete: noop,
 };
 
+function hasAddAndUnsubscribe(value: any): value is Subscription {
+  return value && isFunction(value.unsubscribe) && isFunction(value.add);
+}
+
 export function isSubscriber(u: unknown): u is Subscriber<any, any> {
   return isObject(u) && SubscriberTypeId in u;
 }
+
+function handleStoppedNotification<E, A>(notification: Notification<E, A>, subscriber: Subscriber<E, A>) {
+  const { onStoppedNotification } = config;
+  onStoppedNotification && timeoutProvider.setTimeout(() => onStoppedNotification(notification, subscriber));
+}

package/_src/Subscription.ts

@@ -3,7 +3,7 @@ export interface Unsubscribable {
 }
 
 export interface SubscriptionLike extends Unsubscribable {
-  readonly closed: boolean;
+  readonly _closed: boolean;
 }
 
 export type Finalizer = Unsubscribable | (() => void) | void;
@@ -18,7 +18,7 @@ export type SubscriptionTypeId = typeof SubscriptionTypeId;
 export class Subscription implements SubscriptionLike {
   readonly [SubscriptionTypeId]: SubscriptionTypeId = SubscriptionTypeId;
 
-  public closed = false;
+  public _closed = false;
   private finalizers: Set<Finalizer> | null = null;
   private parents: Set<Subscription> | null = null;
 
@@ -27,8 +27,8 @@ export class Subscription implements SubscriptionLike {
   unsubscribe(): void {
     let errors: unknown[] | undefined;
 
-    if (!this.closed) {
-      this.closed = true;
+    if (!this._closed) {
+      this._closed = true;
 
       const { parents, initialFinalizer, finalizers } = this;
 
@@ -71,11 +71,11 @@ export class Subscription implements SubscriptionLike {
 
   add(finalizer: Finalizer): void {
     if (finalizer && finalizer !== this) {
-      if (this.closed) {
+      if (this._closed) {
         executeFinalizer(finalizer);
       } else {
         if (isSubscription(finalizer)) {
-          if (finalizer.closed || finalizer.hasParent(this)) {
+          if (finalizer._closed || finalizer.hasParent(this)) {
             return;
           }
           finalizer.addParent(this);
@@ -125,8 +125,8 @@ function executeFinalizer(finalizer: Finalizer): void {
  * @tsplus static fncts.observable.SubscriptionOps empty
  */
 export const EMPTY_SUBSCRIPTION = (() => {
-  const empty  = new Subscription();
-  empty.closed = true;
+  const empty   = new Subscription();
+  empty._closed = true;
   return empty;
 })();