Class RunnerBase<Node, Result, Sync, O>Abstract

constructor

• new RunnerBase<Node, Result, Sync, O>(options, from?): RunnerBase<Node, Result, Sync, O>

• Type Parameters

  • Node
  • Result = void
  • Sync extends boolean = false
  • O extends RunnerOptionsSync<Node, Result> | RunnerOptions<Node, Result> = Sync extends true
        ? RunnerOptionsSync<Node, Result>
        : RunnerOptions<Node, Result>

  Parameters

  • options: O
  • Optionalfrom: Callable

  Returns RunnerBase<Node, Result, Sync, O>

Readonly InternalabortController

Readonlydependents

ReadonlydirectDependents

Readonlyerrors

ReadonlyfailFast

Readonlyfrom

Readonlyoptions

Readonlyresults

Readonlysettled

cycleCheck

• cycleCheck(n, path, d): boolean
• Internal

  If the dependency from n -> d at the specified path would cause a cycle, then call the onCycle method and return true. Oherwise, assign the appropriate entries in the dependency tracking sets, and return false.

  Parameters

  • n: Node
  • path: Node[]
  • d: Node

  Returns boolean

AbstractgetDeps

• getDeps(n): Sync extends true
      ? Node[]
      : Promise<Node[]>

• Get the dependencies of a given node

  Parameters

  • n: Node

  Returns Sync extends true
      ? Node[]
      : Promise<Node[]>

handleError

• handleError(er, n, path): void
• Internal

  Method that handles errors raised by visits.

  Parameters

  • er: unknown
  • n: Node
  • path: Node[]

  Returns void

handleValue

• handleValue(value, n): void
• Internal

  Method that handles successful visit results

  Parameters

  • value: Result
  • n: Node

  Returns void

AbstractonCycle

• onCycle(n, cycle, path): Sync extends true
      ? void
      : void | Promise<void>

• Calls the options.onCycle() method when a cycle is detected.

  Parameters

  • n: Node
  • cycle: Node[]
  • path: Node[]

  Returns Sync extends true
      ? void
      : void | Promise<void>

route

• route(n, d): undefined | [n: Node, ...path: Node[]]

• For a Node n that depends directly or transitively on Node d, find the shortest known dependency path from n to d. This is done by walking backwards breadth-first up the dependency relations from d until n is found.

  If no known path can be found, then undefined is returned. Otherwise, a path array is returned that starts with n and ends with d.

  Note that self-referential links are never considered, since they're by definition cyclical.

  Parameters

  • n: Node
  • d: Node

  Returns undefined | [n: Node, ...path: Node[]]

Abstractrun

• run(): Sync extends true
      ? void
      : Promise<void>

• Initiate the graph traversal, resolving/returning when complete

  Returns Sync extends true
      ? void
      : Promise<void>

Abstractvisit

• visit(n, path, depResults): Sync extends true
      ? Result
      : Promise<Result>

• Visit a node. Calls options.visit()

  Parameters

  • n: Node
  • path: Node[]
  • depResults: DepResults<Node, Result>

  Returns Sync extends true
      ? Result
      : Promise<Result>