@fncts/observable 0.0.1

package/_src/Observable/definition.ts

@@ -0,0 +1,69 @@
+export declare namespace Observable {
+  export type TypeOf<X> = X extends ObservableInput<any, infer A> ? A : never;
+  export type ErrorOf<X> = X extends ObservableInput<infer E, any> ? E : never;
+}
+
+export const ObservableTypeId = Symbol.for("@principia/observable/Observable");
+export type ObservableTypeId = typeof ObservableTypeId;
+
+/**
+ * @tsplus type fncts.observable.Observable
+ * @tsplus companion fncts.observable.ObservableOps
+ */
+export class Observable<E, A> implements Subscribable<E, A> {
+  readonly _E!: () => E;
+  readonly _A!: () => A;
+
+  readonly [ObservableTypeId]: ObservableTypeId = ObservableTypeId;
+
+  protected source: Observable<any, any> | undefined;
+  protected operator: Operator<E, A> | undefined;
+
+  constructor(subscribe?: (this: Observable<E, A>, subscriber: Subscriber<E, A>) => Finalizer) {
+    if (subscribe) {
+      this.subscribeInternal = subscribe;
+    }
+  }
+
+  lift<E1, A1>(operator: Operator<E1, A1>): Observable<E1, A1> {
+    const observable    = new Observable<E1, A1>();
+    observable.source   = this;
+    observable.operator = operator;
+    return observable;
+  }
+
+  subscribe(observer?: Partial<Observer<E, A>>): Subscription;
+  subscribe(observer?: (value: A) => void): Subscription;
+  subscribe(observer?: Partial<Observer<E, A>> | ((value: A) => void)): Subscription {
+    const subscriber: Subscriber<E, A> = isSubscriber(observer) ? observer : new SafeSubscriber(observer);
+
+    subscriber.add(
+      this.operator
+        ? this.operator.call(subscriber, this.source)
+        : this.source
+        ? this.subscribeInternal(subscriber)
+        : this.trySubscribe(subscriber),
+    );
+
+    return subscriber;
+  }
+
+  protected trySubscribe(subscriber: Subscriber<E, A>): Finalizer {
+    try {
+      return this.subscribeInternal(subscriber);
+    } catch (err) {
+      subscriber.error(Cause.halt(err));
+      return noop;
+    }
+  }
+
+  protected subscribeInternal(subscriber: Subscriber<E, A>): Finalizer {
+    this.source?.subscribe(subscriber);
+  }
+}
+
+export const EMPTY: Observable<never, never> = new Observable((subscriber) => subscriber.complete());
+
+export function isObservable(u: unknown): u is Observable<unknown, unknown> {
+  return isObject(u) && ObservableTypeId in u;
+}

package/_src/Observable/dom/animationFrames.ts

@@ -0,0 +1,33 @@
+import { animationFrameProvider } from "@fncts/observable/internal/animationFrameProvider";
+import { performanceTimestampProvider } from "@fncts/observable/internal/performanceTimestampProvider";
+
+export function animationFrames(
+  timestampProvider?: TimestampProvider,
+): Observable<never, { timestamp: number; elapsed: number }> {
+  return timestampProvider ? animationFramesInternal(timestampProvider) : DEFAULT_ANIMATION_FRAMES;
+}
+
+function animationFramesInternal(
+  timestampProvider?: TimestampProvider,
+): Observable<never, { timestamp: number; elapsed: number }> {
+  const { schedule } = animationFrameProvider;
+  return new Observable((subscriber) => {
+    const subscription = new Subscription();
+    const provider     = timestampProvider || performanceTimestampProvider;
+    const start        = provider.now();
+    const run          = (timestamp: number) => {
+      const now = provider.now();
+      subscriber.next({
+        timestamp: timestampProvider ? now : timestamp,
+        elapsed: now - start,
+      });
+      if (!subscriber.closed) {
+        subscription.add(schedule(run));
+      }
+    };
+    subscription.add(schedule(run));
+    return subscription;
+  });
+}
+
+const DEFAULT_ANIMATION_FRAMES = animationFramesInternal();

package/_src/Observable/instances.ts

