@fncts/observable 0.0.9 → 0.0.10

package/_src/AnimationFrameScheduler.ts

@@ -1,23 +1,18 @@
-/* eslint-disable no-param-reassign */
 export class AnimationFrameScheduler extends AsyncScheduler {
   public flush(action?: AsyncAction<any>): void {
-    this.active    = true;
-    this.scheduled = undefined;
-
+    this.active       = true;
+    this.scheduled    = undefined;
     const { actions } = this;
     let error: any;
     let index         = -1;
     action            = action || actions.shift()!;
     const count       = actions.length;
-
     do {
       if ((error = action.execute(action.state, action.delay!))) {
         break;
       }
     } while (++index < count && (action = actions.shift()));
-
     this.active = false;
-
     if (error) {
       while (++index < count && (action = actions.shift())) {
         action.unsubscribe();

package/_src/BehaviorSubject.ts

@@ -1,4 +1,4 @@
-export class BehaviorSubject<R, E, A> extends Subject<R, E, A> {
+export class BehaviorSubject<A> extends Subject<never, never, A> {
   constructor(private _value: A) {
     super();
   }
@@ -16,8 +16,8 @@ export class BehaviorSubject<R, E, A> extends Subject<R, E, A> {
     return _value;
   }
 
-  protected subscribeInternal(subscriber: Subscriber<E, A>) {
-    const subscription = super.subscribe(subscriber);
+  protected subscribeInternal(subscriber: Subscriber<never, A>) {
+    const subscription = super.subscribeInternal(subscriber);
     !subscription.closed && subscriber.next(this._value);
     return subscription;
   }

package/_src/Notification.ts

@@ -60,32 +60,30 @@ export function complete<E = never, A = never>(): Notification<E, A> {
 }
 
 /**
- * @tsplus fluent fncts.observable.Notification match
+ * @tsplus pipeable fncts.observable.Notification match
  */
-export function match_<E, A, B, C, D, F>(
-  fa: Notification<E, A>,
-  onNext: (a: A) => B,
-  onFail: (e: Cause<E>) => C,
-  onComplete: () => F,
-): B | C | D | F {
-  switch (fa._tag) {
-    case "Next":
-      return onNext(fa.value);
-    case "Fail":
-      return onFail(fa.error);
-    case "Complete":
-      return onComplete();
-  }
+export function match<E, A, B, C, F>(onNext: (a: A) => B, onFail: (e: Cause<E>) => C, onComplete: () => F) {
+  return <D>(fa: Notification<E, A>): B | C | D | F => {
+    switch (fa._tag) {
+      case "Next":
+        return onNext(fa.value);
+      case "Fail":
+        return onFail(fa.error);
+      case "Complete":
+        return onComplete();
+    }
+  };
 }
 
 /**
- * @tsplus fluent fncts.observable.Notification observe
+ * @tsplus pipeable fncts.observable.Notification observe
  */
-export function observe_<E, A>(notification: Notification<E, A>, observer: Partial<Observer<E, A>>): void {
-  return match_(
-    notification,
-    (a) => observer.next?.(a),
-    (e) => observer.error?.(e),
-    () => observer.complete?.(),
-  );
+export function observe<E, A>(observer: Partial<Observer<E, A>>) {
+  return (notification: Notification<E, A>): void => {
+    return notification.match(
+      (a) => observer.next?.(a),
+      (e) => observer.error?.(e),
+      () => observer.complete?.(),
+    );
+  };
 }

package/_src/Observable/api/connect.ts

@@ -7,17 +7,20 @@ const DEFAULT_CONNECT_CONFIG: ConnectConfig<any, any> = {
 };
 
 /**
- * @tsplus fluent fncts.observable.Observable connect
+ * @tsplus pipeable fncts.observable.Observable connect
  */
 export function connect<R, E, A, R1, E1, B>(
-  fa: Observable<R, E, A>,
   selector: (shared: Observable<R, E, A>) => ObservableInput<R1, E1, B>,
   config: ConnectConfig<E, A> = DEFAULT_CONNECT_CONFIG,
-): Observable<R | R1, E | E1, B> {
-  const { connector } = config;
-  return fa.operate((source, subscriber) => {
-    const subject = connector();
-    Observable.from(selector(Observable.fromSubscribable(subject))).subscribe(subscriber);
-    subscriber.add(source.subscribe(subject));
-  });
+) {
+  return (fa: Observable<R, E, A>): Observable<R | R1, E | E1, B> => {
+    const { connector } = config;
+    return fa.operate((source, subscriber, environment) => {
+      const subject = connector();
+      Observable.from(selector(Observable.fromSubscribable(subject)))
+        .provideEnvironment(environment)
+        .subscribe(subscriber);
+      subscriber.add(source.provideEnvironment(environment).subscribe(subject));
+    });
+  };
 }

package/_src/Observable/api/connectable.ts

@@ -32,7 +32,7 @@ export class Connectable<R, E, A> extends Observable<R, E, A> implements Connect
   }
   connect() {
     if (!this.connection || this.connection.closed) {
-      this.connection = Observable.defer(this.source).subscribe(this.subject);
+      this.connection = Observable.defer(this.source).provideEnvironment(this.environment).subscribe(this.subject);
       if (this.resetOnDisconnect) {
         this.connection.add(() => (this.subject = this.connector()));
       }
@@ -42,11 +42,10 @@ export class Connectable<R, E, A> extends Observable<R, E, A> implements Connect
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable connectable
+ * @tsplus pipeable fncts.observable.Observable connectable
  */
-export function connectable<R, E, A>(
-  source: ObservableInput<R, E, A>,
-  config: ConnectableConfig<E, A> = DEFAULT_CONFIG,
-): Connectable<R, E, A> {
-  return new Connectable(source, config);
+export function connectable<E, A>(config: ConnectableConfig<E, A> = DEFAULT_CONFIG) {
+  return <R>(source: ObservableInput<R, E, A>): Connectable<R, E, A> => {
+    return new Connectable(source, config);
+  };
 }

package/_src/Observable/api/fromCallback.ts

@@ -51,7 +51,6 @@ function fromCallbackInternal(
         if (isComplete) {
           subject.complete();
         }
-
         isAsync = true;
       }
       return subs;

package/_src/Observable/api/fromEvent.ts

@@ -1,5 +1,8 @@
 type EventHandler = (...args: any[]) => void;
 
+/**
+ * @tsplus static fncts.observable.ObservableOps fromEvent
+ */
 export function fromEvent<A extends ReadonlyArray<unknown>>(
   addHandler: (handler: (...args: A) => void) => any,
   removeHandler?: (handler: EventHandler, signal?: any) => void,

package/_src/Observable/api/race.ts

@@ -8,23 +8,25 @@ export function race<O extends ReadonlyArray<ObservableInput<any, any>>>(
 }
 
 export function raceInit<R, E, A>(sources: ReadonlyArray<ObservableInput<R, E, A>>) {
-  return (subscriber: Subscriber<E, A>) => {
+  return (subscriber: Subscriber<E, A>, environment: Environment<R>) => {
     let subscriptions: Subscription[] = [];
     for (let i = 0; subscriptions && !subscriber.closed && i < sources.length; i++) {
       subscriptions.push(
-        Observable.from(sources[i]!).subscribe(
-          operatorSubscriber(subscriber, {
-            next: (value) => {
-              if (subscriptions) {
-                for (let s = 0; s < subscriptions.length; s++) {
-                  s !== i && subscriptions[s]!.unsubscribe();
+        Observable.from(sources[i]!)
+          .provideEnvironment(environment)
+          .subscribe(
+            operatorSubscriber(subscriber, {
+              next: (value) => {
+                if (subscriptions) {
+                  for (let s = 0; s < subscriptions.length; s++) {
+                    s !== i && subscriptions[s]!.unsubscribe();
+                  }
+                  subscriptions = null!;
                 }
-                subscriptions = null!;
-              }
-              subscriber.next(value);
-            },
-          }),
-        ),
+                subscriber.next(value);
+              },
+            }),
+          ),
       );
     }
   };

package/_src/Observable/api/raceWith.ts

@@ -1,19 +1,20 @@
 import { raceInit } from "./race.js";
 
 /**
- * @tsplus fluent fncts.observable.Observablen raceWith
+ * @tsplus pipeable fncts.observable.Observablen raceWith
  */
-export function raceWith_<R, E, A, O extends ReadonlyArray<ObservableInput<any, any>>>(
-  fa: Observable<R, E, A>,
-  ...sources: O
-): Observable<
-  R | Observable.EnvironmentOf<O[number]>,
-  E | Observable.ErrorOf<O[number]>,
-  A | Observable.TypeOf<O[number]>
-> {
-  return !sources.length
-    ? fa
-    : fa.operate((source, subscriber) => {
-        raceInit([source, ...sources])(subscriber);
-      });
+export function raceWith<O extends ReadonlyArray<ObservableInput<any, any>>>(...sources: O) {
+  return <R, E, A>(
+    fa: Observable<R, E, A>,
+  ): Observable<
+    R | Observable.EnvironmentOf<O[number]>,
+    E | Observable.ErrorOf<O[number]>,
+    A | Observable.TypeOf<O[number]>
+  > => {
+    return !sources.length
+      ? fa
+      : fa.operate((source, subscriber, environment) => {
+          raceInit([source, ...sources])(subscriber, environment);
+        });
+  };
 }

package/_src/Observable/api/repeatWhen.ts

@@ -1,63 +1,58 @@
-export function repeatWhen_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
+/**
+ * @tsplus pipeable fncts.observable.Observable repeatWhen
+ */
+export function repeatWhen<R, E, A, R1, E1>(
   notifier: (notifications: Observable<never, never, void>) => Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return fa.operate((source, subscriber) => {
-    let innerSub: Subscription | null;
-    let syncResub = false;
-    let completions$: Subject<never, never, void>;
-    let isNotifierComplete = false;
-    let isMainComplete     = false;
-
-    const checkComplete = () => isMainComplete && isNotifierComplete && (subscriber.complete(), true);
-
-    const getCompletionSubject = () => {
-      if (!completions$) {
-        completions$ = new Subject();
-        notifier(completions$).subscribe(
+) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let innerSub: Subscription | null;
+      let syncResub = false;
+      let completions$: Subject<never, never, void>;
+      let isNotifierComplete     = false;
+      let isMainComplete         = false;
+      const checkComplete        = () => isMainComplete && isNotifierComplete && (subscriber.complete(), true);
+      const getCompletionSubject = () => {
+        if (!completions$) {
+          completions$ = new Subject();
+          notifier(completions$)
+            .provideEnvironment(environment)
+            .subscribe(
+              operatorSubscriber(subscriber, {
+                next: () => {
+                  if (innerSub) {
+                    loop();
+                  } else {
+                    syncResub = true;
+                  }
+                },
+                complete: () => {
+                  isNotifierComplete = true;
+                  checkComplete();
+                },
+              }),
+            );
+        }
+        return completions$;
+      };
+      const loop = () => {
+        isMainComplete = false;
+        innerSub       = source.provideEnvironment(environment).subscribe(
           operatorSubscriber(subscriber, {
-            next: () => {
-              if (innerSub) {
-                loop();
-              } else {
-                syncResub = true;
-              }
-            },
             complete: () => {
-              isNotifierComplete = true;
-              checkComplete();
+              isMainComplete = true;
+              !checkComplete() && getCompletionSubject().next();
             },
           }),
         );
-      }
-      return completions$;
-    };
-
-    const loop = () => {
-      isMainComplete = false;
-      innerSub       = source.subscribe(
-        operatorSubscriber(subscriber, {
-          complete: () => {
-            isMainComplete = true;
-            !checkComplete() && getCompletionSubject().next();
-          },
-        }),
-      );
-
-      if (syncResub) {
-        innerSub.unsubscribe();
-        innerSub  = null;
-        syncResub = false;
-        loop();
-      }
-    };
-
-    loop();
-  });
-}
-
-export function repeatWhen<R1, E1>(
-  notifier: (notifications: Observable<never, never, void>) => Observable<R1, E1, any>,
-): <R, E, A>(fa: Observable<R, E, A>) => Observable<R | R1, E | E1, A> {
-  return (fa) => repeatWhen_(fa, notifier);
+        if (syncResub) {
+          innerSub.unsubscribe();
+          innerSub  = null;
+          syncResub = false;
+          loop();
+        }
+      };
+      loop();
+    });
+  };
 }

package/_src/Observable/api/retryWhen.ts

@@ -1,47 +1,42 @@
 /**
- * @tsplus fluent fncts.observable.Observable retryWhen
+ * @tsplus pipeable fncts.observable.Observable retryWhen
  */
-export function retryWhen_<R, E, A, R1, E1>(
-  fa: Observable<R, E, A>,
+export function retryWhen<E, R1, E1>(
   notifier: (errors: Observable<never, never, Cause<E>>) => Observable<R1, E1, any>,
-): Observable<R | R1, E | E1, A> {
-  return operate_(fa, (source, subscriber) => {
-    let innerSub: Subscription | null;
-    let syncResub = false;
-    let defects$: Subject<never, never, any>;
-
-    const loop = () => {
-      innerSub = source.subscribe(
-        operatorSubscriber(subscriber, {
-          error: (err) => {
-            if (!defects$) {
-              defects$ = new Subject();
-              notifier(defects$).subscribe(
-                operatorSubscriber(subscriber, {
-                  next: () => (innerSub ? loop() : (syncResub = true)),
-                }),
-              );
-            }
-            if (defects$) {
-              defects$.next(err);
-            }
-          },
-        }),
-      );
-      if (syncResub) {
-        innerSub.unsubscribe();
-        innerSub  = null;
-        syncResub = false;
-        loop();
-      }
-    };
-
-    loop();
-  });
-}
-
-export function retryWhen<R1, E1>(
-  notifier: (errors: Observable<never, never, any>) => Observable<R1, E1, any>,
-): <R, E, A>(fa: Observable<R, E, A>) => Observable<R | R1, E | E1, A> {
-  return (fa) => retryWhen_(fa, notifier);
+) {
+  return <R, A>(fa: Observable<R, E, A>): Observable<R | R1, E | E1, A> => {
+    return fa.operate((source, subscriber, environment) => {
+      let innerSub: Subscription | null;
+      let syncResub = false;
+      let defects$: Subject<never, never, any>;
+      const loop    = () => {
+        innerSub = source.provideEnvironment(environment).subscribe(
+          operatorSubscriber(subscriber, {
+            error: (err) => {
+              if (!defects$) {
+                defects$ = new Subject();
+                notifier(defects$)
+                  .provideEnvironment(environment)
+                  .subscribe(
+                    operatorSubscriber(subscriber, {
+                      next: () => (innerSub ? loop() : (syncResub = true)),
+                    }),
+                  );
+              }
+              if (defects$) {
+                defects$.next(err);
+              }
+            },
+          }),
+        );
+        if (syncResub) {
+          innerSub.unsubscribe();
+          innerSub  = null;
+          syncResub = false;
+          loop();
+        }
+      };
+      loop();
+    });
+  };
 }

package/_src/Observable/api/share.ts

@@ -1,101 +1,93 @@
 export interface ShareConfig<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R3 = never, E3 = never> {
-  readonly connector?: () => SubjectLike<E, A>;
+  readonly connector?: () => Subject<R, E, A>;
   readonly resetOnDefect?: boolean | ((err: unknown) => Observable<R1, E1, any>);
   readonly resetOnComplete?: boolean | (() => Observable<R2, E2, any>);
   readonly resetOnRefCountZero?: boolean | (() => Observable<R3, E3, any>);
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable share
+ * @tsplus pipeable fncts.observable.Observable share
  */
-export function share_<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R3 = never, E3 = never>(
-  fa: Observable<R, E, A>,
+export function share<R, E, A, R1 = never, E1 = never, R2 = never, E2 = never, R3 = never, E3 = never>(
   options: ShareConfig<R, E, A, R1, E1, R2, E2, R3, E3> = {},
-): Observable<R | R1 | R2, E | E1 | E2 | E3, A> {
-  const {
-    connector = () => new Subject<R, E, A>(),
-    resetOnDefect = true,
-    resetOnComplete = true,
-    resetOnRefCountZero = true,
-  } = options;
-
-  let connection: SafeSubscriber<E, A> | null = null;
-  let resetConnection: Subscription | null    = null;
-  let subject: SubjectLike<E, A> | null       = null;
-  let refCount     = 0;
-  let hasCompleted = false;
-  let hasErrored   = false;
-
-  const cancelReset = () => {
-    resetConnection?.unsubscribe();
-    resetConnection = null;
-  };
-
-  const reset = () => {
-    cancelReset();
-    connection   = subject = null;
-    hasCompleted = hasErrored = false;
-  };
-
-  const resetAndUnsubscribe = () => {
-    const conn = connection;
-    reset();
-    conn?.unsubscribe();
-  };
-
-  return operate_(fa, (source, subscriber) => {
-    refCount++;
-    if (!hasErrored && !hasCompleted) {
+) {
+  return (fa: Observable<R, E, A>): Observable<R | R1 | R2, E | E1 | E2 | E3, A> => {
+    const {
+      connector = () => new Subject<R, E, A>(),
+      resetOnDefect = true,
+      resetOnComplete = true,
+      resetOnRefCountZero = true,
+    } = options;
+    let connection: SafeSubscriber<E, A> | null = null;
+    let resetConnection: Subscription | null    = null;
+    let subject: Subject<R, E, A> | null        = null;
+    let refCount      = 0;
+    let hasCompleted  = false;
+    let hasErrored    = false;
+    const cancelReset = () => {
+      resetConnection?.unsubscribe();
+      resetConnection = null;
+    };
+    const reset = () => {
       cancelReset();
-    }
-
-    const dest = (subject ||= connector());
-
-    subscriber.add(() => {
-      refCount--;
-      if (refCount === 0 && !hasErrored && !hasCompleted) {
-        resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+      connection   = subject = null;
+      hasCompleted = hasErrored = false;
+    };
+    const resetAndUnsubscribe = () => {
+      const conn = connection;
+      reset();
+      conn?.unsubscribe();
+    };
+    return fa.operate((source, subscriber, environment) => {
+      refCount++;
+      if (!hasErrored && !hasCompleted) {
+        cancelReset();
       }
-    });
-
-    dest.subscribe(subscriber);
-
-    if (!connection) {
-      connection = new SafeSubscriber({
-        next: (value) => dest.next(value),
-        error: (defect) => {
-          hasErrored = true;
-          cancelReset();
-          resetConnection = handleReset(reset, resetOnDefect, defect);
-          dest.error(defect);
-        },
-        complete: () => {
-          hasCompleted = true;
-          cancelReset();
-          resetConnection = handleReset(reset, resetOnComplete);
-          dest.complete();
-        },
+      const dest = (subject ||= connector());
+      subscriber.add(() => {
+        refCount--;
+        if (refCount === 0 && !hasErrored && !hasCompleted) {
+          resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero, environment);
+        }
       });
-      Observable.from(source).subscribe(connection);
-    }
-  });
+      dest.provideEnvironment(environment).subscribe(subscriber);
+      if (!connection) {
+        connection = new SafeSubscriber({
+          next: (value) => dest.next(value),
+          error: (defect) => {
+            hasErrored = true;
+            cancelReset();
+            resetConnection = handleReset(reset, resetOnDefect, environment, defect);
+            dest.error(defect);
+          },
+          complete: () => {
+            hasCompleted = true;
+            cancelReset();
+            resetConnection = handleReset(reset, resetOnComplete, environment);
+            dest.complete();
+          },
+        });
+        Observable.from(source).provideEnvironment(environment).subscribe(connection);
+      }
+    });
+  };
 }
 
 function handleReset<T extends unknown[] = never[]>(
   reset: () => void,
   on: boolean | ((...args: T) => Observable<any, any, any>),
+  environment: Environment<any>,
   ...args: T
 ): Subscription | null {
   if (on === true) {
     reset();
     return null;
   }
-
   if (on === false) {
     return null;
   }
-
   return on(...args)
     .take(1)
+    .provideEnvironment(environment)
     .subscribe({ next: () => reset() });
 }