constructor

• new Async(): Async

• Returns Async

isDestructed

cancelAnimationFrame

• cancelAnimationFrame(request): void

• Smart wrapper for cancelAnimationFrame

  Parameters

  • request: number

  Returns void

cancelIdleCallback

• cancelIdleCallback(request): void

• Parameters

  • request: number

  Returns void

clear

• clear(): void

• Returns void

clearTimeout

• clearTimeout(timer): void

• Parameters

  • timer: number

  Returns void

• clearTimeout(label): void

• Parameters

  • label: string

  Returns void

debounce

• debounce(fn, timeout, firstCallImmediately?): CallbackFunction<any>

• Debouncing enforces that a function not be called again until a certain amount of time has passed without it being called. As in "execute this function only if 100 milliseconds have passed without it being called."

  Parameters

  • fn: CallbackFunction<any>

  • timeout: IAsyncParams | ITimeout

  • firstCallImmediately: boolean = false

  Returns CallbackFunction<any>

  Example

  var jodit = Jodit.make('.editor');
  jodit.e.on('mousemove', jodit.async.debounce(() => {
      // Do expensive things
  }, 100));
  Copy

delay

• delay(timeout): RejectablePromise<void>

• Parameters

  • timeout: number | IAsyncParams

  Returns RejectablePromise<void>

destruct

• destruct(): any

• Returns any

microDebounce

• microDebounce<T>(fn, firstCallImmediately?): T

• Type Parameters

  • T extends CallbackFunction<any>

  Parameters

  • fn: T

  • firstCallImmediately: boolean = false

  Returns T

promise

• promise<T>(executor): RejectablePromise<T>

• Type Parameters

  • T

  Parameters

  • executor: ((resolve, reject) => void)

    • • (resolve, reject): void

      • Parameters

        • resolve: ((value) => void)

          • • (value): void

            • Parameters

              • value: T | PromiseLike<T>

              Returns void

        • reject: ((reason?) => void)

          • • (reason?): void

            • Parameters

              • Optional reason: any

              Returns void

        Returns void

  Returns RejectablePromise<T>

promiseState

• promiseState(p): Promise<"pending" | "fulfilled" | "rejected">

• Get Promise status

  Parameters

  • p: Promise<any>

  Returns Promise<"pending" | "fulfilled" | "rejected">

requestAnimationFrame

• requestAnimationFrame(callback): number

• Smart wrapper for requestAnimationFrame

  Parameters

  • callback: FrameRequestCallback

  Returns number

requestIdleCallback

• requestIdleCallback(callback, options?): number

• Parameters

  • callback: IdleRequestCallback

  • Optional options: {
        timeout: number;
    }

    • timeout: number

  Returns number

requestIdlePromise

• requestIdlePromise(options?): RejectablePromise<number>

• Parameters

  • Optional options: {
        timeout: number;
    }

    • timeout: number

  Returns RejectablePromise<number>

setTimeout

• setTimeout(callback, timeout, ...args): number

• Parameters

  • callback: Callback

  • timeout: number | IAsyncParams

  • Rest ...args: any[]

  Returns number

throttle

• throttle(fn, timeout, ignore?): CallbackFunction<any>

• Throttling enforces a maximum number of times a function can be called over time. As in "execute this function at most once every 100 milliseconds."

  Parameters

  • fn: CallbackFunction<any>

  • timeout: IAsyncParams | ITimeout

  • ignore: boolean = false

  Returns CallbackFunction<any>

  Example

  var jodit = Jodit.make('.editor');
  jodit.e.on(document.body, 'scroll', jodit.async.throttle(function() {
      // Do expensive things
  }, 100));
  Copy

updateTimeout

• updateTimeout(label, timeout): Nullable<number>

• Parameters

  • label: string

  • timeout: number

  Returns Nullable<number>