@@ -0,0 +1,106 @@
+// import type * as HKT from "@principia/base/HKT";
+
+// import * as P from "@principia/base/prelude";
+
+// import * as O from "./core.js";
+
+// export interface ObservableF extends HKT.HKT {
+//   readonly type: O.Observable<this["E"], this["A"]>;
+//   readonly index: number;
+//   readonly variance: {
+//     E: "+";
+//     A: "+";
+//   };
+// }
+
+// export const Functor: P.Functor<ObservableF> = P.Functor({
+//   map_: O.map_,
+// });
+
+// export const FunctorWithIndex: P.FunctorWithIndex<ObservableF> = P.FunctorWithIndex({
+//   imap_: O.mapWithIndex,
+// });
+
+// export const SemimonoidalFunctor: P.SemimonoidalFunctor<ObservableF> = P.SemimonoidalFunctor({
+//   map_: O.map_,
+//   cross_: O.cross_,
+//   crossWith_: O.crossWith_,
+// });
+
+// export const Apply: P.Apply<ObservableF> = P.Apply({
+//   map_: O.map_,
+//   cross_: O.cross_,
+//   crossWith_: O.crossWith_,
+//   ap_: O.ap_,
+// });
+
+// export const apS = P.apSF(Apply);
+
+// export const apT = P.apTF(Apply);
+
+// export const sequenceS = P.sequenceSF(Apply);
+
+// export const sequenceT = P.sequenceTF(Apply);
+
+// export const MonoidalFunctor: P.MonoidalFunctor<ObservableF> = P.MonoidalFunctor({
+//   map_: O.map_,
+//   cross_: O.cross_,
+//   crossWith_: O.crossWith_,
+//   unit: O.unit,
+// });
+
+// export const Applicative: P.Applicative<ObservableF> = P.Applicative({
+//   map_: O.map_,
+//   cross_: O.cross_,
+//   crossWith_: O.crossWith_,
+//   unit: O.unit,
+//   pure: O.pure,
+// });
+
+// export const Monad: P.Monad<ObservableF> = P.Monad({
+//   map_: O.map_,
+//   cross_: O.cross_,
+//   crossWith_: O.crossWith_,
+//   unit: O.unit,
+//   pure: O.pure,
+//   chain_: O.concatMap_,
+//   flatten: O.flatten,
+// });
+
+// const _do = O.pure({});
+
+// export { _do as do };
+
+// export const chainS_ = P.chainSF_(Monad);
+
+// export const chainS = P.chainSF(Monad);
+
+// export const pureS_ = P.pureSF_(Monad);
+
+// export const pureS = P.pureSF(Monad);
+
+// export const MonadSwitch: P.Monad<ObservableF> = P.Monad({
+//   map_: O.map_,
+//   cross_: O.cross_,
+//   crossWith_: O.crossWith_,
+//   unit: O.unit,
+//   pure: O.pure,
+//   chain_: O.switchMap_,
+//   flatten: O.switchFlatten,
+// });
+
+// export const Filterable: P.Filterable<ObservableF> = P.Filterable({
+//   map_: O.map_,
+//   filter_: O.filter_,
+//   filterMap_: O.filterMap_,
+//   partition_: O.partition_,
+//   partitionMap_: O.partitionMap_,
+// });
+
+// export const FilterableWithIndex: P.FilterableWithIndex<ObservableF> = P.FilterableWithIndex({
+//   imap_: O.mapWithIndex,
+//   ifilter_: O.ifilter_,
+//   ifilterMap_: O.filterMapWithIndex,
+//   ipartition_: O.partitionWithIndex,
+//   ipartitionMap_: O.partitionMapWithIndex_,
+// });

package/_src/Observable.ts

@@ -0,0 +1,27 @@
+// codegen:start { preset: barrel, include: Observable/*.ts }
+export * from "./Observable/api.js";
+export * from "./Observable/definition.js";
+export * from "./Observable/instances.js";
+// codegen:end
+
+// codegen:start { preset: barrel, include: Observable/api/*.ts }
+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
+
+// codegen:start { preset: barrel, include: Observable/dom/*.ts }
+export * from "./Observable/dom/animationFrames.js";
+// codegen:end

package/_src/Observer.ts

@@ -0,0 +1,5 @@
+export interface Observer<E, A> {
+  next: (value: A) => void;
+  error: (err: Cause<E>) => void;
+  complete: () => void;
+}

package/_src/Operator.ts

