Class DeferredPromise<T>

Deferred promise implementation.

Type Parameters

T

Hierarchy

DeferredPromise

Implements

Promise<T>

Index

Constructors

Properties

#innerPromise #isResolved #reject #resolve

Accessors

[toStringTag] isResolved

Methods

bind catch finally reject reset resolve then

Constructors

constructor

new DeferredPromise<T>(promise?): DeferredPromise<T>
Create a new deferrable promise which supports resolving it outside of the context of the promise.
Type Parameters
- T
Parameters
- Optional promise: Promise<T>
  
  Optionally a promise to wrap.
Returns DeferredPromise<T>
- Defined in packages/util/src/deferred.ts:22

Properties

`Private` #innerPromise

#innerPromise: Promise<T>

`Private` #isResolved

#isResolved: boolean = false

`Private` #reject

#reject: ((err) => void)

Type declaration

- (err): void
- Parameters
  - err: any
  Returns void

`Private` #resolve

#resolve: ((result) => void)

Type declaration

- (result): void
- Parameters
  - result: T | Promise<T>
  Returns void

Accessors

[toStringTag]

get [toStringTag](): string
Returns string
Implementation of Promise.[toStringTag]
- Defined in packages/util/src/deferred.ts:10

isResolved

get isResolved(): boolean
Returns boolean
- Defined in packages/util/src/deferred.ts:14

Methods

bind

bind(other): DeferredPromise<T>
Bind the current promise to another promise, resolving or rejecting the current promise when the other promise is resolved or rejected.
Parameters
- other: Promise<T>
  
  The other promise to bind to.
Returns DeferredPromise<T>
The current promise.
- Defined in packages/util/src/deferred.ts:35

catch

catch<TResult>(onrejected?): Promise<T | TResult>
Type Parameters
- TResult = never
Parameters
- Optional onrejected: ((reason) => TResult | PromiseLike<TResult>)
  - - (reason): TResult | PromiseLike<TResult>
    - Parameters
      
      reason: any
      
      Returns TResult | PromiseLike<TResult>
Returns Promise<T | TResult>
Implementation of Promise.catch
- Defined in packages/util/src/deferred.ts:69

finally

finally(onFinally?): Promise<T>
Parameters
- Optional onFinally: (() => void)
  - - (): void
    - Returns void
Returns Promise<T>
Implementation of Promise.finally
- Defined in packages/util/src/deferred.ts:73

reject

reject(err): void
Parameters
- err: any
Returns void
- Defined in packages/util/src/deferred.ts:49

reset

reset(): void
Returns void
- Defined in packages/util/src/deferred.ts:41

resolve

resolve(result): void
Parameters
- result: T | Promise<T>
Returns void
- Defined in packages/util/src/deferred.ts:57

then

then<TResult1, TResult2>(onfulfilled?, onrejected?): Promise<TResult1 | TResult2>
Type Parameters
- TResult1 = T
- TResult2 = never
Parameters
- Optional onfulfilled: ((value) => TResult1 | PromiseLike<TResult1>)
  - - (value): TResult1 | PromiseLike<TResult1>
    - Parameters
      
      value: T
      
      Returns TResult1 | PromiseLike<TResult1>
- Optional onrejected: ((reason) => TResult2 | PromiseLike<TResult2>)
  - - (reason): TResult2 | PromiseLike<TResult2>
    - Parameters
      
      reason: any
      
      Returns TResult2 | PromiseLike<TResult2>
Returns Promise<TResult1 | TResult2>
Implementation of Promise.then
- Defined in packages/util/src/deferred.ts:65