@fncts/observable 0.0.1

package/_src/Observable/api/share.ts

@@ -0,0 +1,107 @@
+export interface ShareConfig<E, A, E1 = never, E2 = never, E3 = never> {
+  readonly connector?: () => SubjectLike<E, A>;
+  readonly resetOnDefect?: boolean | ((err: unknown) => Observable<E1, any>);
+  readonly resetOnComplete?: boolean | (() => Observable<E2, any>);
+  readonly resetOnRefCountZero?: boolean | (() => Observable<E3, any>);
+}
+
+/**
+ * @tsplus fluent fncts.observable.Observable share
+ */
+export function share_<E, A, E1 = never, E2 = never, E3 = never>(
+  fa: Observable<E, A>,
+  options: ShareConfig<E, A, E1, E2, E3> = {},
+): Observable<E | E1 | E2 | E3, A> {
+  const {
+    connector = () => new Subject<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) {
+      cancelReset();
+    }
+
+    const dest = (subject ||= connector());
+
+    subscriber.add(() => {
+      refCount--;
+      if (refCount === 0 && !hasErrored && !hasCompleted) {
+        resetConnection = handleReset(resetAndUnsubscribe, resetOnRefCountZero);
+      }
+    });
+
+    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();
+        },
+      });
+      Observable.from(source).subscribe(connection);
+    }
+  });
+}
+
+export function share<E, A, E1, E2, E3>(
+  options: ShareConfig<E, A, E1, E2, E3> = {},
+): (fa: Observable<E, A>) => Observable<E | E1 | E2 | E3, A> {
+  return (fa) => share_(fa, options);
+}
+
+function handleReset<T extends unknown[] = never[]>(
+  reset: () => void,
+  on: boolean | ((...args: T) => Observable<any, any>),
+  ...args: T
+): Subscription | null {
+  if (on === true) {
+    reset();
+    return null;
+  }
+
+  if (on === false) {
+    return null;
+  }
+
+  return on(...args)
+    .take(1)
+    .subscribe({ next: () => reset() });
+}

package/_src/Observable/api/window.ts

@@ -0,0 +1,44 @@
+/**
+ * @tsplus fluent fncts.observable.Observable window
+ */
+export function window_<E, A>(
+  fa: Observable<E, A>,
+  windowBoundaries: Observable<never, any>,
+): Observable<E, Observable<E, A>> {
+  return operate_(fa, (source, subscriber) => {
+    let windowSubject: Subject<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!;
+    };
+  });
+}

package/_src/Observable/api/windowCount.ts

@@ -0,0 +1,56 @@
+/**
+ * @tsplus fluent fncts.observable.Observable windowCount
+ */
+export function windowCount_<E, A>(
+  fa: Observable<E, A>,
+  windowSize: number,
+  startWindowEvery = 0,
+): Observable<E, Observable<E, A>> {
+  const startEvery = startWindowEvery > 0 ? startWindowEvery : windowSize;
+
+  return operate_(fa, (source, subscriber) => {
+    let windows = [new Subject<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<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);
+          },
+        },
+        () => {
+          windows = null!;
+        },
+      ),
+    );
+  });
+}

package/_src/Observable/api/windowTime.ts

@@ -0,0 +1,102 @@
+import { popScheduler } from "@fncts/observable/internal/args";
+import { arrayRemove } from "@fncts/observable/internal/util";
+
+interface WindowRecord<E, A> {
+  seen: number;
+  window: Subject<E, A>;
+  subs: Subscription;
+}
+
+/**
+ * @tsplus fluent fncts.observable.Observable windowTime
+ */
+export function windowTime_<E, A>(
+  fa: Observable<E, A>,
+  windowTimeSpan: number,
+  scheduler?: SchedulerLike,
+): Observable<E, Observable<E, A>>;
+export function windowTime_<E, A>(
+  fa: Observable<E, A>,
+  windowTimeSpan: number,
+  windowCreationInterval: number,
+  scheduler?: SchedulerLike,
+): Observable<E, Observable<E, A>>;
+export function windowTime_<E, A>(
+  fa: Observable<E, A>,
+  windowTimeSpan: number,
+  windowCreationInterval: number,
+  maxWindowSize: number,
+  scheduler?: SchedulerLike,
+): Observable<E, Observable<E, A>>;
+export function windowTime_<E, A>(
+  fa: Observable<E, A>,
+  windowTimeSpan: number,
+  ...args: any[]
+): Observable<E, Observable<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<E, A>[] | null = [];
+    let restartOnClose = false;
+    const closeWindow  = (record: { window: Subject<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<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<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!;
+    };
+  });
+}

package/_src/Observable/api/windowToggle.ts

@@ -0,0 +1,84 @@
+import { arrayRemove } from "@fncts/observable/internal/util";
+
+/**
+ * @tsplus fluent fncts.observable.Observable windowToggle
+ */
+export function windowToggle_<E, A, E1, B, E2>(
+  fa: Observable<E, A>,
+  openings: ObservableInput<E1, B>,
+  closingSelector: (openValue: B) => ObservableInput<E2, any>,
+): Observable<E | E1 | E2, Observable<E, A>> {
+  return operate_(fa, (source, subscriber) => {
+    const windows: Subject<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<E, A>();
+          windows.push(window);
+          const closingSubscription = new Subscription();
+          const closeWindow         = () => {
+            arrayRemove(windows, window);
+            window.complete();
+            closingSubscription.unsubscribe();
+          };
+
+          let closingNotifier: Observable<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);
+            }
+          },
+          error: handleError,
+          complete: () => {
+            while (0 < windows.length) {
+              windows.shift()!.complete();
+            }
+            subscriber.complete();
+          },
+        },
+        () => {
+          while (0 < windows.length) {
+            windows.shift()!.unsubscribe();
+          }
+        },
+      ),
+    );
+  });
+}

package/_src/Observable/api/windowWhen.ts

@@ -0,0 +1,59 @@
+/**
+ * @tsplus fluent fncts.observable.Observable windowWhen
+ */
+export function windowWhen_<E, A>(
+  fa: Observable<E, A>,
+  closingSelector: () => ObservableInput<never, any>,
+): Observable<E, Observable<E, A>> {
+  return operate_(fa, (source, subscriber) => {
+    let window: Subject<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, 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();
+          },
+        },
+        () => {
+          closingSubscriber?.unsubscribe();
+          window = null!;
+        },
+      ),
+    );
+  });
+}