@fncts/observable 0.0.1

package/_src/Subscription.ts

@@ -0,0 +1,143 @@
+export interface Unsubscribable {
+  readonly unsubscribe: () => void;
+}
+
+export interface SubscriptionLike extends Unsubscribable {
+  readonly closed: boolean;
+}
+
+export type Finalizer = Unsubscribable | (() => void) | void;
+
+export const SubscriptionTypeId = Symbol.for("@fncts/observable/Subscription");
+export type SubscriptionTypeId = typeof SubscriptionTypeId;
+
+/**
+ * @tsplus type fncts.observable.Subscription
+ * @tsplus companion fncts.observable.SubscriptionOps
+ */
+export class Subscription implements SubscriptionLike {
+  readonly [SubscriptionTypeId]: SubscriptionTypeId = SubscriptionTypeId;
+
+  public closed = false;
+  private finalizers: Set<Finalizer> | null = null;
+  private parents: Set<Subscription> | null = null;
+
+  constructor(private initialFinalizer?: () => void) {}
+
+  unsubscribe(): void {
+    let errors: unknown[] | undefined;
+
+    if (!this.closed) {
+      this.closed = true;
+
+      const { parents, initialFinalizer, finalizers } = this;
+
+      if (parents) {
+        this.parents = null;
+        for (const parent of parents) {
+          parent.remove(this);
+        }
+      }
+
+      if (initialFinalizer) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = isUnsubscribeError(e) ? e.errors : [e];
+        }
+      }
+
+      if (finalizers) {
+        this.finalizers = null;
+        for (const finalizer of finalizers) {
+          try {
+            executeFinalizer(finalizer);
+          } catch (e) {
+            errors ||= [];
+            if (isUnsubscribeError(e)) {
+              errors.push(...e.errors);
+            } else {
+              errors.push(e);
+            }
+          }
+        }
+      }
+    }
+
+    if (errors) {
+      throw new UnsubscribeError(errors);
+    }
+  }
+
+  add(finalizer: Finalizer): void {
+    if (finalizer && finalizer !== this) {
+      if (this.closed) {
+        executeFinalizer(finalizer);
+      } else {
+        if (isSubscription(finalizer)) {
+          if (finalizer.closed || finalizer.hasParent(this)) {
+            return;
+          }
+          finalizer.addParent(this);
+        }
+        if (!this.finalizers) {
+          this.finalizers = new Set();
+        }
+        this.finalizers.add(finalizer);
+      }
+    }
+  }
+
+  private hasParent(parent: Subscription) {
+    const parentage = this.parents;
+    return parentage ? parentage.has(parent) : false;
+  }
+
+  private addParent(parent: Subscription) {
+    if (!this.parents) {
+      this.parents = new Set();
+    }
+    this.parents.add(parent);
+  }
+
+  private removeParent(parent: Subscription) {
+    this.parents?.delete(parent);
+  }
+
+  remove(finalizer: Finalizer): void {
+    this.finalizers?.delete(finalizer);
+
+    if (isSubscription(finalizer)) {
+      finalizer.removeParent(this);
+    }
+  }
+}
+
+export function isSubscription(u: unknown): u is Subscription {
+  return isObject(u) && SubscriptionTypeId in u;
+}
+
+function executeFinalizer(finalizer: Finalizer): void {
+  return finalizer && ("unsubscribe" in finalizer ? finalizer.unsubscribe() : finalizer());
+}
+
+/**
+ * @tsplus static fncts.observable.SubscriptionOps empty
+ */
+export const EMPTY_SUBSCRIPTION = (() => {
+  const empty  = new Subscription();
+  empty.closed = true;
+  return empty;
+})();
+
+export const UnsubscribeErrorTypeId = Symbol.for("@principia/observable/UnsubscribeError");
+export type UnsubscribeErrorTypeId = typeof UnsubscribeErrorTypeId;
+
+export class UnsubscribeError {
+  readonly [UnsubscribeErrorTypeId]: UnsubscribeErrorTypeId = UnsubscribeErrorTypeId;
+  constructor(readonly errors: unknown[]) {}
+}
+
+export function isUnsubscribeError(u: unknown): u is UnsubscribeError {
+  return isObject(u) && UnsubscribeErrorTypeId in u;
+}

