@codingame/monaco-vscode-views-service-override 1.83.10-next.0 → 1.83.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-views-service-override",
-  "version": "1.83.10-next.0",
+  "version": "1.83.11",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,14 +18,14 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.10-next.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.11",
     "monaco-editor": "0.44.0",
-    "@codingame/monaco-vscode-bulk-edit-service-override": "1.83.10-next.0",
-    "@codingame/monaco-vscode-layout-service-override": "1.83.10-next.0",
-    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.10-next.0",
-    "@codingame/monaco-vscode-keybindings-service-override": "1.83.10-next.0",
-    "@codingame/monaco-vscode-environment-service-override": "1.83.10-next.0",
-    "@codingame/monaco-vscode-extensions-service-override": "1.83.10-next.0",
-    "@codingame/monaco-vscode-files-service-override": "1.83.10-next.0"
+    "@codingame/monaco-vscode-bulk-edit-service-override": "1.83.11",
+    "@codingame/monaco-vscode-layout-service-override": "1.83.11",
+    "@codingame/monaco-vscode-quickaccess-service-override": "1.83.11",
+    "@codingame/monaco-vscode-keybindings-service-override": "1.83.11",
+    "@codingame/monaco-vscode-environment-service-override": "1.83.11",
+    "@codingame/monaco-vscode-extensions-service-override": "1.83.11",
+    "@codingame/monaco-vscode-files-service-override": "1.83.11"
   }
 }

package/views.js

@@ -88,6 +88,8 @@ export { ConfirmResult } from './override/vs/platform/dialogs/common/dialogs.js'
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
 import { IBannerService } from 'vscode/vscode/vs/workbench/services/banner/browser/bannerService';
 import { ITitleService } from 'vscode/vscode/vs/workbench/services/title/common/titleService';
+import { IProgressService } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { ProgressService } from './vscode/src/vs/workbench/services/progress/browser/progressService.js';
 import { DomScrollableElement } from 'monaco-editor/esm/vs/base/browser/ui/scrollbar/scrollableElement.js';
 import { assertAllDefined, assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
 export { AbstractResourceEditorInput } from 'vscode/vscode/vs/workbench/common/editor/resourceEditorInput';
@@ -544,7 +546,8 @@ function getServiceOverride(openEditorFallback, _webviewIframeAlternateDomains,
         [( ICustomEditorService.toString())]: new SyncDescriptor(CustomEditorService, [], true),
         [( IWebviewService.toString())]: new SyncDescriptor(WebviewService, [], true),
         [( IWebviewViewService.toString())]: new SyncDescriptor(WebviewViewService, [], true),
-        [( IWebviewWorkbenchService.toString())]: new SyncDescriptor(WebviewEditorService, [], true)
+        [( IWebviewWorkbenchService.toString())]: new SyncDescriptor(WebviewEditorService, [], true),
+        [( IProgressService.toString())]: new SyncDescriptor(ProgressService, [], true)
     };
 }
 