@@ -0,0 +1,73 @@
+export interface Operator<E, A> {
+  call(subscriber: Subscriber<E, A>, source: any): Finalizer;
+}
+
+export class OperatorSubscriber<E, A> extends Subscriber<E, A> {
+  constructor(destination: Subscriber<any, any>, observer: Partial<Observer<E, A>>, private onFinalize?: () => void) {
+    super(destination);
+    this.next = observer.next
+      ? function (this: OperatorSubscriber<E, A>, value: A) {
+          try {
+            observer.next!(value);
+          } catch (err) {
+            destination.error(Cause.halt(err));
+          }
+        }
+      : super.next;
+    this.error = observer.error
+      ? function (this: OperatorSubscriber<E, A>, error: Cause<E>) {
+          try {
+            observer.error!(error);
+          } catch (err) {
+            destination.error(Cause.halt(err));
+            this.unsubscribe();
+          } finally {
+            if (error.failureOrCause.isRight()) {
+              this.unsubscribe();
+            }
+          }
+        }
+      : super.error;
+    this.complete = observer.complete
+      ? function (this: OperatorSubscriber<E, A>) {
+          try {
+            observer.complete!();
+          } catch (err) {
+            destination.error(Cause.halt(err));
+          } finally {
+            this.unsubscribe();
+          }
+        }
+      : super.complete;
+  }
+
+  unsubscribe() {
+    const { closed } = this;
+    super.unsubscribe();
+    !closed && this.onFinalize?.();
+  }
+}
+
+export function operatorSubscriber<E, A, E1, A1>(
+  destination: Subscriber<E1, A1>,
+  observer: Partial<Observer<E, A>>,
+  onFinalize?: () => void,
+): OperatorSubscriber<E, A> {
+  return new OperatorSubscriber(destination, observer, onFinalize);
+}
+
+/**
+ * @tsplus fluent fncts.observable.Observable operate
+ */
+export function operate_<E, A, E1, A1>(
+  source: Observable<E, A>,
+  f: (source: Observable<E, A>, subscriber: Subscriber<E1, A1>) => (() => void) | void,
+): Observable<E1, A1> {
+  return source.lift(function (this: Subscriber<E1, A1>, liftedSource: Observable<E, A>) {
+    try {
+      f(liftedSource, this);
+    } catch (err) {
+      this.error(Cause.halt(err));
+    }
+  });
+}

package/_src/Scheduler.ts

@@ -0,0 +1,52 @@
+import { dateTimestampProvider } from "@fncts/observable/internal/timestampProvider";
+
+export interface SchedulerLike extends TimestampProvider {
+  schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
+}
+
+export interface SchedulerAction<T> extends Subscription {
+  schedule(state?: T, delay?: number): Subscription;
+}
+
+/*
+ * -------------------------------------------------------------------------------------------------
+ * Scheduler
+ * -------------------------------------------------------------------------------------------------
+ */
+
+export const SchedulerTypeId = Symbol.for("fncts.observable.Scheduler");
+export type SchedulerTypeId = typeof SchedulerTypeId;
+
+export class Scheduler implements SchedulerLike {
+  readonly [SchedulerTypeId]: SchedulerTypeId = SchedulerTypeId;
+
+  public now: () => number;
+  constructor(private actionConstructor: typeof Action, now: () => number = Scheduler.now) {
+    this.now = now;
+  }
+  schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription {
+    return new this.actionConstructor(this, work).schedule(state, delay);
+  }
+  public static now: () => number = dateTimestampProvider.now;
+}
+
+export function isScheduler(u: unknown): u is Scheduler {
+  return isObject(u) && SchedulerTypeId in u;
+}
+
+export function caughtSchedule<E, A>(
+  subscriber: Subscriber<E, A>,
+  scheduler: SchedulerLike,
+  execute: (this: SchedulerAction<any>) => void,
+  delay = 0,
+): Subscription {
+  const subscription = scheduler.schedule(function () {
+    try {
+      execute.call(this);
+    } catch (err) {
+      subscriber.error(Cause.halt(err));
+    }
+  }, delay);
+  subscriber.add(subscription);
+  return subscription;
+}

package/_src/Subject.ts