package/_src/demo.ts

@@ -0,0 +1,29 @@
+const x = new Observable<never, void>((subscriber) => {
+  setInterval(() => {
+    subscriber.next(undefined);
+  }, 1000);
+});
+
+new Observable<string, number>((subscriber) => {
+  let i        = 0;
+  const handle = setInterval(() => {
+    if (i === 100) {
+      subscriber.error(Cause.fail("lmao"));
+    } else {
+      subscriber.next(i++);
+    }
+  }, 100);
+  subscriber.add(() => {
+    clearInterval(handle);
+  });
+})
+  .share()
+  .window(x)
+  .subscribe({
+    next: (value) => {
+      value.subscribe(console.log.bind(console));
+    },
+    error: (cause) => {
+      console.log(cause);
+    },
+  });

package/_src/global.ts

@@ -0,0 +1,141 @@
+import "@fncts/observable";
+
+/**
+ * @tsplus global
+ */
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+/**
+ * @tsplus global
+ */
+import { Cause } from "@fncts/base/data/Cause";
+/**
+ * @tsplus global
+ */
+import { Either } from "@fncts/base/data/Either";
+/**
+ * @tsplus global
+ */
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus global
+ */
+import { Lazy } from "@fncts/base/data/function";
+/**
+ * @tsplus global
+ */
+import { Just, Maybe, Nothing } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus global
+ */
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate";
+/**
+ * @tsplus global
+ */
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement";
+/**
+ * @tsplus global
+ */
+import { Eq } from "@fncts/base/typeclass";
+/**
+ * @tsplus global
+ */
+import { isDate, isFunction, isIterable, isObject, isPlain } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { Fiber, FiberContext } from "@fncts/io/Fiber";
+/**
+ * @tsplus global
+ */
+import { IO, isIO, UIO } from "@fncts/io/IO";
+/**
+ * @tsplus global
+ */
+import { IOEnv } from "@fncts/io/IOEnv";
+/**
+ * @tsplus global
+ */
+import { Action } from "@fncts/observable/Action";
+/**
+ * @tsplus global
+ */
+import { AnimationFrameAction } from "@fncts/observable/AnimationFrameAction";
+/**
+ * @tsplus global
+ */
+import { AnimationFrameScheduler } from "@fncts/observable/AnimationFrameScheduler";
+/**
+ * @tsplus global
+ */
+import { AsyncAction } from "@fncts/observable/AsyncAction";
+/**
+ * @tsplus global
+ */
+import { AsyncScheduler, asyncScheduler } from "@fncts/observable/AsyncScheduler";
+/**
+ * @tsplus global
+ */
+import { animationFrameProvider } from "@fncts/observable/internal/animationFrameProvider";
+/**
+ * @tsplus global
+ */
+import { timeoutProvider } from "@fncts/observable/internal/timeoutProvider";
+/**
+ * @tsplus global
+ */
+import { TimestampProvider } from "@fncts/observable/internal/timestampProvider";
+/**
+ * @tsplus global
+ */
+import {
+  isArrayLike,
+  isAsyncIterable,
+  isPromiseLike,
+  isReadableStream,
+  isValidDate,
+  noop,
+  ReadableStreamLike,
+  reportUnhandledError,
+} from "@fncts/observable/internal/util";
+/**
+ * @tsplus global
+ */
+import { Notification } from "@fncts/observable/Notification";
+/**
+ * @tsplus global
+ */
+import { Observable, ObservableInput, Subscribable } from "@fncts/observable/Observable";
+/**
+ * @tsplus global
+ */
+import { Observer } from "@fncts/observable/Observer";
+/**
+ * @tsplus global
+ */
+import { operate_, Operator, OperatorSubscriber, operatorSubscriber } from "@fncts/observable/Operator";
+/**
+ * @tsplus global
+ */
+import { isScheduler, Scheduler, SchedulerAction, SchedulerLike } from "@fncts/observable/Scheduler";
+/**
+ * @tsplus global
+ */
+import { Subject, SubjectLike } from "@fncts/observable/Subject";
+/**
+ * @tsplus global
+ */
+import { AsyncSubject } from "@fncts/observable/Subject";
+/**
+ * @tsplus global
+ */
+import { isSubscriber, SafeSubscriber, Subscriber } from "@fncts/observable/Subscriber";
+/**
+ * @tsplus global
+ */
+import {
+  Finalizer,
+  isSubscription,
+  Subscription,
+  SubscriptionLike,
+  Unsubscribable,
+} from "@fncts/observable/Subscription";

