Class ProgressReporter

src/platform/progress/progressReporter.ts:17–106

 */
@injectable()
export class ProgressReporter implements IProgressReporter {
    private progressReporters: VSCProgress<{ message?: string | undefined; increment?: number | undefined }>[] = [];
    private actionPhases = new Map<ReportableAction, 'started' | 'completed'>();
    private currentActions: ReportableAction[] = [];
    private get currentAction(): ReportableAction | undefined {
        return this.currentActions.length === 0 ? undefined : this.currentActions[this.currentActions.length - 1];
    }

    constructor() {
        registerReporter(this);
    }

    /**
     * Create and display a progress indicator for starting of Jupyter Notebooks.
     *
     * @param {string} message
     * @returns {(IDisposable & { token: CancellationToken })}
     * @memberof ProgressReporter
     */
    public createProgressIndicator(message: string, cancellable = false): IDisposable & { token: CancellationToken } {
        const cancellation = new CancellationTokenSource();
        const deferred = createDeferred();
        const options = { location: ProgressLocation.Notification, cancellable: cancellable, title: message };

        window
            .withProgress(options, async (progress, cancelToken) => {
                cancelToken.onCancellationRequested(() => {
                    if (cancelToken.isCancellationRequested) {
                        cancellation.cancel();
                    }
                    deferred.resolve();
                });
                cancellation.token.onCancellationRequested(() => {
                    deferred.resolve();
                });
                this.progressReporters.push(progress);
                await deferred.promise;
            })
            .then(noop, noop);

        return {
            token: cancellation.token,
            dispose: () => deferred.resolve()
        };
    }

    /**
     * Reports progress to the user.
     * Keep messages in a stack. As we have new actions taking place place them in a stack and notify progress.
     * As they finish pop them from the stack (if currently displayed).
     * We need a stack, as we have multiple async actions taking place, and each stat & can complete at different times.
     *
     * @param {Progress} progress
     * @returns {void}
     * @memberof JupyterStartupProgressReporter
     */
    public report(progress: Progress): void {
        if (this.progressReporters.length === 0) {