@fncts/observable 0.0.1

package/_src/AnimationFrameScheduler.ts

@@ -0,0 +1,30 @@
+/* eslint-disable no-param-reassign */
+export class AnimationFrameScheduler extends AsyncScheduler {
+  public flush(action?: AsyncAction<any>): void {
+    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();
+      }
+      throw error;
+    }
+  }
+}
+
+export const animationFrameScheduler = new AnimationFrameScheduler(AnimationFrameAction);

package/_src/AsyncAction.ts

@@ -0,0 +1,93 @@
+import { intervalProvider } from "@fncts/observable/internal/intervalProvider";
+import { arrayRemove } from "@fncts/observable/internal/util";
+
+export class AsyncAction<A> extends Action<A> {
+  public id: any;
+  public state?: A;
+  public delay: number | undefined;
+  protected pending = false;
+
+  constructor(protected scheduler: AsyncScheduler, protected work: (this: SchedulerAction<A>, state?: A) => void) {
+    super(scheduler, work);
+  }
+
+  schedule(state?: A, delay = 0): Subscription {
+    if (this.closed) {
+      return this;
+    }
+
+    this.state = state;
+
+    const id        = this.id;
+    const scheduler = this.scheduler;
+
+    if (id != null) {
+      this.id = this.recycleAsyncId(scheduler, id, delay);
+    }
+
+    this.pending = true;
+    this.delay   = delay;
+    this.id      = this.id || this.requestAsyncId(scheduler, this.id, delay);
+
+    return this;
+  }
+
+  protected requestAsyncId(scheduler: AsyncScheduler, _id: any, delay = 0): any {
+    return intervalProvider.setInterval(scheduler.flush.bind(scheduler, this), delay);
+  }
+
+  protected recycleAsyncId(_scheduler: AsyncScheduler, id: any, delay: number | null = 0): any {
+    if (delay != null && this.delay === delay && this.pending === false) {
+      return id;
+    }
+    intervalProvider.clearInterval(id);
+    return undefined;
+  }
+
+  public execute(state: A, delay: number): unknown {
+    if (this.closed) {
+      throw new Error("executing a cancelled action");
+    }
+
+    this.pending = false;
+    const error  = this.executeInternal(state, delay);
+    if (error) {
+      return error;
+    } else if (this.pending === false && this.id != null) {
+      this.id = this.recycleAsyncId(this.scheduler, this.id, null);
+    }
+  }
+
+  protected executeInternal(state: A, _delay: number): unknown {
+    let errored = false;
+    let errorValue: unknown;
+    try {
+      this.work(state);
+    } catch (e) {
+      errored    = true;
+      errorValue = e ? e : new Error("Scheduled action threw falsy error");
+    }
+    if (errored) {
+      this.unsubscribe();
+      return errorValue;
+    }
+  }
+
+  unsubscribe() {
+    if (!this.closed) {
+      const { id, scheduler } = this;
+      const { actions }       = scheduler;
+
+      this.work    = this.state = this.scheduler = null!;
+      this.pending = false;
+
+      arrayRemove(actions, this);
+      if (id != null) {
+        this.id = this.recycleAsyncId(scheduler, id, null);
+      }
+
+      this.delay = null!;
+      super.unsubscribe();
+    }
+  }
+}

package/_src/AsyncScheduler.ts

@@ -0,0 +1,41 @@
+export class AsyncScheduler extends Scheduler {
+  public actions: Array<AsyncAction<any>> = [];
+
+  active         = false;
+  scheduled: any = undefined;
+
+  constructor(actionConstructor: typeof Action, now: () => number = Scheduler.now) {
+    super(actionConstructor, now);
+  }
+
+  flush(action: AsyncAction<any>) {
+    const { actions } = this;
+
+    if (this.active) {
+      actions.push(action);
+      return;
+    }
+
+    let error: unknown;
+    this.active = true;
+
+    do {
+      if ((error = action.execute(action.state, action.delay!))) {
+        break;
+      }
+      // eslint-disable-next-line no-param-reassign
+    } while ((action = actions.shift()!));
+
+    this.active = false;
+
+    if (error) {
+      // eslint-disable-next-line no-param-reassign
+      while ((action = actions.shift()!)) {
+        action.unsubscribe();
+      }
+      throw error;
+    }
+  }
+}
+
+export const asyncScheduler = new AsyncScheduler(AsyncAction);