package/_src/index.ts

@@ -0,0 +1,14 @@
+export * as action from "@fncts/observable/Action";
+export * as animationFrameAction from "@fncts/observable/AnimationFrameAction";
+export * as animationFrameScheduler from "@fncts/observable/AnimationFrameScheduler";
+export * as asyncAction from "@fncts/observable/AsyncAction";
+export * as asyncScheduler from "@fncts/observable/AsyncScheduler";
+export * as behaviorSubject from "@fncts/observable/BehaviorSubject";
+export * as observable from "@fncts/observable/Observable";
+export * as notification from "@fncts/observable/Observable";
+export * as observer from "@fncts/observable/Observer";
+export * as operator from "@fncts/observable/Operator";
+export * as scheduler from "@fncts/observable/Scheduler";
+export * as subject from "@fncts/observable/Subject";
+export * as subscriber from "@fncts/observable/Subscriber";
+export * as subscription from "@fncts/observable/Subscription";

package/_src/internal/animationFrameProvider.ts

@@ -0,0 +1,37 @@
+interface AnimationFrameProvider {
+  schedule(callback: FrameRequestCallback): Subscription;
+  requestAnimationFrame: typeof requestAnimationFrame;
+  cancelAnimationFrame: typeof cancelAnimationFrame;
+  delegate:
+    | {
+        requestAnimationFrame: typeof requestAnimationFrame;
+        cancelAnimationFrame: typeof cancelAnimationFrame;
+      }
+    | undefined;
+}
+
+export const animationFrameProvider: AnimationFrameProvider = {
+  schedule(callback) {
+    let request = requestAnimationFrame;
+    let cancel: typeof this.cancelAnimationFrame | undefined = cancelAnimationFrame;
+    const { delegate } = animationFrameProvider;
+    if (delegate) {
+      request = delegate.requestAnimationFrame;
+      cancel  = delegate.cancelAnimationFrame;
+    }
+    const handle = request((timestamp) => {
+      cancel = undefined;
+      callback(timestamp);
+    });
+    return new Subscription(() => cancel?.(handle));
+  },
+  requestAnimationFrame(...args) {
+    const { delegate } = animationFrameProvider;
+    return (delegate?.requestAnimationFrame || requestAnimationFrame)(...args);
+  },
+  cancelAnimationFrame(...args) {
+    const { delegate } = animationFrameProvider;
+    return (delegate?.cancelAnimationFrame || cancelAnimationFrame)(...args);
+  },
+  delegate: undefined,
+};

package/_src/internal/args.ts

@@ -0,0 +1,11 @@
+function last<A>(arr: A[]): A | undefined {
+  return arr[arr.length - 1];
+}
+
+export function popNumber(args: any[], defaultValue: number): number {
+  return typeof last(args) === "number" ? args.pop()! : defaultValue;
+}
+
+export function popScheduler(args: any[]): SchedulerLike | undefined {
+  return isScheduler(last(args)) ? args.pop() : undefined;
+}

package/_src/internal/intervalProvider.ts

@@ -0,0 +1,27 @@
+type SetIntervalFunction = (handler: () => void, timeout?: number, ...args: any[]) => number;
+type ClearIntervalFunction = (handle: number) => void;
+
+interface IntervalProvider {
+  setInterval: SetIntervalFunction;
+  clearInterval: ClearIntervalFunction;
+  delegate:
+    | {
+        setInterval: SetIntervalFunction;
+        clearInterval: ClearIntervalFunction;
+      }
+    | undefined;
+}
+
+export const intervalProvider: IntervalProvider = {
+  // When accessing the delegate, use the variable rather than `this` so that
+  // the functions can be called without being bound to the provider.
+  setInterval(...args) {
+    const { delegate } = intervalProvider;
+    return (delegate?.setInterval || setInterval)(...args);
+  },
+  clearInterval(handle) {
+    const { delegate } = intervalProvider;
+    return (delegate?.clearInterval || clearInterval)(handle);
+  },
+  delegate: undefined,
+};

