@fncts/observable 0.0.8 → 0.0.10

package/_src/Observable/api/window.ts

@@ -1,44 +1,39 @@
 /**
- * @tsplus fluent fncts.observable.Observable window
+ * @tsplus pipeable fncts.observable.Observable window
  */
-export function window_<R, E, A>(
-  fa: Observable<R, E, A>,
-  windowBoundaries: Observable<never, never, any>,
-): Observable<R, E, Observable<never, E, A>> {
-  return operate_(fa, (source, subscriber) => {
-    let windowSubject: Subject<never, E, A> = new Subject();
-    subscriber.next(windowSubject.asObservable());
-
-    const errorHandler = (err: Cause<E>) => {
-      windowSubject.error(err);
-      subscriber.error(err);
-    };
-
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => windowSubject.next(value),
-        error: errorHandler,
-        complete: () => {
-          windowSubject.complete();
-          subscriber.complete();
-        },
-      }),
-    );
-
-    windowBoundaries.subscribe(
-      operatorSubscriber(subscriber, {
-        next: () => {
-          windowSubject.complete();
-          subscriber.next((windowSubject = new Subject()));
-        },
-        complete: noop,
-        error: errorHandler,
-      }),
-    );
-
-    return () => {
-      windowSubject.unsubscribe();
-      windowSubject = null!;
-    };
-  });
+export function window(windowBoundaries: Observable<never, never, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
+    return fa.operate((source, subscriber, environment) => {
+      let windowSubject: Subject<never, E, A> = new Subject();
+      subscriber.next(windowSubject.asObservable());
+      const errorHandler = (err: Cause<E>) => {
+        windowSubject.error(err);
+        subscriber.error(err);
+      };
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => windowSubject.next(value),
+          error: errorHandler,
+          complete: () => {
+            windowSubject.complete();
+            subscriber.complete();
+          },
+        }),
+      );
+      windowBoundaries.subscribe(
+        operatorSubscriber(subscriber, {
+          next: () => {
+            windowSubject.complete();
+            subscriber.next((windowSubject = new Subject()));
+          },
+          complete: noop,
+          error: errorHandler,
+        }),
+      );
+      return () => {
+        windowSubject.unsubscribe();
+        windowSubject = null!;
+      };
+    });
+  };
 }

package/_src/Observable/api/windowCount.ts

@@ -1,56 +1,49 @@
 /**
- * @tsplus fluent fncts.observable.Observable windowCount
+ * @tsplus pipeable fncts.observable.Observable windowCount
  */
-export function windowCount_<R, E, A>(
-  fa: Observable<R, E, A>,
-  windowSize: number,
-  startWindowEvery = 0,
-): Observable<R, E, Observable<never, E, A>> {
-  const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
-
-  return operate_(fa, (source, subscriber) => {
-    let windows = [new Subject<never, E, A>()];
-    let count   = 0;
-
-    subscriber.next(windows[0]!.asObservable());
-
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            for (const window of windows) {
-              window.next(value);
-            }
-
-            const c = count - windowSize + 1;
-            if (c >= 0 && c % startEvery === 0) {
-              windows.shift()!.complete();
-            }
-
-            if (++count && startEvery === 0) {
-              const window = new Subject<never, E, A>();
-              windows.push(window);
-              subscriber.next(window.asObservable());
-            }
+export function windowCount(windowSize: number, startWindowEvery = 0) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
+    const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
+    return fa.operate((source, subscriber, environment) => {
+      let windows = [new Subject<never, E, A>()];
+      let count   = 0;
+      subscriber.next(windows[0]!.asObservable());
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              for (const window of windows) {
+                window.next(value);
+              }
+              const c = count - windowSize + 1;
+              if (c >= 0 && c % startEvery === 0) {
+                windows.shift()!.complete();
+              }
+              if (++count && startEvery === 0) {
+                const window = new Subject<never, E, A>();
+                windows.push(window);
+                subscriber.next(window.asObservable());
+              }
+            },
+            complete: () => {
+              while (windows.length > 0) {
+                windows.shift()!.complete();
+              }
+              subscriber.complete();
+            },
+            error: (err) => {
+              while (windows.length > 0) {
+                windows.shift()!.error(err);
+              }
+              subscriber.error(err);
+            },
           },
-          complete: () => {
-            while (windows.length > 0) {
-              windows.shift()!.complete();
-            }
-            subscriber.complete();
+          () => {
+            windows = null!;
           },
-          error: (err) => {
-            while (windows.length > 0) {
-              windows.shift()!.error(err);
-            }
-            subscriber.error(err);
-          },
-        },
-        () => {
-          windows = null!;
-        },
-      ),
-    );
-  });
+        ),
+      );
+    });
+  };
 }

