@most/types/index.js.flow

Reactive programming with lean, functions-only, curried, tree-shakeable API

// @flow

// An instant in time.  This can be wall-clock time
// or a virtual time, depending on the particular Scheduler
// in use
export type Time = number

// A Clock represents a source of the current time
export type Clock = {
  now (): Time
}

export type Stream<A> = {
  run (Sink<A>, Scheduler): Disposable
}

export type Sink<A> = {
  event (Time, A): void,
  end (Time): void,
  error (Time, Error): void,
}

// Interface of a resource that can be disposed
export type Disposable = {
  dispose (): void
}

// Delay time offset
export type Delay = number

// Span of time between time instants
export type Period = number

// Relative offset between two clocks / schedulers
export type Offset = number

export type Scheduler = {
  currentTime (): Time,
  scheduleTask (Offset, Delay, Period, Task): ScheduledTask,
  relative (Offset): Scheduler,
  cancel (ScheduledTask): void,
  // @deprecated
  cancelAll ((ScheduledTask) => boolean): void
}

// Opaque handle vended by some platform-specific functions,
// like setTimeout.
export type Handle = any

// A Timer can schedule a function to run after
// a particular delay
export type Timer = {
  now (): Time,
  setTimer (() => any, Delay): Handle,
  clearTimer (Handle): void
}

// Run a ScheduledTask
export type TaskRunner = (ScheduledTask) => any

// A Timeline is a set of ScheduledTasks to be executed at
// particular times
export type Timeline = {
  add (ScheduledTask): void,
  remove (ScheduledTask): boolean,
  // @deprecated
  removeAll ((ScheduledTask) => boolean): void,
  isEmpty (): boolean,
  nextArrival (): Time,
  runTasks (Time, TaskRunner): void
}

export type Task = Disposable & {
  run (Time): void,
  error (Time, Error): void,
}

export type ScheduledTask = Disposable & {
  task: Task,
  run (): void,
  error (Error): void,
}