package/vscode/src/vs/workbench/services/progress/browser/media/progressService.css.js

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .progress-badge>.badge-content:before{background-color:currentColor;bottom:0;content:\"\";height:14px;left:0;margin:auto;mask:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMiAyIDE0IDE0Ij48cGF0aCBmaWxsPSIjZmZmIiBkPSJNOSAxNmMtMy44NiAwLTctMy4xNC03LTdzMy4xNC03IDctN2MzLjg1OSAwIDcgMy4xNDEgNyA3cy0zLjE0MSA3LTcgN3pNOSAzLjRDNS45MTIgMy40IDMuNCA1LjkxMyAzLjQgOXMyLjUxMiA1LjYgNS42IDUuNiA1LjYtMi41MTIgNS42LTUuNlMxMi4wODggMy40IDkgMy40em0zLjg2IDcuMUw5LjcgOC42MDRWNC44SDguM3Y0LjU5NmwzLjg0IDIuMzA1LjcyLTEuMjAxeiIvPjwvc3ZnPg==\");-webkit-mask:url(\"data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNCIgaGVpZ2h0PSIxNCIgdmlld0JveD0iMiAyIDE0IDE0Ij48cGF0aCBmaWxsPSIjZmZmIiBkPSJNOSAxNmMtMy44NiAwLTctMy4xNC03LTdzMy4xNC03IDctN2MzLjg1OSAwIDcgMy4xNDEgNyA3cy0zLjE0MSA3LTcgN3pNOSAzLjRDNS45MTIgMy40IDMuNCA1LjkxMyAzLjQgOXMyLjUxMiA1LjYgNS42IDUuNiA1LjYtMi41MTIgNS42LTUuNlMxMi4wODggMy40IDkgMy40em0zLjg2IDcuMUw5LjcgOC42MDRWNC44SDguM3Y0LjU5NmwzLjg0IDIuMzA1LjcyLTEuMjAxeiIvPjwvc3ZnPg==\");position:absolute;right:0;top:0;width:14px}";
+n(css,{});
+
+export { css, css as default };

package/vscode/src/vs/workbench/services/progress/browser/progressService.js

@@ -0,0 +1,512 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import './media/progressService.css.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { Disposable, dispose, DisposableStore, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { IStatusbarService } from 'vscode/vscode/vs/workbench/services/statusbar/browser/statusbar';
+import { timeout, RunOnceScheduler, DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ProgressBadge, IActivityService } from 'vscode/vscode/vs/workbench/services/activity/common/activity';
+import { NotificationPriority, INotificationService, Severity } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Emitter, Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { Dialog } from 'monaco-editor/esm/vs/base/browser/ui/dialog/dialog.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { EventHelper } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { parseLinkedText } from 'monaco-editor/esm/vs/base/common/linkedText.js';
+import { IViewDescriptorService, IViewsService } from 'vscode/vscode/vs/workbench/common/views';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { stripIcons } from 'monaco-editor/esm/vs/base/common/iconLabels.js';
+import { defaultButtonStyles, defaultCheckboxStyles, defaultInputBoxStyles, defaultDialogStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+
+let ProgressService = class ProgressService extends Disposable {
+    constructor(activityService, paneCompositeService, viewDescriptorService, viewsService, notificationService, statusbarService, layoutService, keybindingService) {
+        super();
+        this.activityService = activityService;
+        this.paneCompositeService = paneCompositeService;
+        this.viewDescriptorService = viewDescriptorService;
+        this.viewsService = viewsService;
+        this.notificationService = notificationService;
+        this.statusbarService = statusbarService;
+        this.layoutService = layoutService;
+        this.keybindingService = keybindingService;
+        this.windowProgressStack = [];
+        this.windowProgressStatusEntry = undefined;
+    }
+    async withProgress(options, task, onDidCancel) {
+        const { location } = options;
+        const handleStringLocation = (location) => {
+            const viewContainer = this.viewDescriptorService.getViewContainerById(location);
+            if (viewContainer) {
+                const viewContainerLocation = this.viewDescriptorService.getViewContainerLocation(viewContainer);
+                if (viewContainerLocation !== null) {
+                    return this.withPaneCompositeProgress(location, viewContainerLocation, task, { ...options, location });
+                }
+            }
+            if (this.viewDescriptorService.getViewDescriptorById(location) !== null) {
+                return this.withViewProgress(location, task, { ...options, location });
+            }
+            throw new Error(`Bad progress location: ${location}`);
+        };
+        if (typeof location === 'string') {
+            return handleStringLocation(location);
+        }
+        switch (location) {
+            case 15 :
+                return this.withNotificationProgress({ ...options, location, priority: this.notificationService.doNotDisturbMode ? NotificationPriority.SILENT : undefined }, task, onDidCancel);
+            case 10 : {
+                const type = options.type;
+                if (options.command) {
+                    return this.withWindowProgress({ ...options, location, type }, task);
+                }
+                return this.withNotificationProgress({ delay: 150 , ...options, priority: NotificationPriority.SILENT, location: 15 , type }, task, onDidCancel);
+            }
+            case 1 :
+                return this.withPaneCompositeProgress('workbench.view.explorer', 0 , task, { ...options, location });
+            case 3 :
+                return handleStringLocation('workbench.scm');
+            case 5 :
+                return this.withPaneCompositeProgress('workbench.view.extensions', 0 , task, { ...options, location });
+            case 20 :
+                return this.withDialogProgress(options, task, onDidCancel);
+            default:
+                throw new Error(`Bad progress location: ${location}`);
+        }
+    }
+    withWindowProgress(options, callback) {
+        const task = [options, ( new Progress(() => this.updateWindowProgress()))];
+        const promise = callback(task[1]);
+        let delayHandle = setTimeout(() => {
+            delayHandle = undefined;
+            this.windowProgressStack.unshift(task);
+            this.updateWindowProgress();
+            Promise.all([
+                timeout(150),
+                promise
+            ]).finally(() => {
+                const idx = this.windowProgressStack.indexOf(task);
+                this.windowProgressStack.splice(idx, 1);
+                this.updateWindowProgress();
+            });
+        }, 150);
+        return promise.finally(() => clearTimeout(delayHandle));
+    }
+    updateWindowProgress(idx = 0) {
+        if (idx < this.windowProgressStack.length) {
+            const [options, progress] = this.windowProgressStack[idx];
+            const progressTitle = options.title;
+            const progressMessage = progress.value && progress.value.message;
+            const progressCommand = options.command;
+            let text;
+            let title;
+            const source = options.source && typeof options.source !== 'string' ? options.source.label : options.source;
+            if (progressTitle && progressMessage) {
+                text = ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.text2',
+                    "{0}: {1}",
+                    progressTitle,
+                    progressMessage
+                ));
+                title = source ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.title3',
+                    "[{0}] {1}: {2}",
+                    source,
+                    progressTitle,
+                    progressMessage
+                )) : text;
+            }
+            else if (progressTitle) {
+                text = progressTitle;
+                title = source ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.title2',
+                    "[{0}]: {1}",
+                    source,
+                    progressTitle
+                )) : text;
+            }
+            else if (progressMessage) {
+                text = progressMessage;
+                title = source ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'progress.title2',
+                    "[{0}]: {1}",
+                    source,
+                    progressMessage
+                )) : text;
+            }
+            else {
+                this.updateWindowProgress(idx + 1);
+                return;
+            }
+            const statusEntryProperties = {
+                name: ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'status.progress',
+                    "Progress Message"
+                )),
+                text,
+                showProgress: options.type || true,
+                ariaLabel: text,
+                tooltip: title,
+                command: progressCommand
+            };
+            if (this.windowProgressStatusEntry) {
+                this.windowProgressStatusEntry.update(statusEntryProperties);
+            }
+            else {
+                this.windowProgressStatusEntry = this.statusbarService.addEntry(statusEntryProperties, 'status.progress', 0 );
+            }
+        }
+        else {
+            this.windowProgressStatusEntry?.dispose();
+            this.windowProgressStatusEntry = undefined;
+        }
+    }
+    withNotificationProgress(options, callback, onDidCancel) {
+        const progressStateModel = new (class extends Disposable {
+            get step() { return this._step; }
+            get done() { return this._done; }
+            constructor() {
+                super();
+                this._onDidReport = this._register(( new Emitter()));
+                this.onDidReport = this._onDidReport.event;
+                this._onWillDispose = this._register(( new Emitter()));
+                this.onWillDispose = this._onWillDispose.event;
+                this._step = undefined;
+                this._done = false;
+                this.promise = callback(this);
+                this.promise.finally(() => {
+                    this.dispose();
+                });
+            }
+            report(step) {
+                this._step = step;
+                this._onDidReport.fire(step);
+            }
+            cancel(choice) {
+                onDidCancel?.(choice);
+                this.dispose();
+            }
+            dispose() {
+                this._done = true;
+                this._onWillDispose.fire();
+                super.dispose();
+            }
+        });
+        const createWindowProgress = () => {
+            const promise = ( new DeferredPromise());
+            this.withWindowProgress({
+                location: 10 ,
+                title: options.title ? ( parseLinkedText(options.title).toString()) : undefined,
+                command: 'notifications.showList',
+                type: options.type
+            }, progress => {
+                function reportProgress(step) {
+                    if (step.message) {
+                        progress.report({
+                            message: ( parseLinkedText(step.message).toString())
+                        });
+                    }
+                }
+                if (progressStateModel.step) {
+                    reportProgress(progressStateModel.step);
+                }
+                const onDidReportListener = progressStateModel.onDidReport(step => reportProgress(step));
+                promise.p.finally(() => onDidReportListener.dispose());
+                Event.once(progressStateModel.onWillDispose)(() => promise.complete());
+                return promise.p;
+            });
+            return toDisposable(() => promise.complete());
+        };
+        const createNotification = (message, priority, increment) => {
+            const notificationDisposables = ( new DisposableStore());
+            const primaryActions = options.primaryActions ? Array.from(options.primaryActions) : [];
+            const secondaryActions = options.secondaryActions ? Array.from(options.secondaryActions) : [];
+            if (options.buttons) {
+                options.buttons.forEach((button, index) => {
+                    const buttonAction = new (class extends Action {
+                        constructor() {
+                            super(`progress.button.${button}`, button, undefined, true);
+                        }
+                        async run() {
+                            progressStateModel.cancel(index);
+                        }
+                    });
+                    notificationDisposables.add(buttonAction);
+                    primaryActions.push(buttonAction);
+                });
+            }
+            if (options.cancellable) {
+                const cancelAction = new (class extends Action {
+                    constructor() {
+                        super('progress.cancel', ( localizeWithPath(
+                            'vs/workbench/services/progress/browser/progressService',
+                            'cancel',
+                            "Cancel"
+                        )), undefined, true);
+                    }
+                    async run() {
+                        progressStateModel.cancel();
+                    }
+                });
+                notificationDisposables.add(cancelAction);
+                primaryActions.push(cancelAction);
+            }
+            const notification = this.notificationService.notify({
+                severity: Severity.Info,
+                message: stripIcons(message),
+                source: options.source,
+                actions: { primary: primaryActions, secondary: secondaryActions },
+                progress: typeof increment === 'number' && increment >= 0 ? { total: 100, worked: increment } : { infinite: true },
+                priority
+            });
+            let windowProgressDisposable = undefined;
+            const onVisibilityChange = (visible) => {
+                dispose(windowProgressDisposable);
+                if (!visible && !progressStateModel.done) {
+                    windowProgressDisposable = createWindowProgress();
+                }
+            };
+            notificationDisposables.add(notification.onDidChangeVisibility(onVisibilityChange));
+            if (priority === NotificationPriority.SILENT) {
+                onVisibilityChange(false);
+            }
+            Event.once(notification.onDidClose)(() => notificationDisposables.dispose());
+            return notification;
+        };
+        const updateProgress = (notification, increment) => {
+            if (typeof increment === 'number' && increment >= 0) {
+                notification.progress.total(100);
+                notification.progress.worked(increment);
+            }
+            else {
+                notification.progress.infinite();
+            }
+        };
+        let notificationHandle;
+        let notificationTimeout;
+        let titleAndMessage;
+        const updateNotification = (step) => {
+            if (step?.message && options.title) {
+                titleAndMessage = `${options.title}: ${step.message}`;
+            }
+            else {
+                titleAndMessage = options.title || step?.message;
+            }
+            if (!notificationHandle && titleAndMessage) {
+                if (typeof options.delay === 'number' && options.delay > 0) {
+                    if (typeof notificationTimeout !== 'number') {
+                        notificationTimeout = setTimeout(() => notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment), options.delay);
+                    }
+                }
+                else {
+                    notificationHandle = createNotification(titleAndMessage, options.priority, step?.increment);
+                }
+            }
+            if (notificationHandle) {
+                if (titleAndMessage) {
+                    notificationHandle.updateMessage(titleAndMessage);
+                }
+                if (typeof step?.increment === 'number') {
+                    updateProgress(notificationHandle, step.increment);
+                }
+            }
+        };
+        updateNotification(progressStateModel.step);
+        const listener = progressStateModel.onDidReport(step => updateNotification(step));
+        Event.once(progressStateModel.onWillDispose)(() => listener.dispose());
+        (async () => {
+            try {
+                if (typeof options.delay === 'number' && options.delay > 0) {
+                    await progressStateModel.promise;
+                }
+                else {
+                    await Promise.all([timeout(800), progressStateModel.promise]);
+                }
+            }
+            finally {
+                clearTimeout(notificationTimeout);
+                notificationHandle?.close();
+            }
+        })();
+        return progressStateModel.promise;
+    }
+    withPaneCompositeProgress(paneCompositeId, viewContainerLocation, task, options) {
+        const progressIndicator = this.paneCompositeService.getProgressIndicator(paneCompositeId, viewContainerLocation);
+        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
+        if (viewContainerLocation === 0 ) {
+            this.showOnActivityBar(paneCompositeId, options, promise);
+        }
+        return promise;
+    }
+    withViewProgress(viewId, task, options) {
+        const progressIndicator = this.viewsService.getViewProgressIndicator(viewId);
+        const promise = progressIndicator ? this.withCompositeProgress(progressIndicator, task, options) : task({ report: () => { } });
+        const location = this.viewDescriptorService.getViewLocationById(viewId);
+        if (location !== 0 ) {
+            return promise;
+        }
+        const viewletId = this.viewDescriptorService.getViewContainerByViewId(viewId)?.id;
+        if (viewletId === undefined) {
+            return promise;
+        }
+        this.showOnActivityBar(viewletId, options, promise);
+        return promise;
+    }
+    showOnActivityBar(viewletId, options, promise) {
+        let activityProgress;
+        let delayHandle = setTimeout(() => {
+            delayHandle = undefined;
+            const handle = this.activityService.showViewContainerActivity(viewletId, { badge: ( new ProgressBadge(() => '')), clazz: 'progress-badge', priority: 100 });
+            const startTimeVisible = Date.now();
+            const minTimeVisible = 300;
+            activityProgress = {
+                dispose() {
+                    const d = Date.now() - startTimeVisible;
+                    if (d < minTimeVisible) {
+                        setTimeout(() => handle.dispose(), minTimeVisible - d);
+                    }
+                    else {
+                        handle.dispose();
+                    }
+                }
+            };
+        }, options.delay || 300);
+        promise.finally(() => {
+            clearTimeout(delayHandle);
+            dispose(activityProgress);
+        });
+    }
+    withCompositeProgress(progressIndicator, task, options) {
+        let discreteProgressRunner = undefined;
+        function updateProgress(stepOrTotal) {
+            let total = undefined;
+            let increment = undefined;
+            if (typeof stepOrTotal !== 'undefined') {
+                if (typeof stepOrTotal === 'number') {
+                    total = stepOrTotal;
+                }
+                else if (typeof stepOrTotal.increment === 'number') {
+                    total = stepOrTotal.total ?? 100;
+                    increment = stepOrTotal.increment;
+                }
+            }
+            if (typeof total === 'number') {
+                if (!discreteProgressRunner) {
+                    discreteProgressRunner = progressIndicator.show(total, options.delay);
+                    promise.catch(() => undefined ).finally(() => discreteProgressRunner?.done());
+                }
+                if (typeof increment === 'number') {
+                    discreteProgressRunner.worked(increment);
+                }
+            }
+            else {
+                discreteProgressRunner?.done();
+                progressIndicator.showWhile(promise, options.delay);
+            }
+            return discreteProgressRunner;
+        }
+        const promise = task({
+            report: progress => {
+                updateProgress(progress);
+            }
+        });
+        updateProgress(options.total);
+        return promise;
+    }
+    withDialogProgress(options, task, onDidCancel) {
+        const disposables = ( new DisposableStore());
+        const allowableCommands = [
+            'workbench.action.quit',
+            'workbench.action.reloadWindow',
+            'copy',
+            'cut',
+            'editor.action.clipboardCopyAction',
+            'editor.action.clipboardCutAction'
+        ];
+        let dialog;
+        const createDialog = (message) => {
+            const buttons = options.buttons || [];
+            if (!options.sticky) {
+                buttons.push(options.cancellable ? ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'cancel',
+                    "Cancel"
+                )) : ( localizeWithPath(
+                    'vs/workbench/services/progress/browser/progressService',
+                    'dismiss',
+                    "Dismiss"
+                )));
+            }
+            dialog = ( new Dialog(this.layoutService.container, message, buttons, {
+                type: 'pending',
+                detail: options.detail,
+                cancelId: buttons.length - 1,
+                disableCloseAction: options.sticky,
+                disableDefaultAction: options.sticky,
+                keyEventProcessor: (event) => {
+                    const resolved = this.keybindingService.softDispatch(event, this.layoutService.container);
+                    if (resolved.kind === 2  && resolved.commandId) {
+                        if (!allowableCommands.includes(resolved.commandId)) {
+                            EventHelper.stop(event, true);
+                        }
+                    }
+                },
+                buttonStyles: defaultButtonStyles,
+                checkboxStyles: defaultCheckboxStyles,
+                inputBoxStyles: defaultInputBoxStyles,
+                dialogStyles: defaultDialogStyles
+            }));
+            disposables.add(dialog);
+            dialog.show().then(dialogResult => {
+                onDidCancel?.(dialogResult.button);
+                dispose(dialog);
+            });
+            return dialog;
+        };
+        let delay = options.delay ?? 0;
+        let latestMessage = undefined;
+        const scheduler = disposables.add(( new RunOnceScheduler(() => {
+            delay = 0;
+            if (latestMessage && !dialog) {
+                dialog = createDialog(latestMessage);
+            }
+            else if (latestMessage) {
+                dialog.updateMessage(latestMessage);
+            }
+        }, 0)));
+        const updateDialog = function (message) {
+            latestMessage = message;
+            if (!scheduler.isScheduled()) {
+                scheduler.schedule(delay);
+            }
+        };
+        const promise = task({
+            report: progress => {
+                updateDialog(progress.message);
+            }
+        });
+        promise.finally(() => {
+            dispose(disposables);
+        });
+        if (options.title) {
+            updateDialog(options.title);
+        }
+        return promise;
+    }
+};
+ProgressService = ( __decorate([
+    ( __param(0, IActivityService)),
+    ( __param(1, IPaneCompositePartService)),
+    ( __param(2, IViewDescriptorService)),
+    ( __param(3, IViewsService)),
+    ( __param(4, INotificationService)),
+    ( __param(5, IStatusbarService)),
+    ( __param(6, ILayoutService)),
+    ( __param(7, IKeybindingService))
+], ProgressService));
+
+export { ProgressService };