Method fireAsync

src/platform/common/utils/events.ts:75–122

(data: IWaitUntilData<T>, token: CancellationToken)

    }

    async fireAsync(data: IWaitUntilData<T>, token: CancellationToken): Promise<void> {
        if (!this._listeners) {
            return;
        }

        if (!this._asyncDeliveryQueue) {
            this._asyncDeliveryQueue = [];
        }

        for (const listener of this._listeners) {
            this._asyncDeliveryQueue!.push([listener, data]);
        }

        while (this._asyncDeliveryQueue.length > 0 && !token.isCancellationRequested) {
            const [listener, data] = this._asyncDeliveryQueue.shift()!;
            const thenables: Promise<unknown>[] = [];

            const event = <T>{
                ...data,
                token,
                waitUntil: (p: Promise<unknown>): void => {
                    if (Object.isFrozen(thenables)) {
                        throw new Error('waitUntil can NOT be called asynchronous');
                    }
                    thenables.push(p);
                }
            };

            try {
                listener(event);
            } catch (e) {
                console.error(e);
                continue;
            }

            // freeze thenables-collection to enforce sync-calls to
            // wait until and then wait for all thenables to resolve
            Object.freeze(thenables);

            await Promise.allSettled(thenables).then((values) => {
                for (const value of values) {
                    if (value.status === 'rejected') {
                        console.error(value.reason);
                    }
                }
            });
        }
    }

    dispose(): void {
        this._listeners.clear();