taskbuffer/ts/taskbuffer.classes.task.ts

import * as plugins from './taskbuffer.plugins'
import * as helpers from './taskbuffer.classes.helpers'

export interface ITaskFunction {
  (x?: any): PromiseLike<any>
}

export class Task {
  // man datory properties
  name: string
  taskFunction: ITaskFunction
  buffered: boolean

  bufferMax: number
  execDelay: number

  // tasks to run before and after
  preTask: Task
  afterTask: Task

  // initialize by default
  running: boolean = false
  bufferRunner = new helpers.BufferRunner(this)
  cycleCounter = new helpers.CycleCounter(this)

  idle: boolean = true
  private _state: string = 'ready'

  constructor(optionsArg: {
    /**
     * the task function to run, must return promise
     */
    taskFunction: ITaskFunction
    /**
     * any other task to run before
     */
    preTask?: Task
    /**
     * any other task to run after
     */
    afterTask?: Task
    /**
     * wether this task should run buffered
     */
    buffered?: boolean
    /**
     * the maximum buffer
     */
    bufferMax?: number
    /**
     * the execution delay, before the task is executed
     * only makes sense when running in buffered mode
     */
    execDelay?: number
    /**
     * the name of the task
     */
    name?: string
  }) {
    this.taskFunction = optionsArg.taskFunction
    this.preTask = optionsArg.preTask
    this.afterTask = optionsArg.afterTask
    this.idle = !this.running
    this.buffered = optionsArg.buffered
    this.bufferMax = optionsArg.bufferMax
    this.execDelay = optionsArg.execDelay
    this.name = optionsArg.name
  }

  /**
   * trigger the task. Will trigger buffered if this.buffered is true
   */
  trigger(x?): Promise<any> {
    if (this.buffered) {
      return this.triggerBuffered(x)
    } else {
      return this.triggerUnBuffered(x)
    }
  }

  /**
   * trigger task unbuffered.
   */
  triggerUnBuffered(x?): Promise<any> {
    return helpers.runTask(this, { x: x })
  }

  /**
   * trigger task buffered.
   */
  triggerBuffered(x?): Promise<any> {
    return this.bufferRunner.trigger(x)
  }

  get state(): string {
    return this._state
  }

  set state(stateArg: string) {
    if (stateArg === 'locked') {
      this._state = 'locked'
    } else {
      plugins.beautylog.error('state type ' + stateArg + ' could not be set')
    }
  }
}