package/_src/BehaviorSubject.ts

@@ -0,0 +1,28 @@
+export class BehaviorSubject<E, A> extends Subject<E, A> {
+  constructor(private _value: A) {
+    super();
+  }
+
+  get value(): A {
+    return this.getValue();
+  }
+
+  getValue(): A {
+    const { hasError, thrownError, _value } = this;
+    if (hasError) {
+      throw thrownError;
+    }
+    this.throwIfClosed();
+    return _value;
+  }
+
+  protected subscribeInternal(subscriber: Subscriber<E, A>) {
+    const subscription = super.subscribe(subscriber);
+    !subscription.closed && subscriber.next(this._value);
+    return subscription;
+  }
+
+  next(value: A): void {
+    super.next((this._value = value));
+  }
+}

package/_src/Notification.ts

@@ -0,0 +1,91 @@
+export const NextTypeId = Symbol.for("fncts.observable.Notification.Next");
+export type NextTypeId = typeof NextTypeId;
+
+export class Next<A> {
+  readonly _tag                     = "Next";
+  readonly [NextTypeId]: NextTypeId = NextTypeId;
+  constructor(readonly value: A) {}
+}
+
+export const FailTypeId = Symbol.for("fncts.observable.Notification.Fail");
+export type FailTypeId = typeof FailTypeId;
+
+export class Fail<E> {
+  readonly _tag                     = "Fail";
+  readonly [FailTypeId]: FailTypeId = FailTypeId;
+  constructor(readonly error: Cause<E>) {}
+}
+
+export const CompleteTypeId = Symbol.for("fncts.observable.Notification.Complete");
+export type CompleteTypeId = typeof CompleteTypeId;
+
+export class Complete {
+  readonly _tag = "Complete";
+  readonly [CompleteTypeId]: CompleteTypeId = CompleteTypeId;
+}
+
+const COMPLETE = new Complete();
+
+/**
+ * @tsplus type fncts.observable.Notification
+ */
+export type Notification<E, A> = Next<A> | Fail<E> | Complete;
+
+/**
+ * @tsplus type fncts.observable.NotificationOps
+ */
+export interface NotificationOps {}
+
+export const Notification: NotificationOps = {};
+
+/**
+ * @tsplus static fncts.observable.NotificationOps next
+ */
+export function next<E = never, A = never>(value: A): Notification<E, A> {
+  return new Next(value);
+}
+
+/**
+ * @tsplus static fncts.observable.NotificationOps error
+ */
+export function error<E = never, A = never>(error: Cause<E>): Notification<E, A> {
+  return new Fail(error);
+}
+
+/**
+ * @tsplus static fncts.observable.NotificationOps complete
+ */
+export function complete<E = never, A = never>(): Notification<E, A> {
+  return COMPLETE;
+}
+
+/**
+ * @tsplus fluent 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();
+  }
+}
+
+/**
+ * @tsplus fluent 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?.(),
+  );
+}

package/_src/Observable/api/connect.ts

@@ -0,0 +1,23 @@
+export interface ConnectConfig<E, A> {
+  readonly connector: () => SubjectLike<E, A>;
+}
+
+const DEFAULT_CONNECT_CONFIG: ConnectConfig<any, any> = {
+  connector: () => new Subject(),
+};
+
+/**
+ * @tsplus fluent fncts.observable.Observable connect
+ */
+export function connect<E, A, E1, B>(
+  fa: Observable<E, A>,
+  selector: (shared: Observable<E, A>) => ObservableInput<E1, B>,
+  config: ConnectConfig<E, A> = DEFAULT_CONNECT_CONFIG,
+): Observable<E | E1, B> {
+  const { connector } = config;
+  return operate_(fa, (source, subscriber) => {
+    const subject = connector();
+    Observable.from(selector(Observable.fromSubscribable(subject))).subscribe(subscriber);
+    subscriber.add(source.subscribe(subject));
+  });
+}

