@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibilityStatus.js

@@ -0,0 +1,112 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable, MutableDisposable } from '../../../../base/common/lifecycle.js';
+import { Event } from '../../../../base/common/event.js';
+import Severity$1 from '../../../../base/common/severity.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { CommandsRegistry } from '../../../../platform/commands/common/commands.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { NotificationPriority, INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
+let AccessibilityStatus = class AccessibilityStatus extends Disposable {
+    static { this.ID = 'workbench.contrib.accessibilityStatus'; }
+    constructor(configurationService, notificationService, accessibilityService, statusbarService) {
+        super();
+        this.configurationService = configurationService;
+        this.notificationService = notificationService;
+        this.accessibilityService = accessibilityService;
+        this.statusbarService = statusbarService;
+        this.screenReaderNotification = null;
+        this.promptedScreenReader = false;
+        this.screenReaderModeElement = this._register(( new MutableDisposable()));
+        this._register(CommandsRegistry.registerCommand({ id: 'showEditorScreenReaderNotification', handler: () => this.showScreenReaderNotification() }));
+        this.updateScreenReaderModeElement(this.accessibilityService.isScreenReaderOptimized());
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.accessibilityService.onDidChangeScreenReaderOptimized(() => this.onScreenReaderModeChange()));
+        this._register(this.configurationService.onDidChangeConfiguration(c => {
+            if (c.affectsConfiguration('editor.accessibilitySupport')) {
+                this.onScreenReaderModeChange();
+            }
+        }));
+    }
+    showScreenReaderNotification() {
+        this.screenReaderNotification = this.notificationService.prompt(Severity$1.Info, ( localizeWithPath(
+            'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+            'screenReaderDetectedExplanation.question',
+            "Are you using a screen reader to operate VS Code?"
+        )), [{
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                    'screenReaderDetectedExplanation.answerYes',
+                    "Yes"
+                )),
+                run: () => {
+                    this.configurationService.updateValue('editor.accessibilitySupport', 'on', 2 );
+                }
+            }, {
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                    'screenReaderDetectedExplanation.answerNo',
+                    "No"
+                )),
+                run: () => {
+                    this.configurationService.updateValue('editor.accessibilitySupport', 'off', 2 );
+                }
+            }], {
+            sticky: true,
+            priority: NotificationPriority.URGENT
+        });
+        Event.once(this.screenReaderNotification.onDidClose)(() => this.screenReaderNotification = null);
+    }
+    updateScreenReaderModeElement(visible) {
+        if (visible) {
+            if (!this.screenReaderModeElement.value) {
+                const text = ( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                    'screenReaderDetected',
+                    "Screen Reader Optimized"
+                ));
+                this.screenReaderModeElement.value = this.statusbarService.addEntry({
+                    name: ( localizeWithPath(
+                        'vs/workbench/contrib/accessibility/browser/accessibilityStatus',
+                        'status.editor.screenReaderMode',
+                        "Screen Reader Mode"
+                    )),
+                    text,
+                    ariaLabel: text,
+                    command: 'showEditorScreenReaderNotification',
+                    kind: 'prominent',
+                    showInAllWindows: true
+                }, 'status.editor.screenReaderMode', 1 , 100.6);
+            }
+        }
+        else {
+            this.screenReaderModeElement.clear();
+        }
+    }
+    onScreenReaderModeChange() {
+        const screenReaderDetected = this.accessibilityService.isScreenReaderOptimized();
+        if (screenReaderDetected) {
+            const screenReaderConfiguration = this.configurationService.getValue('editor.accessibilitySupport');
+            if (screenReaderConfiguration === 'auto') {
+                if (!this.promptedScreenReader) {
+                    this.promptedScreenReader = true;
+                    setTimeout(() => this.showScreenReaderNotification(), 100);
+                }
+            }
+        }
+        if (this.screenReaderNotification) {
+            this.screenReaderNotification.close();
+        }
+        this.updateScreenReaderModeElement(this.accessibilityService.isScreenReaderOptimized());
+    }
+};
+AccessibilityStatus = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, INotificationService)),
+    ( __param(2, IAccessibilityService)),
+    ( __param(3, IStatusbarService))
+], AccessibilityStatus));
+export { AccessibilityStatus };

package/vscode/src/vs/workbench/contrib/accessibility/browser/openDiffEditorAnnouncement.js