@@ -0,0 +1,171 @@
+import { arrayRemove } from "@fncts/observable/internal/util";
+
+export interface SubjectLike<E, A> extends Observer<E, A>, Subscribable<E, A> {}
+
+export class Subject<E, A> extends Observable<E, A> implements SubscriptionLike {
+  closed = false;
+  protected observers: Array<Observer<E, A>> = [];
+  protected isStopped             = false;
+  protected hasError              = false;
+  protected thrownError: Cause<E> = null!;
+
+  constructor() {
+    super();
+  }
+
+  lift<E1, B>(operator: Operator<E1, B>): Observable<E1, B> {
+    const subject    = new AnonymousSubject(this, this);
+    subject.operator = operator as any;
+    return subject as any;
+  }
+
+  next(value: A) {
+    this.throwIfClosed();
+    if (!this.isStopped) {
+      const copy = this.observers.slice();
+      for (const observer of copy) {
+        observer.next(value);
+      }
+    }
+  }
+
+  error(err: Cause<E>) {
+    this.throwIfClosed();
+    if (!this.isStopped) {
+      this.hasError       = this.isStopped = true;
+      this.thrownError    = err;
+      const { observers } = this;
+      while (observers.length) {
+        observers.shift()!.error(err);
+      }
+    }
+  }
+
+  complete() {
+    this.throwIfClosed();
+    if (!this.isStopped) {
+      this.isStopped      = true;
+      const { observers } = this;
+      while (observers.length) {
+        observers.shift()!.complete();
+      }
+    }
+  }
+
+  unsubscribe() {
+    this.isStopped = this.closed = true;
+    this.observers = null!;
+  }
+
+  get observed() {
+    return this.observers?.length > 0;
+  }
+
+  protected throwIfClosed() {
+    if (this.closed) {
+      throw new Error("Object Unsubscribed");
+    }
+  }
+
+  protected trySubscribe(subscriber: Subscriber<E, A>): Finalizer {
+    this.throwIfClosed();
+    return super.trySubscribe(subscriber);
+  }
+
+  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)));
+  }
+
+  protected checkFinalizedStatuses(subscriber: Subscriber<any, any>) {
+    const { hasError, thrownError, isStopped } = this;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  }
+
+  asObservable(): Observable<E, A> {
+    const observable: any = new Observable<E, A>();
+    observable.source     = this;
+    return observable;
+  }
+}
+
+export class AnonymousSubject<E, A> extends Subject<E, A> {
+  constructor(protected destination?: Observer<E, A>, source?: Observable<E, A>) {
+    super();
+    this.source = source;
+  }
+  next(value: A) {
+    this.destination?.next?.(value);
+  }
+  error(err: Cause<E>) {
+    this.destination?.error?.(err);
+  }
+  complete() {
+    this.destination?.complete?.();
+  }
+
+  /** @internal */
+  protected subscribeInternal<E, A>(subscriber: Subscriber<E, A>) {
+    return this.source?.subscribe(subscriber) ?? Subscription.empty;
+  }
+}
+
+export class AsyncSubject<E, A> extends Subject<E, A> {
+  private value: Either<Cause<E>, A> | null = null;
+  private hasValue   = false;
+  private isComplete = false;
+
+  /** @internal */
+  protected checkFinalizedStatuses(subscriber: Subscriber<E, A>) {
+    const { hasError, hasValue, value, thrownError, isStopped, isComplete } = this;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped || isComplete) {
+      hasValue &&
+        value!.match(
+          (e) => subscriber.error(e),
+          (a) => subscriber.next(a),
+        );
+      subscriber.complete();
+    }
+  }
+
+  next(value: A) {
+    if (!this.isStopped) {
+      this.value    = Either.right(value);
+      this.hasValue = true;
+    }
+  }
+
+  error(err: Cause<E>) {
+    if (!this.isStopped) {
+      this.value    = Either.left(err);
+      this.hasValue = true;
+    }
+  }
+
+  complete() {
+    const { hasValue, value, isComplete } = this;
+    if (!isComplete) {
+      this.isComplete = true;
+      hasValue &&
+        value!.match(
+          (e) => super.error(e),
+          (a) => super.next(a),
+        );
+      super.complete();
+    }
+  }
+}

package/_src/Subscriber.ts

@@ -0,0 +1,130 @@
+export const SubscriberTypeId = Symbol.for("fncts.observable.Subscriber");
+export type SubscriberTypeId = typeof SubscriberTypeId;
+
+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;
+    }
+  }
+  next(value: A) {
+    if (!this.isStopped) {
+      this._next(value);
+    }
+  }
+  error(err: Cause<E>) {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      this._error(err);
+    }
+  }
+  complete() {
+    if (!this.isStopped) {
+      this.isStopped = true;
+      this._complete();
+    }
+  }
+  unsubscribe(): void {
+    if (!this.closed) {
+      this.isStopped = true;
+      super.unsubscribe();
+      this.observer = null;
+    }
+  }
+
+  _next(value: A) {
+    this.observer!.next(value);
+  }
+
+  _error(err: Cause<E>) {
+    try {
+      this.observer!.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  }
+
+  _complete() {
+    try {
+      this.observer!.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);
+    }
+    if (error) {
+      this.observer = {
+        next: next ? wrapDefectHandler(next, error) : noop,
+        error: error ? wrapDefectHandler(error, error) : noop,
+        complete: complete ? wrapDefectHandler(complete, error) : noop,
+      };
+    } else {
+      this.observer = {
+        next: next ? wrapThrowHandler(next) : noop,
+        error: wrapThrowHandler(error ?? defaultErrorHandler),
+        complete: complete ? wrapThrowHandler(complete) : noop,
+      };
+    }
+  }
+}
+
+function wrapDefectHandler<E>(handler: (arg?: any) => void, onDefect: (err: Cause<E>) => void) {
+  return (...args: any[]) => {
+    try {
+      handler(...args);
+    } catch (err) {
+      onDefect(Cause.halt(err));
+    }
+  };
+}
+
+function wrapThrowHandler(handler: (arg?: any) => void) {
+  return (...args: any[]) => {
+    try {
+      handler(...args);
+    } catch (err) {
+      reportUnhandledError(err);
+    }
+  };
+}
+
+function defaultErrorHandler(error: any) {
+  throw error;
+}
+
+export const EMPTY_OBSERVER: Readonly<Observer<any, any>> & { closed: true } = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop,
+};
+
+export function isSubscriber(u: unknown): u is Subscriber<any, any> {
+  return isObject(u) && SubscriberTypeId in u;
+}