package/_src/Observable/api/windowTime.ts

@@ -8,95 +8,83 @@ interface WindowRecord<R, E, A> {
 }
 
 /**
- * @tsplus fluent fncts.observable.Observable windowTime
+ * @tsplus pipeable fncts.observable.Observable windowTime
  */
-export function windowTime_<R, E, A>(
-  fa: Observable<R, E, A>,
+export function windowTime(
   windowTimeSpan: number,
   scheduler?: SchedulerLike,
-): Observable<R, E, Observable<never, E, A>>;
-export function windowTime_<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, Observable<never, E, A>>;
+export function windowTime(
   windowTimeSpan: number,
   windowCreationInterval: number,
   scheduler?: SchedulerLike,
-): Observable<R, E, Observable<never, E, A>>;
-export function windowTime_<R, E, A>(
-  fa: Observable<R, E, A>,
+): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, Observable<never, E, A>>;
+export function windowTime(
   windowTimeSpan: number,
   windowCreationInterval: number,
   maxWindowSize: number,
   scheduler?: SchedulerLike,
-): Observable<R, E, Observable<never, E, A>>;
-export function windowTime_<R, E, A>(
-  fa: Observable<R, E, A>,
-  windowTimeSpan: number,
-  ...args: any[]
-): Observable<R, E, Observable<never, E, A>> {
-  const scheduler = popScheduler(args) ?? asyncScheduler;
-  const windowCreationInterval: number | null = args[0] ?? null;
-  const maxWindowSize: number                 = args[1] || Infinity;
-
-  return operate_(fa, (source, subscriber) => {
-    let windowRecords: WindowRecord<never, E, A>[] | null = [];
-    let restartOnClose = false;
-    const closeWindow  = (record: { window: Subject<never, E, A>; subs: Subscription }) => {
-      const { window, subs } = record;
-      window.complete();
-      subs.unsubscribe();
-      arrayRemove(windowRecords, record);
-      restartOnClose && startWindow();
-    };
-    const startWindow = () => {
-      if (windowRecords) {
-        const subs = new Subscription();
-        subscriber.add(subs);
-        const window = new Subject<never, E, A>();
-        const record = {
-          window,
-          subs,
-          seen: 0,
-        };
-        windowRecords.push(record);
-        subscriber.next(window.asObservable());
-        subs.add(scheduler.schedule(() => closeWindow(record), windowTimeSpan));
-      }
-    };
-
-    windowCreationInterval !== null && windowCreationInterval >= 0
-      ? subscriber.add(
-          scheduler.schedule(function () {
-            startWindow();
-            !this.closed && subscriber.add(this.schedule(null, windowCreationInterval));
-          }, windowCreationInterval),
-        )
-      : (restartOnClose = true);
-
-    startWindow();
-
-    const loop = (cb: (record: WindowRecord<never, E, A>) => void) => windowRecords!.slice().forEach(cb);
-
-    const terminate = (cb: (consumer: Observer<E, any>) => void) => {
-      loop(({ window }) => cb(window));
-      cb(subscriber);
-      subscriber.unsubscribe();
-    };
-
-    source.subscribe(
-      operatorSubscriber(subscriber, {
-        next: (value) => {
-          loop((record) => {
-            record.window.next(value);
-            maxWindowSize <= ++record.seen && closeWindow(record);
-          });
-        },
-        error: (err) => terminate((consumer) => consumer.error(err)),
-        complete: () => terminate((consumer) => consumer.complete()),
-      }),
-    );
-
-    return () => {
-      windowRecords = null!;
-    };
-  });
+): <R, E, A>(fa: Observable<R, E, A>) => Observable<R, E, Observable<never, E, A>>;
+export function windowTime(windowTimeSpan: number, ...args: any[]) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
+    const scheduler = popScheduler(args) ?? asyncScheduler;
+    const windowCreationInterval: number | null = args[0] ?? null;
+    const maxWindowSize: number                 = args[1] || Infinity;
+    return fa.operate((source, subscriber, environment) => {
+      let windowRecords: WindowRecord<never, E, A>[] | null = [];
+      let restartOnClose = false;
+      const closeWindow  = (record: { window: Subject<never, E, A>; subs: Subscription }) => {
+        const { window, subs } = record;
+        window.complete();
+        subs.unsubscribe();
+        arrayRemove(windowRecords, record);
+        restartOnClose && startWindow();
+      };
+      const startWindow = () => {
+        if (windowRecords) {
+          const subs = new Subscription();
+          subscriber.add(subs);
+          const window = new Subject<never, E, A>();
+          const record = {
+            window,
+            subs,
+            seen: 0,
+          };
+          windowRecords.push(record);
+          subscriber.next(window.asObservable());
+          subs.add(scheduler.schedule(() => closeWindow(record), windowTimeSpan));
+        }
+      };
+      windowCreationInterval !== null && windowCreationInterval >= 0
+        ? subscriber.add(
+            scheduler.schedule(function () {
+              startWindow();
+              !this.closed && subscriber.add(this.schedule(null, windowCreationInterval));
+            }, windowCreationInterval),
+          )
+        : (restartOnClose = true);
+      startWindow();
+      const loop      = (cb: (record: WindowRecord<never, E, A>) => void) => windowRecords!.slice().forEach(cb);
+      const terminate = (cb: (consumer: Observer<E, any>) => void) => {
+        loop(({ window }) => cb(window));
+        cb(subscriber);
+        subscriber.unsubscribe();
+      };
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(subscriber, {
+          next: (value) => {
+            loop((record) => {
+              record.window.next(value);
+              maxWindowSize <= ++record.seen && closeWindow(record);
+            });
+          },
+          error: (err) => terminate((consumer) => consumer.error(err)),
+          complete: () => terminate((consumer) => consumer.complete()),
+        }),
+      );
+      return () => {
+        windowRecords = null!;
+      };
+    });
+  };
 }