package/_src/Observable/api/connectable.ts

@@ -0,0 +1,52 @@
+export interface ConnectableLike<E, A> extends Observable<E, A> {
+  connect(): Subscription;
+}
+
+export interface ConnectableConfig<E, A> {
+  readonly connector: () => SubjectLike<E, A>;
+  readonly resetOnDisconnect?: boolean;
+}
+
+const DEFAULT_CONFIG: ConnectableConfig<any, any> = {
+  connector: () => new Subject(),
+  resetOnDisconnect: false,
+};
+
+export class Connectable<E, A> extends Observable<E, A> implements ConnectableLike<E, A> {
+  protected connection: Subscription | null;
+  protected connector: () => SubjectLike<E, A>;
+  protected resetOnDisconnect: boolean;
+  protected source: Observable<E, A>;
+  protected subject: SubjectLike<E, A>;
+  constructor(source: ObservableInput<E, A>, config: ConnectableConfig<E, A>) {
+    const { connector, resetOnDisconnect = true } = config;
+    const subject = connector();
+    super((subscriber) => {
+      return subject.subscribe(subscriber);
+    });
+    this.connection        = null;
+    this.subject           = subject;
+    this.connector         = connector;
+    this.resetOnDisconnect = resetOnDisconnect;
+    this.source            = Observable.from(source);
+  }
+  connect() {
+    if (!this.connection || this.connection.closed) {
+      this.connection = Observable.defer(this.source).subscribe(this.subject);
+      if (this.resetOnDisconnect) {
+        this.connection.add(() => (this.subject = this.connector()));
+      }
+    }
+    return this.connection;
+  }
+}
+
+/**
+ * @tsplus fluent fncts.observable.Observable connectable
+ */
+export function connectable<E, A>(
+  source: ObservableInput<E, A>,
+  config: ConnectableConfig<E, A> = DEFAULT_CONFIG,
+): Connectable<E, A> {
+  return new Connectable(source, config);
+}

package/_src/Observable/api/fromCallback.ts

@@ -0,0 +1,57 @@
+/**
+ * @tsplus static fncts.observable.ObservableOps fromCallback
+ */
+export function fromCallback<A extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown>>(
+  callbackFunc: (...args: [...A, (...res: R) => void]) => void,
+): (...args: A) => Observable<unknown, R> {
+  // @ts-expect-error
+  return fromCallbackInternal(false, callbackFunc);
+}
+
+/**
+ * @tsplus static fncts.observable.ObservableOps fromNodeCallback
+ */
+export function fromNodeCallback<E, A extends ReadonlyArray<unknown>, R extends ReadonlyArray<unknown>>(
+  callbackFunc: (...args: [...A, (err: E, ...res: R) => void]) => void,
+): (...args: A) => Observable<Exclude<E, null | undefined>, R extends [] ? void : R extends [any] ? R[0] : R> {
+  // @ts-expect-error
+  return fromCallbackInternal(true, callbackFunc);
+}
+
+function fromCallbackInternal(isNodeStyle: boolean, callbackFunc: any): (...args: any[]) => Observable<unknown, any> {
+  return function (this: any, ...args: any[]): Observable<unknown, any> {
+    const subject     = new AsyncSubject<any, any>();
+    let uninitialized = true;
+    return new Observable((subscriber) => {
+      const subs = subject.subscribe(subscriber);
+      if (uninitialized) {
+        uninitialized  = false;
+        let isAsync    = false;
+        let isComplete = false;
+        callbackFunc.apply(this, [
+          ...args,
+          (...results: any[]) => {
+            if (isNodeStyle) {
+              const err = results.shift();
+              if (err != null) {
+                subject.error(err);
+                return;
+              }
+            }
+            subject.next(1 < results.length ? results : results[0]);
+            isComplete = true;
+            if (isAsync) {
+              subject.complete();
+            }
+          },
+        ]);
+        if (isComplete) {
+          subject.complete();
+        }
+
+        isAsync = true;
+      }
+      return subs;
+    });
+  };
+}