package/_src/internal/performanceTimestampProvider.ts

@@ -0,0 +1,12 @@
+import type { TimestampProvider } from "./timestampProvider";
+
+interface PerformanceTimestampProvider extends TimestampProvider {
+  delegate: TimestampProvider | undefined;
+}
+
+export const performanceTimestampProvider: PerformanceTimestampProvider = {
+  now() {
+    return (performanceTimestampProvider.delegate || performance).now();
+  },
+  delegate: undefined,
+};

package/_src/internal/timeoutProvider.ts

@@ -0,0 +1,27 @@
+type SetTimeoutFunction = (handler: () => void, timeout?: number, ...args: any[]) => number;
+type ClearTimeoutFunction = (handle: number) => void;
+
+interface TimeoutProvider {
+  setTimeout: SetTimeoutFunction;
+  clearTimeout: ClearTimeoutFunction;
+  delegate:
+    | {
+        setTimeout: SetTimeoutFunction;
+        clearTimeout: ClearTimeoutFunction;
+      }
+    | undefined;
+}
+
+export const timeoutProvider: TimeoutProvider = {
+  // When accessing the delegate, use the variable rather than `this` so that
+  // the functions can be called without being bound to the provider.
+  setTimeout(...args) {
+    const { delegate } = timeoutProvider;
+    return (delegate?.setTimeout || setTimeout)(...args);
+  },
+  clearTimeout(handle) {
+    const { delegate } = timeoutProvider;
+    return (delegate?.clearTimeout || clearTimeout)(handle);
+  },
+  delegate: undefined,
+};

package/_src/internal/timestampProvider.ts

@@ -0,0 +1,14 @@
+export interface TimestampProvider {
+  now(): number;
+}
+
+export interface DateTimestampProvider extends TimestampProvider {
+  delegate: TimestampProvider | undefined;
+}
+
+export const dateTimestampProvider: DateTimestampProvider = {
+  now() {
+    return (dateTimestampProvider.delegate || Date).now();
+  },
+  delegate: undefined,
+};

package/_src/internal/util.ts