package/_src/Observable/api/windowToggle.ts

@@ -1,84 +1,80 @@
 import { arrayRemove } from "@fncts/observable/internal/util";
 
 /**
- * @tsplus fluent fncts.observable.Observable windowToggle
+ * @tsplus pipeable fncts.observable.Observable windowToggle
  */
-export function windowToggle_<R, E, A, R1, E1, B, R2, E2>(
-  fa: Observable<R, E, A>,
+export function windowToggle<R1, E1, B, R2, E2>(
   openings: ObservableInput<R1, E1, B>,
   closingSelector: (openValue: B) => ObservableInput<R2, E2, any>,
-): Observable<R | R1 | R2, E | E1 | E2, Observable<never, E, A>> {
-  return operate_(fa, (source, subscriber) => {
-    const windows: Subject<never, E, A>[] = [];
-
-    const handleError = (err: Cause<E>) => {
-      while (0 < windows.length) {
-        windows.shift()!.error(err);
-      }
-      subscriber.error(err);
-    };
-
-    Observable.from(openings).subscribe(
-      operatorSubscriber(subscriber, {
-        next: (openValue) => {
-          const window = new Subject<never, E, A>();
-          windows.push(window);
-          const closingSubscription = new Subscription();
-          const closeWindow         = () => {
-            arrayRemove(windows, window);
-            window.complete();
-            closingSubscription.unsubscribe();
-          };
-
-          let closingNotifier: Observable<R2, E2, any>;
-
-          try {
-            closingNotifier = Observable.from(closingSelector(openValue));
-          } catch (err) {
-            handleError(Cause.halt(err));
-            return;
-          }
-
-          subscriber.next(window.asObservable());
-
-          closingSubscription.add(
-            closingNotifier.subscribe(
-              operatorSubscriber(subscriber, {
-                next: closeWindow,
-                complete: noop,
-                error: closeWindow,
-              }),
-            ),
-          );
-        },
-        complete: noop,
-      }),
-    );
-
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => {
-            const windowsCopy = windows.slice();
-            for (const window of windowsCopy) {
-              window.next(value);
-            }
+) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R | R1 | R2, E | E1 | E2, Observable<never, E, A>> => {
+    return fa.operate((source, subscriber, environment) => {
+      const windows: Subject<never, E, A>[] = [];
+      const handleError                     = (err: Cause<E>) => {
+        while (0 < windows.length) {
+          windows.shift()!.error(err);
+        }
+        subscriber.error(err);
+      };
+      Observable.from(openings)
+        .provideEnvironment(environment)
+        .subscribe(
+          operatorSubscriber(subscriber, {
+            next: (openValue) => {
+              const window = new Subject<never, E, A>();
+              windows.push(window);
+              const closingSubscription = new Subscription();
+              const closeWindow         = () => {
+                arrayRemove(windows, window);
+                window.complete();
+                closingSubscription.unsubscribe();
+              };
+              let closingNotifier: Observable<R2, E2, any>;
+              try {
+                closingNotifier = Observable.from(closingSelector(openValue));
+              } catch (err) {
+                handleError(Cause.halt(err));
+                return;
+              }
+              subscriber.next(window.asObservable());
+              closingSubscription.add(
+                closingNotifier.provideEnvironment(environment).subscribe(
+                  operatorSubscriber(subscriber, {
+                    next: closeWindow,
+                    complete: noop,
+                    error: closeWindow,
+                  }),
+                ),
+              );
+            },
+            complete: noop,
+          }),
+        );
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => {
+              const windowsCopy = windows.slice();
+              for (const window of windowsCopy) {
+                window.next(value);
+              }
+            },
+            error: handleError,
+            complete: () => {
+              while (0 < windows.length) {
+                windows.shift()!.complete();
+              }
+              subscriber.complete();
+            },
           },
-          error: handleError,
-          complete: () => {
+          () => {
             while (0 < windows.length) {
-              windows.shift()!.complete();
+              windows.shift()!.unsubscribe();
             }
-            subscriber.complete();
           },
-        },
-        () => {
-          while (0 < windows.length) {
-            windows.shift()!.unsubscribe();
-          }
-        },
-      ),
-    );
-  });
+        ),
+      );
+    });
+  };
 }

