Class Timer<T>

constructor

• new Timer<T>(handler?, delay?, lazy?, controller?): Timer<T>

• Construct a Timer By default lazy is false, which means it will eagerly reject the timer, even if the handler has already started executing If lazy is true, this will make the timer wait for the handler to finish executing Note that passing a custom controller does not stop the default behaviour

  Type Parameters

  • T = void

  Parameters

  • Optional handler: ((signal) => T | PromiseLike<T>)

    • • (signal): T | PromiseLike<T>

      • Parameters

        • signal: AbortSignal

        Returns T | PromiseLike<T>

  • Optional delay: number

  • Optional lazy: boolean

  • Optional controller: PromiseCancellableController

  Returns Timer<T>
• new Timer<T>(opts?): Timer<T>

• Type Parameters

  • T = void

  Parameters

  • Optional opts: {
        controller?: PromiseCancellableController;
        delay?: number;
        handler?: ((signal) => T | PromiseLike<T>);
        lazy?: boolean;
    }

    • Optional controller?: PromiseCancellableController

    • Optional delay?: number

    • Optional handler?: ((signal) => T | PromiseLike<T>)

      • • (signal): T | PromiseLike<T>

        • Parameters

          • signal: AbortSignal

          Returns T | PromiseLike<T>

    • Optional lazy?: boolean

  Returns Timer<T>

Readonly lazy

Readonly timestamp

[toStringTag]

• get [toStringTag](): string

• Returns string

delay

• get delay(): number

• Delay in milliseconds This may be Infinity

  Returns number

scheduled

• get scheduled(): undefined | Date

• Timestamp when this is scheduled to finish and execute the handler Guaranteed to be weakly monotonic within the process lifetime Compare this with performance.now() not Date.now()

  Returns undefined | Date

status

• get status(): null | "settling" | "settled"

• Returns null | "settling" | "settled"

cancel

• cancel(reason?): void

• Cancels the timer Unlike PromiseCancellable, canceling the timer will not result in an unhandled promise rejection, all promise rejections are ignored

  Parameters

  • Optional reason: any

  Returns void

catch

• catch<TResult>(onRejected?, controller?): PromiseCancellable<T | TResult>

• Type Parameters

  • TResult = never

  Parameters

  • Optional onRejected: null | ((reason, signal) => TResult | PromiseLike<TResult>)

  • Optional controller: PromiseCancellableController

  Returns PromiseCancellable<T | TResult>

finally

• finally(onFinally?, controller?): PromiseCancellable<T>

• Parameters

  • Optional onFinally: null | ((signal) => void)

  • Optional controller: PromiseCancellableController

  Returns PromiseCancellable<T>

getTimeout

• getTimeout(): number

• Gets the remaining time in milliseconds This will return Infinity if delay is Infinity This will return 0 if status is settling or settled

  Returns number

refresh

• refresh(): void

• Refreshes the timer to the original delay and updates the scheduled time.

  Returns void

  Throws

  If the timer is settling or settled

reset

• reset(delay): void

• Resets the timer with a new delay and updates the scheduled time and delay.

  Parameters

  • delay: number

  Returns void

  Throws

  If the timer is settling or settled

then

• then<TResult1, TResult2>(onFulfilled?, onRejected?, controller?): PromiseCancellable<TResult1 | TResult2>

• Type Parameters

  • TResult1 = T

  • TResult2 = never

  Parameters

  • Optional onFulfilled: null | ((value, signal) => TResult1 | PromiseLike<TResult1>)

  • Optional onRejected: null | ((reason, signal) => TResult2 | PromiseLike<TResult2>)

  • Optional controller: PromiseCancellableController

  Returns PromiseCancellable<TResult1 | TResult2>

toString

• toString(): string

• To remaining time as a string This may return 'Infinity' if this.delay is Infinity This will return '0' if status is settling or settled

  Returns string

valueOf

• valueOf(): number

• To remaining time as a number This may return Infinity if this.delay is Infinity This will return 0 if status is settling or settled

  Returns number