package/_src/Observable/api/fromEvent.ts

@@ -0,0 +1,12 @@
+type EventHandler = (...args: any[]) => void;
+
+export function fromEvent<A extends ReadonlyArray<unknown>>(
+  addHandler: (handler: (...args: A) => void) => any,
+  removeHandler?: (handler: EventHandler, signal?: any) => void,
+): Observable<never, A extends [infer X] ? X : A> {
+  return new Observable((subscriber) => {
+    const handler  = (...e: any[]) => subscriber.next(e.length === 1 ? e[0] : e);
+    const retValue = addHandler(handler as any);
+    return removeHandler && (() => removeHandler(handler, retValue));
+  });
+}

package/_src/Observable/api/index.ts

@@ -0,0 +1,14 @@
+export * from "./connect.js";
+export * from "./connectable.js";
+export * from "./fromCallback.js";
+export * from "./fromEvent.js";
+export * from "./race.js";
+export * from "./raceWith.js";
+export * from "./repeatWhen.js";
+export * from "./retryWhen.js";
+export * from "./share.js";
+export * from "./window.js";
+export * from "./windowCount.js";
+export * from "./windowTime.js";
+export * from "./windowToggle.js";
+export * from "./windowWhen.js";

package/_src/Observable/api/race.ts

@@ -0,0 +1,31 @@
+/**
+ * @tsplus static fncts.observable.ObservableOps race
+ */
+export function race<O extends ReadonlyArray<ObservableInput<any, any>>>(
+  ...sources: O
+): Observable<Observable.ErrorOf<O[number]>, Observable.TypeOf<O[number]>> {
+  return sources.length === 1 ? Observable.from(sources[0]!) : new Observable(raceInit(sources));
+}
+
+export function raceInit<E, A>(sources: ReadonlyArray<ObservableInput<E, A>>) {
+  return (subscriber: Subscriber<E, A>) => {
+    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();
+                }
+                subscriptions = null!;
+              }
+              subscriber.next(value);
+            },
+          }),
+        ),
+      );
+    }
+  };
+}

package/_src/Observable/api/raceWith.ts

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

package/_src/Observable/api/repeatWhen.ts

@@ -0,0 +1,63 @@
+export function repeatWhen_<E, A, E1>(
+  fa: Observable<E, A>,
+  notifier: (notifications: Observable<never, void>) => Observable<E1, any>,
+): Observable<E | E1, A> {
+  return fa.operate((source, subscriber) => {
+    let innerSub: Subscription | null;
+    let syncResub = false;
+    let completions$: Subject<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(
+          operatorSubscriber(subscriber, {
+            next: () => {
+              if (innerSub) {
+                loop();
+              } else {
+                syncResub = true;
+              }
+            },
+            complete: () => {
+              isNotifierComplete = true;
+              checkComplete();
+            },
+          }),
+        );
+      }
+      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<E1>(
+  notifier: (notifications: Observable<never, void>) => Observable<E1, any>,
+): <E, A>(fa: Observable<E, A>) => Observable<E | E1, A> {
+  return (fa) => repeatWhen_(fa, notifier);
+}

package/_src/Observable/api/retryWhen.ts

@@ -0,0 +1,47 @@
+/**
+ * @tsplus fluent fncts.observable.Observable retryWhen
+ */
+export function retryWhen_<E, A, E1>(
+  fa: Observable<E, A>,
+  notifier: (errors: Observable<never, Cause<E>>) => Observable<E1, any>,
+): Observable<E | E1, A> {
+  return operate_(fa, (source, subscriber) => {
+    let innerSub: Subscription | null;
+    let syncResub = false;
+    let defects$: Subject<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<E1>(
+  notifier: (errors: Observable<never, any>) => Observable<E1, any>,
+): <E, A>(fa: Observable<E, A>) => Observable<E | E1, A> {
+  return (fa) => retryWhen_(fa, notifier);
+}