package/_src/Observable/api/windowWhen.ts

@@ -1,59 +1,53 @@
 /**
- * @tsplus fluent fncts.observable.Observable windowWhen
+ * @tsplus pipeable fncts.observable.Observable windowWhen
  */
-export function windowWhen_<R, E, A>(
-  fa: Observable<R, E, A>,
-  closingSelector: () => ObservableInput<never, never, any>,
-): Observable<R, E, Observable<never, E, A>> {
-  return operate_(fa, (source, subscriber) => {
-    let window: Subject<never, E, A> | null;
-    let closingSubscriber: Subscriber<E, any> | undefined;
-
-    const handleError = (err: Cause<E>) => {
-      window!.error(err);
-      subscriber.error(err);
-    };
-
-    const openWindow = () => {
-      closingSubscriber?.unsubscribe();
-      window?.complete();
-      window = new Subject();
-      subscriber.next(window.asObservable());
-      let closingNotifier: Observable<never, never, any>;
-      try {
-        closingNotifier = Observable.from(closingSelector());
-      } catch (err) {
-        handleError(Cause.halt(err));
-        return;
-      }
-
-      closingNotifier.subscribe(
-        (closingSubscriber = operatorSubscriber(subscriber, {
-          next: openWindow,
-          complete: openWindow,
-          error: handleError,
-        })),
-      );
-    };
-
-    openWindow();
-
-    source.subscribe(
-      operatorSubscriber(
-        subscriber,
-        {
-          next: (value) => window!.next(value),
-          error: handleError,
-          complete: () => {
-            window!.complete();
-            subscriber.complete();
+export function windowWhen(closingSelector: () => ObservableInput<never, never, any>) {
+  return <R, E, A>(fa: Observable<R, E, A>): Observable<R, E, Observable<never, E, A>> => {
+    return fa.operate((source, subscriber, environment) => {
+      let window: Subject<never, E, A> | null;
+      let closingSubscriber: Subscriber<E, any> | undefined;
+      const handleError = (err: Cause<E>) => {
+        window!.error(err);
+        subscriber.error(err);
+      };
+      const openWindow = () => {
+        closingSubscriber?.unsubscribe();
+        window?.complete();
+        window = new Subject();
+        subscriber.next(window.asObservable());
+        let closingNotifier: Observable<never, never, any>;
+        try {
+          closingNotifier = Observable.from(closingSelector());
+        } catch (err) {
+          handleError(Cause.halt(err));
+          return;
+        }
+        closingNotifier.subscribe(
+          (closingSubscriber = operatorSubscriber(subscriber, {
+            next: openWindow,
+            complete: openWindow,
+            error: handleError,
+          })),
+        );
+      };
+      openWindow();
+      source.provideEnvironment(environment).subscribe(
+        operatorSubscriber(
+          subscriber,
+          {
+            next: (value) => window!.next(value),
+            error: handleError,
+            complete: () => {
+              window!.complete();
+              subscriber.complete();
+            },
+          },
+          () => {
+            closingSubscriber?.unsubscribe();
+            window = null!;
           },
-        },
-        () => {
-          closingSubscriber?.unsubscribe();
-          window = null!;
-        },
-      ),
-    );
-  });
+        ),
+      );
+    });
+  };
 }