@@ -0,0 +1,94 @@
+export function arrayRemove<T>(arr: T[] | undefined | null, item: T) {
+  if (arr) {
+    const index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+
+export function noop(): void {
+  // noop
+}
+
+export function isAsyncIterable(u: any): u is AsyncIterable<any> {
+  return Symbol.asyncIterator && isFunction(u?.[Symbol.asyncIterator]);
+}
+
+export function isArrayLike(u: any): u is ArrayLike<any> {
+  return u != null && typeof u.length === "number" && typeof u !== "function";
+}
+
+export function isPromiseLike(u: any): u is PromiseLike<any> {
+  return isFunction(u?.then);
+}
+
+export function isValidDate(u: unknown): u is Date {
+  return isDate(u) && !isNaN(u as any);
+}
+
+export function reportUnhandledError(err: unknown) {
+  return timeoutProvider.setTimeout(() => {
+    throw err;
+  });
+}
+
+export function arrayOrObject<T, O extends Record<string, T>>(
+  args: ReadonlyArray<T> | [O] | [ReadonlyArray<T>],
+): { args: ReadonlyArray<T>; keys: ReadonlyArray<string> | null } {
+  if (args.length === 1) {
+    const first = args[0];
+    if (Array.isArray(first)) {
+      return { args: first, keys: null };
+    }
+    if (isPlain(first)) {
+      const keys = Object.keys(first);
+      return {
+        args: Object.values(first),
+        keys,
+      };
+    }
+  }
+
+  return { args: args as ReadonlyArray<T>, keys: null };
+}
+
+/*
+ * -------------------------------------------------------------------------------------------------
+ * ReadableStream
+ * -------------------------------------------------------------------------------------------------
+ */
+
+interface ReadableStreamDefaultReaderLike<T> {
+  read(): PromiseLike<
+    | {
+        done: false;
+        value: T;
+      }
+    | { done: true; value?: undefined }
+  >;
+  releaseLock(): void;
+}
+
+export interface ReadableStreamLike<T> {
+  getReader(): ReadableStreamDefaultReaderLike<T>;
+}
+
+export async function* readableStreamToAsyncGenerator<A>(readableStream: ReadableStreamLike<A>): AsyncGenerator<A> {
+  const reader = readableStream.getReader();
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value!;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+
+export function isReadableStream<A>(u: any): u is ReadableStreamLike<A> {
+  return isFunction(u?.getReader);
+}
+
+export type Init<A extends ReadonlyArray<unknown>> = A extends [...infer Init, infer Last] ? Init : never;

package/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/global.d.ts

@@ -0,0 +1,125 @@
+/**
+ * @tsplus global
+ */
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+/**
+ * @tsplus global
+ */
+import { Cause } from "@fncts/base/data/Cause";
+/**
+ * @tsplus global
+ */
+import { Either } from "@fncts/base/data/Either";
+/**
+ * @tsplus global
+ */
+import { Exit } from "@fncts/base/data/Exit";
+/**
+ * @tsplus global
+ */
+import { Lazy } from "@fncts/base/data/function";
+/**
+ * @tsplus global
+ */
+import { Just, Maybe, Nothing } from "@fncts/base/data/Maybe";
+/**
+ * @tsplus global
+ */
+import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate";
+/**
+ * @tsplus global
+ */
+import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement";
+/**
+ * @tsplus global
+ */
+import { Eq } from "@fncts/base/typeclass";
+/**
+ * @tsplus global
+ */
+import { isDate, isFunction, isIterable, isObject, isPlain } from "@fncts/base/util/predicates";
+/**
+ * @tsplus global
+ */
+import { Fiber, FiberContext } from "@fncts/io/Fiber";
+/**
+ * @tsplus global
+ */
+import { IO, isIO, UIO } from "@fncts/io/IO";
+/**
+ * @tsplus global
+ */
+import { IOEnv } from "@fncts/io/IOEnv";
+/**
+ * @tsplus global
+ */
+import { Action } from "@fncts/observable/Action";
+/**
+ * @tsplus global
+ */
+import { AnimationFrameAction } from "@fncts/observable/AnimationFrameAction";
+/**
+ * @tsplus global
+ */
+import { AnimationFrameScheduler } from "@fncts/observable/AnimationFrameScheduler";
+/**
+ * @tsplus global
+ */
+import { AsyncAction } from "@fncts/observable/AsyncAction";
+/**
+ * @tsplus global
+ */
+import { AsyncScheduler, asyncScheduler } from "@fncts/observable/AsyncScheduler";
+/**
+ * @tsplus global
+ */
+import { animationFrameProvider } from "@fncts/observable/internal/animationFrameProvider";
+/**
+ * @tsplus global
+ */
+import { timeoutProvider } from "@fncts/observable/internal/timeoutProvider";
+/**
+ * @tsplus global
+ */
+import { TimestampProvider } from "@fncts/observable/internal/timestampProvider";
+/**
+ * @tsplus global
+ */
+import { isArrayLike, isAsyncIterable, isPromiseLike, isReadableStream, isValidDate, noop, ReadableStreamLike, reportUnhandledError, } from "@fncts/observable/internal/util";
+/**
+ * @tsplus global
+ */
+import { Notification } from "@fncts/observable/Notification";
+/**
+ * @tsplus global
+ */
+import { Observable, ObservableInput, Subscribable } from "@fncts/observable/Observable";
+/**
+ * @tsplus global
+ */
+import { Observer } from "@fncts/observable/Observer";
+/**
+ * @tsplus global
+ */
+import { operate_, Operator, OperatorSubscriber, operatorSubscriber } from "@fncts/observable/Operator";
+/**
+ * @tsplus global
+ */
+import { isScheduler, Scheduler, SchedulerAction, SchedulerLike } from "@fncts/observable/Scheduler";
+/**
+ * @tsplus global
+ */
+import { Subject, SubjectLike } from "@fncts/observable/Subject";
+/**
+ * @tsplus global
+ */
+import { AsyncSubject } from "@fncts/observable/Subject";
+/**
+ * @tsplus global
+ */
+import { isSubscriber, SafeSubscriber, Subscriber } from "@fncts/observable/Subscriber";
+/**
+ * @tsplus global
+ */
+import { Finalizer, isSubscription, Subscription, SubscriptionLike, Unsubscribable, } from "@fncts/observable/Subscription";
+import "@fncts/observable";