@@ -0,0 +1,50 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { Event } from '../../../../base/common/event.js';
+let DiffEditorActiveAnnouncementContribution = class DiffEditorActiveAnnouncementContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.diffEditorActiveAnnouncement'; }
+    constructor(_editorService, _accessibilityService, _configurationService) {
+        super();
+        this._editorService = _editorService;
+        this._accessibilityService = _accessibilityService;
+        this._configurationService = _configurationService;
+        this._register(Event.runAndSubscribe(_accessibilityService.onDidChangeScreenReaderOptimized, () => this._updateListener()));
+        this._register(_configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration("accessibility.verbosity.diffEditorActive" )) {
+                this._updateListener();
+            }
+        }));
+    }
+    _updateListener() {
+        const announcementEnabled = this._configurationService.getValue("accessibility.verbosity.diffEditorActive" );
+        const screenReaderOptimized = this._accessibilityService.isScreenReaderOptimized();
+        if (!announcementEnabled || !screenReaderOptimized) {
+            this._onDidActiveEditorChangeListener?.dispose();
+            this._onDidActiveEditorChangeListener = undefined;
+            return;
+        }
+        if (this._onDidActiveEditorChangeListener) {
+            return;
+        }
+        this._onDidActiveEditorChangeListener = this._register(this._editorService.onDidActiveEditorChange(() => {
+            if (isDiffEditor(this._editorService.activeTextEditorControl)) {
+                this._accessibilityService.alert(( localizeWithPath(
+                    'vs/workbench/contrib/accessibility/browser/openDiffEditorAnnouncement',
+                    'openDiffEditorAnnouncement',
+                    "Diff editor"
+                )));
+            }
+        }));
+    }
+};
+DiffEditorActiveAnnouncementContribution = ( __decorate([
+    ( __param(0, IEditorService)),
+    ( __param(1, IAccessibilityService)),
+    ( __param(2, IConfigurationService))
+], DiffEditorActiveAnnouncementContribution));
+export { DiffEditorActiveAnnouncementContribution };

package/vscode/src/vs/workbench/contrib/accessibility/browser/saveAccessibilitySignal.js

@@ -0,0 +1,18 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { AccessibilitySignal, IAccessibilitySignalService } from '../../../../platform/accessibilitySignal/browser/accessibilitySignalService.js';
+import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
+let SaveAccessibilitySignalContribution = class SaveAccessibilitySignalContribution extends Disposable {
+    static { this.ID = 'workbench.contrib.saveAccessibilitySignal'; }
+    constructor(_accessibilitySignalService, _workingCopyService) {
+        super();
+        this._accessibilitySignalService = _accessibilitySignalService;
+        this._workingCopyService = _workingCopyService;
+        this._register(this._workingCopyService.onDidSave(e => this._accessibilitySignalService.playSignal(AccessibilitySignal.save, { userGesture: e.reason === 1  })));
+    }
+};
+SaveAccessibilitySignalContribution = ( __decorate([
+    ( __param(0, IAccessibilitySignalService)),
+    ( __param(1, IWorkingCopyService))
+], SaveAccessibilitySignalContribution));
+export { SaveAccessibilitySignalContribution };

package/vscode/src/vs/workbench/contrib/accessibility/browser/unfocusedViewDimmingContribution.js

