Logos DX
    Preparing search index...

    Class DeferredEvent<T>

    Creates a deferred promise that can be resolved or rejected externally.

    Provides a promise with externally accessible resolve and reject methods. Useful for creating promises that need to be controlled from outside their creation context.

    const deferred = new Deferred<string>();

    // Set up the promise consumer
    deferred.promise.then(result => {
        console.log('Got result:', result);
    });

    // Resolve from elsewhere
    setTimeout(() => {
        deferred.resolve('Hello world!');
    }, 1000);

    class AsyncQueue<T> {
        private pending = new Map<string, Deferred<T>>();

        async waitFor(id: string): Promise<T> {
            if (!this.pending.has(id)) {
                this.pending.set(id, new Deferred<T>());
            }
            return this.pending.get(id)!.promise;
        }

        complete(id: string, result: T) {
            const deferred = this.pending.get(id);
            if (deferred) {
                deferred.resolve(result);
                this.pending.delete(id);
            }
        }
    }

    // Coordinate multiple async operations
    const coordinateWork = () => {
        const coordinator = new Deferred<void>();
        let completed = 0;

        const checkComplete = () => {
            if (++completed === 3) {
                coordinator.resolve();
            }
        };

        doWork1().then(checkComplete);
        doWork2().then(checkComplete);
        doWork3().then(checkComplete);

        return coordinator.promise;
    };

    Type Parameters

    • T

    Hierarchy (View Summary)

    Index

    Constructors

    constructor

    Properties

    cleanup? promise reject resolve

    Constructors

    Properties

    cleanup?: () => void
    promise: EventPromise<T>
    reject: (reason?: string | Error) => void
    resolve: (value: T | PromiseLike<T>) => void

    Settings

    Member Visibility

    On This Page

    Constructors
    Properties