@tempest/core/src/interfaces.ts

The core of the Tempest Stream Library

export interface Subscribable<T> {
  source: Source<T>
  subscribe(nextOrObserver?: Subscriber<T> | ((x: T) => any),
            error?: (error: Error) => any,
            complete?: (x?: T) => any): Subscription<T>
}

export interface Source<T> {
  run (sink: Sink<T>, scheduler: Scheduler): Disposable<T>
}

export interface Sink<T> {
  event (time: number, value: T): void
  end (time: number, value?: T): void
  error (time: number, err: Error): void
}

export interface Scheduler {
  now(): number
  asap(task: Task): ScheduledTask
  delay(delayTime: number, task: Task): ScheduledTask
  periodic(period: number, task: Task): ScheduledTask
  schedule(delay: number, period: number, task: Task): ScheduledTask
  cancel(task: ScheduledTask): void
  cancelAll(predicate: (task: ScheduledTask) => boolean): void
}

export interface Timeline<T> {
  nextArrival (): number
  isEmpty (): boolean
  add (task: T): void
  remove (task: T): boolean
  removeAll (f: (task: T) => boolean): void
  runTasks (time: number, runTask: (task: T) => any): void
}

export interface Timeslot<T> {
  time: number
  events: T[]
}

export interface Timer<T> {
  now(): number,
  setTimer(fn: () => any, delayTime: number): T | number
  clearTimer(task: T): any
}

export interface Task {
  run(time: number): void
  error(time: number, e: Error): void
  dispose(): void
}

export interface ScheduledTask {
  task: Task
  run(): void
  error(err: Error): void
  dispose(): void
}

export interface Disposable<A> {
  dispose(): void | Promise<A>
}

export interface Subscriber<A> {
  next(value: A): void;
  error(err: Error): void;
  complete(value?: A): void;
}

export interface Subscription<A> {
  unsubscribe(): void;
}