@@ -0,0 +1,66 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { createStyleSheet } from '../../../../base/browser/dom.js';
+import { Event } from '../../../../base/common/event.js';
+import { Disposable, toDisposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { clamp } from '../../../../base/common/numbers.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+let UnfocusedViewDimmingContribution = class UnfocusedViewDimmingContribution extends Disposable {
+    constructor(configurationService) {
+        super();
+        this._styleElementDisposables = undefined;
+        this._register(toDisposable(() => this._removeStyleElement()));
+        this._register(Event.runAndSubscribe(configurationService.onDidChangeConfiguration, e => {
+            if (e && !e.affectsConfiguration("accessibility.dimUnfocused.enabled" ) && !e.affectsConfiguration("accessibility.dimUnfocused.opacity" )) {
+                return;
+            }
+            let cssTextContent = '';
+            const enabled = ensureBoolean(configurationService.getValue("accessibility.dimUnfocused.enabled" ), false);
+            if (enabled) {
+                const opacity = clamp(ensureNumber(configurationService.getValue("accessibility.dimUnfocused.opacity" ), 0.75 ), 0.2 , 1 );
+                if (opacity !== 1) {
+                    const rules = ( new Set());
+                    const filterRule = `filter: opacity(${opacity});`;
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal:not(:focus-within) .tabs-container { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .pane-body.integrated-terminal .terminal-wrapper:not(:focus-within) { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .breadcrumbs-below-tabs { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .terminal-wrapper { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .settings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .keybindings-editor { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .monaco-editor-pane-placeholder { ${filterRule} }`);
+                    rules.add(`.monaco-workbench .editor-instance:not(:focus-within) .gettingStartedContainer { ${filterRule} }`);
+                    cssTextContent = [...rules].join('\n');
+                }
+            }
+            if (cssTextContent.length === 0) {
+                this._removeStyleElement();
+            }
+            else {
+                this._getStyleElement().textContent = cssTextContent;
+            }
+        }));
+    }
+    _getStyleElement() {
+        if (!this._styleElement) {
+            this._styleElementDisposables = ( new DisposableStore());
+            this._styleElement = createStyleSheet(undefined, undefined, this._styleElementDisposables);
+            this._styleElement.className = 'accessibilityUnfocusedViewOpacity';
+        }
+        return this._styleElement;
+    }
+    _removeStyleElement() {
+        this._styleElementDisposables?.dispose();
+        this._styleElementDisposables = undefined;
+        this._styleElement = undefined;
+    }
+};
+UnfocusedViewDimmingContribution = ( __decorate([
+    ( __param(0, IConfigurationService))
+], UnfocusedViewDimmingContribution));
+function ensureBoolean(value, defaultValue) {
+    return typeof value === 'boolean' ? value : defaultValue;
+}
+function ensureNumber(value, defaultValue) {
+    return typeof value === 'number' ? value : defaultValue;
+}
+export { UnfocusedViewDimmingContribution };

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js

@@ -0,0 +1,358 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { toDisposable } from '../../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../../base/common/linkedList.js';
+import { ResourceMap, ResourceSet } from '../../../../base/common/map.js';
+import { isCodeEditor, isDiffEditor } from '../../../../editor/browser/editorBrowser.js';
+import { ResourceTextEdit, ResourceFileEdit } from '../../../../editor/browser/services/bulkEditService.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { Progress } from '../../../../platform/progress/common/progress.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { UndoRedoGroup } from '../../../../platform/undoRedo/common/undoRedo.js';
+import { ResourceNotebookCellEdit, BulkCellEdits } from './bulkCellEdits.js';
+import { BulkFileEdits } from './bulkFileEdits.js';
+import { BulkTextEdits } from './bulkTextEdits.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { ILifecycleService } from '../../../services/lifecycle/common/lifecycle.js';
+import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
+import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+function liftEdits(edits) {
+    return ( edits.map(edit => {
+        if (ResourceTextEdit.is(edit)) {
+            return ResourceTextEdit.lift(edit);
+        }
+        if (ResourceFileEdit.is(edit)) {
+            return ResourceFileEdit.lift(edit);
+        }
+        if (ResourceNotebookCellEdit.is(edit)) {
+            return ResourceNotebookCellEdit.lift(edit);
+        }
+        throw new Error('Unsupported edit');
+    }));
+}
+let BulkEdit = class BulkEdit {
+    constructor(_label, _code, _editor, _progress, _token, _edits, _undoRedoGroup, _undoRedoSource, _confirmBeforeUndo, _instaService, _logService) {
+        this._label = _label;
+        this._code = _code;
+        this._editor = _editor;
+        this._progress = _progress;
+        this._token = _token;
+        this._edits = _edits;
+        this._undoRedoGroup = _undoRedoGroup;
+        this._undoRedoSource = _undoRedoSource;
+        this._confirmBeforeUndo = _confirmBeforeUndo;
+        this._instaService = _instaService;
+        this._logService = _logService;
+    }
+    ariaMessage() {
+        const otherResources = ( new ResourceMap());
+        const textEditResources = ( new ResourceMap());
+        let textEditCount = 0;
+        for (const edit of this._edits) {
+            if (edit instanceof ResourceTextEdit) {
+                textEditCount += 1;
+                textEditResources.set(edit.resource, true);
+            }
+            else if (edit instanceof ResourceFileEdit) {
+                otherResources.set(edit.oldResource ?? edit.newResource, true);
+            }
+        }
+        if (this._edits.length === 0) {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'summary.0',
+                "Made no edits"
+            ));
+        }
+        else if (otherResources.size === 0) {
+            if (textEditCount > 1 && textEditResources.size > 1) {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'summary.nm',
+                    "Made {0} text edits in {1} files",
+                    textEditCount,
+                    textEditResources.size
+                ));
+            }
+            else {
+                return ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'summary.n0',
+                    "Made {0} text edits in one file",
+                    textEditCount
+                ));
+            }
+        }
+        else {
+            return ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'summary.textFiles',
+                "Made {0} text edits in {1} files, also created or deleted {2} files",
+                textEditCount,
+                textEditResources.size,
+                otherResources.size
+            ));
+        }
+    }
+    async perform() {
+        if (this._edits.length === 0) {
+            return [];
+        }
+        const ranges = [1];
+        for (let i = 1; i < this._edits.length; i++) {
+            if (Object.getPrototypeOf(this._edits[i - 1]) === Object.getPrototypeOf(this._edits[i])) {
+                ranges[ranges.length - 1]++;
+            }
+            else {
+                ranges.push(1);
+            }
+        }
+        const increment = this._edits.length > 1 ? 0 : undefined;
+        this._progress.report({ increment, total: 100 });
+        const progress = { report: _ => this._progress.report({ increment: 100 / this._edits.length }) };
+        const resources = [];
+        let index = 0;
+        for (const range of ranges) {
+            if (this._token.isCancellationRequested) {
+                break;
+            }
+            const group = this._edits.slice(index, index + range);
+            if (group[0] instanceof ResourceFileEdit) {
+                resources.push(await this._performFileEdits(group, this._undoRedoGroup, this._undoRedoSource, this._confirmBeforeUndo, progress));
+            }
+            else if (group[0] instanceof ResourceTextEdit) {
+                resources.push(await this._performTextEdits(group, this._undoRedoGroup, this._undoRedoSource, progress));
+            }
+            else if (group[0] instanceof ResourceNotebookCellEdit) {
+                resources.push(await this._performCellEdits(group, this._undoRedoGroup, this._undoRedoSource, progress));
+            }
+            else {
+                console.log('UNKNOWN EDIT');
+            }
+            index = index + range;
+        }
+        return resources.flat();
+    }
+    async _performFileEdits(edits, undoRedoGroup, undoRedoSource, confirmBeforeUndo, progress) {
+        this._logService.debug('_performFileEdits', JSON.stringify(edits));
+        const model = this._instaService.createInstance(BulkFileEdits, this._label || ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+            'workspaceEdit',
+            "Workspace Edit"
+        )), this._code || 'undoredo.workspaceEdit', undoRedoGroup, undoRedoSource, confirmBeforeUndo, progress, this._token, edits);
+        return await model.apply();
+    }
+    async _performTextEdits(edits, undoRedoGroup, undoRedoSource, progress) {
+        this._logService.debug('_performTextEdits', JSON.stringify(edits));
+        const model = this._instaService.createInstance(BulkTextEdits, this._label || ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+            'workspaceEdit',
+            "Workspace Edit"
+        )), this._code || 'undoredo.workspaceEdit', this._editor, undoRedoGroup, undoRedoSource, progress, this._token, edits);
+        return await model.apply();
+    }
+    async _performCellEdits(edits, undoRedoGroup, undoRedoSource, progress) {
+        this._logService.debug('_performCellEdits', JSON.stringify(edits));
+        const model = this._instaService.createInstance(BulkCellEdits, undoRedoGroup, undoRedoSource, progress, this._token, edits);
+        return await model.apply();
+    }
+};
+BulkEdit = ( __decorate([
+    ( __param(9, IInstantiationService)),
+    ( __param(10, ILogService))
+], BulkEdit));
+let BulkEditService = class BulkEditService {
+    constructor(_instaService, _logService, _editorService, _lifecycleService, _dialogService, _workingCopyService, _configService) {
+        this._instaService = _instaService;
+        this._logService = _logService;
+        this._editorService = _editorService;
+        this._lifecycleService = _lifecycleService;
+        this._dialogService = _dialogService;
+        this._workingCopyService = _workingCopyService;
+        this._configService = _configService;
+        this._activeUndoRedoGroups = ( new LinkedList());
+    }
+    setPreviewHandler(handler) {
+        this._previewHandler = handler;
+        return toDisposable(() => {
+            if (this._previewHandler === handler) {
+                this._previewHandler = undefined;
+            }
+        });
+    }
+    hasPreviewHandler() {
+        return Boolean(this._previewHandler);
+    }
+    async apply(editsIn, options) {
+        let edits = liftEdits(Array.isArray(editsIn) ? editsIn : editsIn.edits);
+        if (edits.length === 0) {
+            return { ariaSummary: ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'nothing',
+                "Made no edits"
+            )), isApplied: false };
+        }
+        if (this._previewHandler && (options?.showPreview || ( edits.some(value => value.metadata?.needsConfirmation)))) {
+            edits = await this._previewHandler(edits, options);
+        }
+        let codeEditor = options?.editor;
+        if (!codeEditor) {
+            const candidate = this._editorService.activeTextEditorControl;
+            if (isCodeEditor(candidate)) {
+                codeEditor = candidate;
+            }
+            else if (isDiffEditor(candidate)) {
+                codeEditor = candidate.getModifiedEditor();
+            }
+        }
+        if (codeEditor && codeEditor.getOption(91 )) {
+            codeEditor = undefined;
+        }
+        let undoRedoGroup;
+        let undoRedoGroupRemove = () => { };
+        if (typeof options?.undoRedoGroupId === 'number') {
+            for (const candidate of this._activeUndoRedoGroups) {
+                if (candidate.id === options.undoRedoGroupId) {
+                    undoRedoGroup = candidate;
+                    break;
+                }
+            }
+        }
+        if (!undoRedoGroup) {
+            undoRedoGroup = ( new UndoRedoGroup());
+            undoRedoGroupRemove = this._activeUndoRedoGroups.push(undoRedoGroup);
+        }
+        const label = options?.quotableLabel || options?.label;
+        const bulkEdit = this._instaService.createInstance(BulkEdit, label, options?.code, codeEditor, options?.progress ?? Progress.None, options?.token ?? CancellationToken.None, edits, undoRedoGroup, options?.undoRedoSource, !!options?.confirmBeforeUndo);
+        let listener;
+        try {
+            listener = this._lifecycleService.onBeforeShutdown(e => e.veto(this._shouldVeto(label, e.reason), 'veto.blukEditService'));
+            const resources = await bulkEdit.perform();
+            if (options?.respectAutoSaveConfig && this._configService.getValue(autoSaveSetting) === true && resources.length > 1) {
+                await this._saveAll(resources);
+            }
+            return { ariaSummary: bulkEdit.ariaMessage(), isApplied: edits.length > 0 };
+        }
+        catch (err) {
+            this._logService.error(err);
+            throw err;
+        }
+        finally {
+            listener?.dispose();
+            undoRedoGroupRemove();
+        }
+    }
+    async _saveAll(resources) {
+        const set = ( new ResourceSet(resources));
+        const saves = ( this._workingCopyService.dirtyWorkingCopies.map(async (copy) => {
+            if (( set.has(copy.resource))) {
+                await copy.save();
+            }
+        }));
+        const result = await Promise.allSettled(saves);
+        for (const item of result) {
+            if (item.status === 'rejected') {
+                this._logService.warn(item.reason);
+            }
+        }
+    }
+    async _shouldVeto(label, reason) {
+        let message;
+        let primaryButton;
+        switch (reason) {
+            case 1 :
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'closeTheWindow.message',
+                    "Are you sure you want to close the window?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'closeTheWindow', comment: ['&& denotes a mnemonic'] },
+                    "&&Close Window"
+                ));
+                break;
+            case 4 :
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'changeWorkspace.message',
+                    "Are you sure you want to change the workspace?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'changeWorkspace', comment: ['&& denotes a mnemonic'] },
+                    "Change &&Workspace"
+                ));
+                break;
+            case 3 :
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'reloadTheWindow.message',
+                    "Are you sure you want to reload the window?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'reloadTheWindow', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window"
+                ));
+                break;
+            default:
+                message = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'quit.message',
+                    "Are you sure you want to quit?"
+                ));
+                primaryButton = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    { key: 'quit', comment: ['&& denotes a mnemonic'] },
+                    "&&Quit"
+                ));
+                break;
+        }
+        const result = await this._dialogService.confirm({
+            message,
+            detail: ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'areYouSureQuiteBulkEdit.detail',
+                "'{0}' is in progress.",
+                label || ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                    'fileOperation',
+                    "File operation"
+                ))
+            )),
+            primaryButton
+        });
+        return !result.confirmed;
+    }
+};
+BulkEditService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, ILifecycleService)),
+    ( __param(4, IDialogService)),
+    ( __param(5, IWorkingCopyService)),
+    ( __param(6, IConfigurationService))
+], BulkEditService));
+const autoSaveSetting = 'files.refactoring.autoSave';
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: 'files',
+    properties: {
+        [autoSaveSetting]: {
+            description: ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/bulkEditService',
+                'refactoring.autoSave',
+                "Controls if files that were part of a refactoring are saved automatically"
+            )),
+            default: true,
+            type: 'boolean'
+        }
+    }
+});
+export { BulkEditService };