@codingame/monaco-vscode-api 1.78.5 → 1.78.6-next.0

package/dist/vscode/vs/workbench/common/views.js

@@ -1,5 +1,12 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { getOrSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { flatten } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { SetMap } from 'monaco-editor/esm/vs/base/common/collections.js';
+import { mixin } from 'monaco-editor/esm/vs/base/common/objects.js';
 import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
 import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
 const defaultViewIcon = ( registerIcon('default-view-icon', Codicon.window, ( localize('defaultViewIcon', 'Default view icon.'))));
@@ -8,6 +15,12 @@ var Extensions;
     Extensions.ViewContainersRegistry = 'workbench.registry.view.containers';
     Extensions.ViewsRegistry = 'workbench.registry.view';
 })(Extensions || (Extensions = {})));
+var ViewContainerLocation;
+( (function(ViewContainerLocation) {
+    ViewContainerLocation[ViewContainerLocation["Sidebar"] = 0] = "Sidebar";
+    ViewContainerLocation[ViewContainerLocation["Panel"] = 1] = "Panel";
+    ViewContainerLocation[ViewContainerLocation["AuxiliaryBar"] = 2] = "AuxiliaryBar";
+})(ViewContainerLocation || (ViewContainerLocation = {})));
 function ViewContainerLocationToString(viewContainerLocation) {
     switch (viewContainerLocation) {
         case 0 : return 'sidebar';
@@ -15,6 +28,268 @@ function ViewContainerLocationToString(viewContainerLocation) {
         case 2 : return 'auxiliarybar';
     }
 }
+class ViewContainersRegistryImpl extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onDidRegister = this._register(( new Emitter()));
+        this.onDidRegister = this._onDidRegister.event;
+        this._onDidDeregister = this._register(( new Emitter()));
+        this.onDidDeregister = this._onDidDeregister.event;
+        this.viewContainers = ( new Map());
+        this.defaultViewContainers = [];
+    }
+    get all() {
+        return flatten([...( this.viewContainers.values())]);
+    }
+    registerViewContainer(viewContainerDescriptor, viewContainerLocation, options) {
+        const existing = this.get(viewContainerDescriptor.id);
+        if (existing) {
+            return existing;
+        }
+        const viewContainer = viewContainerDescriptor;
+        viewContainer.openCommandActionDescriptor = options?.doNotRegisterOpenCommand ? undefined : (viewContainer.openCommandActionDescriptor ?? { id: viewContainer.id });
+        const viewContainers = getOrSet(this.viewContainers, viewContainerLocation, []);
+        viewContainers.push(viewContainer);
+        if (options?.isDefault) {
+            this.defaultViewContainers.push(viewContainer);
+        }
+        this._onDidRegister.fire({ viewContainer, viewContainerLocation });
+        return viewContainer;
+    }
+    deregisterViewContainer(viewContainer) {
+        for (const viewContainerLocation of ( this.viewContainers.keys())) {
+            const viewContainers = this.viewContainers.get(viewContainerLocation);
+            const index = viewContainers?.indexOf(viewContainer);
+            if (index !== -1) {
+                viewContainers?.splice(index, 1);
+                if (viewContainers.length === 0) {
+                    this.viewContainers.delete(viewContainerLocation);
+                }
+                this._onDidDeregister.fire({ viewContainer, viewContainerLocation });
+                return;
+            }
+        }
+    }
+    get(id) {
+        return this.all.filter(viewContainer => viewContainer.id === id)[0];
+    }
+    getViewContainers(location) {
+        return [...(this.viewContainers.get(location) || [])];
+    }
+    getViewContainerLocation(container) {
+        return [...( this.viewContainers.keys())].filter(location => this.getViewContainers(location).filter(viewContainer => viewContainer?.id === container.id).length > 0)[0];
+    }
+    getDefaultViewContainer(location) {
+        return this.defaultViewContainers.find(viewContainer => this.getViewContainerLocation(viewContainer) === location);
+    }
+}
+Registry.add(Extensions.ViewContainersRegistry, ( new ViewContainersRegistryImpl()));
+var ViewContentGroups;
+( (function(ViewContentGroups) {
+    ViewContentGroups["Open"] = "2_open";
+    ViewContentGroups["Debug"] = "4_debug";
+    ViewContentGroups["SCM"] = "5_scm";
+    ViewContentGroups["More"] = "9_more";
+})(ViewContentGroups || (ViewContentGroups = {})));
+function compareViewContentDescriptors(a, b) {
+    const aGroup = a.group ?? ViewContentGroups.More;
+    const bGroup = b.group ?? ViewContentGroups.More;
+    if (aGroup !== bGroup) {
+        return aGroup.localeCompare(bGroup);
+    }
+    return (a.order ?? 5) - (b.order ?? 5);
+}
+class ViewsRegistry extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._onViewsRegistered = this._register(( new Emitter()));
+        this.onViewsRegistered = this._onViewsRegistered.event;
+        this._onViewsDeregistered = this._register(( new Emitter()));
+        this.onViewsDeregistered = this._onViewsDeregistered.event;
+        this._onDidChangeContainer = this._register(( new Emitter()));
+        this.onDidChangeContainer = this._onDidChangeContainer.event;
+        this._onDidChangeViewWelcomeContent = this._register(( new Emitter()));
+        this.onDidChangeViewWelcomeContent = this._onDidChangeViewWelcomeContent.event;
+        this._viewContainers = [];
+        this._views = ( new Map());
+        this._viewWelcomeContents = ( new SetMap());
+    }
+    registerViews(views, viewContainer) {
+        this.registerViews2([{ views, viewContainer }]);
+    }
+    registerViews2(views) {
+        views.forEach(({ views, viewContainer }) => this.addViews(views, viewContainer));
+        this._onViewsRegistered.fire(views);
+    }
+    deregisterViews(viewDescriptors, viewContainer) {
+        const views = this.removeViews(viewDescriptors, viewContainer);
+        if (views.length) {
+            this._onViewsDeregistered.fire({ views, viewContainer });
+        }
+    }
+    moveViews(viewsToMove, viewContainer) {
+        for (const container of ( this._views.keys())) {
+            if (container !== viewContainer) {
+                const views = this.removeViews(viewsToMove, container);
+                if (views.length) {
+                    this.addViews(views, viewContainer);
+                    this._onDidChangeContainer.fire({ views, from: container, to: viewContainer });
+                }
+            }
+        }
+    }
+    getViews(loc) {
+        return this._views.get(loc) || [];
+    }
+    getView(id) {
+        for (const viewContainer of this._viewContainers) {
+            const viewDescriptor = (this._views.get(viewContainer) || []).filter(v => v.id === id)[0];
+            if (viewDescriptor) {
+                return viewDescriptor;
+            }
+        }
+        return null;
+    }
+    getViewContainer(viewId) {
+        for (const viewContainer of this._viewContainers) {
+            const viewDescriptor = (this._views.get(viewContainer) || []).filter(v => v.id === viewId)[0];
+            if (viewDescriptor) {
+                return viewContainer;
+            }
+        }
+        return null;
+    }
+    registerViewWelcomeContent(id, viewContent) {
+        this._viewWelcomeContents.add(id, viewContent);
+        this._onDidChangeViewWelcomeContent.fire(id);
+        return toDisposable(() => {
+            this._viewWelcomeContents.delete(id, viewContent);
+            this._onDidChangeViewWelcomeContent.fire(id);
+        });
+    }
+    registerViewWelcomeContent2(id, viewContentMap) {
+        const disposables = ( new Map());
+        for (const [key, content] of viewContentMap) {
+            this._viewWelcomeContents.add(id, content);
+            disposables.set(key, toDisposable(() => {
+                this._viewWelcomeContents.delete(id, content);
+                this._onDidChangeViewWelcomeContent.fire(id);
+            }));
+        }
+        this._onDidChangeViewWelcomeContent.fire(id);
+        return disposables;
+    }
+    getViewWelcomeContent(id) {
+        const result = [];
+        this._viewWelcomeContents.forEach(id, descriptor => result.push(descriptor));
+        return result.sort(compareViewContentDescriptors);
+    }
+    addViews(viewDescriptors, viewContainer) {
+        let views = this._views.get(viewContainer);
+        if (!views) {
+            views = [];
+            this._views.set(viewContainer, views);
+            this._viewContainers.push(viewContainer);
+        }
+        for (const viewDescriptor of viewDescriptors) {
+            if (this.getView(viewDescriptor.id) !== null) {
+                throw new Error(localize('duplicateId', "A view with id '{0}' is already registered", viewDescriptor.id));
+            }
+            views.push(viewDescriptor);
+        }
+    }
+    removeViews(viewDescriptors, viewContainer) {
+        const views = this._views.get(viewContainer);
+        if (!views) {
+            return [];
+        }
+        const viewsToDeregister = [];
+        const remaningViews = [];
+        for (const view of views) {
+            if (!viewDescriptors.includes(view)) {
+                remaningViews.push(view);
+            }
+            else {
+                viewsToDeregister.push(view);
+            }
+        }
+        if (viewsToDeregister.length) {
+            if (remaningViews.length) {
+                this._views.set(viewContainer, remaningViews);
+            }
+            else {
+                this._views.delete(viewContainer);
+                this._viewContainers.splice(this._viewContainers.indexOf(viewContainer), 1);
+            }
+        }
+        return viewsToDeregister;
+    }
+}
+Registry.add(Extensions.ViewsRegistry, ( new ViewsRegistry()));
 const IViewsService = ( createDecorator('viewsService'));
 const IViewDescriptorService = ( createDecorator('viewDescriptorService'));
-export { Extensions, IViewDescriptorService, IViewsService, ViewContainerLocationToString, defaultViewIcon };
+var ViewVisibilityState;
+( (function(ViewVisibilityState) {
+    ViewVisibilityState[ViewVisibilityState["Default"] = 0] = "Default";
+    ViewVisibilityState[ViewVisibilityState["Expand"] = 1] = "Expand";
+})(ViewVisibilityState || (ViewVisibilityState = {})));
+var TreeItemCollapsibleState;
+( (function(TreeItemCollapsibleState) {
+    TreeItemCollapsibleState[TreeItemCollapsibleState["None"] = 0] = "None";
+    TreeItemCollapsibleState[TreeItemCollapsibleState["Collapsed"] = 1] = "Collapsed";
+    TreeItemCollapsibleState[TreeItemCollapsibleState["Expanded"] = 2] = "Expanded";
+})(TreeItemCollapsibleState || (TreeItemCollapsibleState = {})));
+class ResolvableTreeItem {
+    constructor(treeItem, resolve) {
+        this.resolved = false;
+        this._hasResolve = false;
+        mixin(this, treeItem);
+        this._hasResolve = !!resolve;
+        this.resolve = async (token) => {
+            if (resolve && !this.resolved) {
+                const resolvedItem = await resolve(token);
+                if (resolvedItem) {
+                    this.tooltip = this.tooltip ?? resolvedItem.tooltip;
+                    this.command = this.command ?? resolvedItem.command;
+                }
+            }
+            if (!token.isCancellationRequested) {
+                this.resolved = true;
+            }
+        };
+    }
+    get hasResolve() {
+        return this._hasResolve;
+    }
+    resetResolve() {
+        this.resolved = false;
+    }
+    asTreeItem() {
+        return {
+            handle: this.handle,
+            parentHandle: this.parentHandle,
+            collapsibleState: this.collapsibleState,
+            label: this.label,
+            description: this.description,
+            icon: this.icon,
+            iconDark: this.iconDark,
+            themeIcon: this.themeIcon,
+            resourceUri: this.resourceUri,
+            tooltip: this.tooltip,
+            contextValue: this.contextValue,
+            command: this.command,
+            children: this.children,
+            accessibilityInformation: this.accessibilityInformation
+        };
+    }
+}
+class NoTreeViewError extends Error {
+    constructor(treeViewId) {
+        super(( localize(
+            'treeView.notRegistered',
+            'No tree view with id \'{0}\' registered.',
+            treeViewId
+        )));
+    }
+}
+export { Extensions, IViewDescriptorService, IViewsService, NoTreeViewError, ResolvableTreeItem, TreeItemCollapsibleState, ViewContainerLocation, ViewContainerLocationToString, ViewContentGroups, ViewVisibilityState, defaultViewIcon };

package/dist/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits.js

@@ -1,6 +1,13 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { groupBy } from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { compare } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
 import { ResourceEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { getNotebookEditorFromEditorPane } from '../../notebook/browser/notebookBrowser.js';
+import { CellUri, SelectionStateType } from '../../notebook/common/notebookCommon.js';
+import { INotebookEditorModelResolverService } from '../../notebook/common/notebookEditorModelResolverService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
 class ResourceNotebookCellEdit extends ResourceEdit {
     static is(candidate) {
         if (candidate instanceof ResourceNotebookCellEdit) {
@@ -22,4 +29,58 @@ class ResourceNotebookCellEdit extends ResourceEdit {
         this.notebookVersionId = notebookVersionId;
     }
 }
-export { ResourceNotebookCellEdit };
+let BulkCellEdits = class BulkCellEdits {
+    constructor(_undoRedoGroup, undoRedoSource, _progress, _token, _edits, _editorService, _notebookModelService) {
+        this._undoRedoGroup = _undoRedoGroup;
+        this._progress = _progress;
+        this._token = _token;
+        this._edits = _edits;
+        this._editorService = _editorService;
+        this._notebookModelService = _notebookModelService;
+        this._edits = ( this._edits.map(e => {
+            if (e.resource.scheme === CellUri.scheme) {
+                const uri = CellUri.parse(e.resource)?.notebook;
+                if (!uri) {
+                    throw new Error(`Invalid notebook URI: ${e.resource}`);
+                }
+                return ( new ResourceNotebookCellEdit(uri, e.cellEdit, e.notebookVersionId, e.metadata));
+            }
+            else {
+                return e;
+            }
+        }));
+    }
+    async apply() {
+        const resources = [];
+        const editsByNotebook = groupBy(this._edits, (a, b) => compare(( a.resource.toString()), ( b.resource.toString())));
+        for (const group of editsByNotebook) {
+            if (this._token.isCancellationRequested) {
+                break;
+            }
+            const [first] = group;
+            const ref = await this._notebookModelService.resolve(first.resource);
+            if (typeof first.notebookVersionId === 'number' && ref.object.notebook.versionId !== first.notebookVersionId) {
+                ref.dispose();
+                throw new Error(`Notebook '${first.resource}' has changed in the meantime`);
+            }
+            const edits = ( group.map(entry => entry.cellEdit));
+            const computeUndo = !ref.object.isReadonly();
+            const editor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
+            const initialSelectionState = editor?.textModel?.uri.toString() === ( ref.object.notebook.uri.toString()) ? {
+                kind: SelectionStateType.Index,
+                focus: editor.getFocus(),
+                selections: editor.getSelections()
+            } : undefined;
+            ref.object.notebook.applyEdits(edits, true, initialSelectionState, () => undefined, this._undoRedoGroup, computeUndo);
+            ref.dispose();
+            this._progress.report(undefined);
+            resources.push(first.resource);
+        }
+        return resources;
+    }
+};
+BulkCellEdits = ( __decorate([
+    ( __param(5, IEditorService)),
+    ( __param(6, INotebookEditorModelResolverService))
+], BulkCellEdits));
+export { BulkCellEdits, ResourceNotebookCellEdit };

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

@@ -0,0 +1,305 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+import { ResourceMap, ResourceSet } from 'monaco-editor/esm/vs/base/common/map.js';
+import { isCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { IDialogService } from 'monaco-editor/esm/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { Progress } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { UndoRedoGroup } from 'monaco-editor/esm/vs/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';
+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 ( localize('summary.0', "Made no edits"));
+        }
+        else if (otherResources.size === 0) {
+            if (textEditCount > 1 && textEditResources.size > 1) {
+                return ( localize(
+                    'summary.nm',
+                    "Made {0} text edits in {1} files",
+                    textEditCount,
+                    textEditResources.size
+                ));
+            }
+            else {
+                return ( localize('summary.n0', "Made {0} text edits in one file", textEditCount));
+            }
+        }
+        else {
+            return ( localize(
+                '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 || ( localize('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 || ( localize('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: ( localize('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;
+            }
+        }
+        if (codeEditor && codeEditor.getOption(87 )) {
+            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 = ( localize('closeTheWindow.message', "Are you sure you want to close the window?"));
+                primaryButton = ( localize(
+                    { key: 'closeTheWindow', comment: ['&& denotes a mnemonic'] },
+                    "&&Close Window"
+                ));
+                break;
+            case 4 :
+                message = ( localize(
+                    'changeWorkspace.message',
+                    "Are you sure you want to change the workspace?"
+                ));
+                primaryButton = ( localize(
+                    { key: 'changeWorkspace', comment: ['&& denotes a mnemonic'] },
+                    "Change &&Workspace"
+                ));
+                break;
+            case 3 :
+                message = ( localize('reloadTheWindow.message', "Are you sure you want to reload the window?"));
+                primaryButton = ( localize(
+                    { key: 'reloadTheWindow', comment: ['&& denotes a mnemonic'] },
+                    "&&Reload Window"
+                ));
+                break;
+            default:
+                message = ( localize('quit.message', "Are you sure you want to quit?"));
+                primaryButton = ( localize({ key: 'quit', comment: ['&& denotes a mnemonic'] }, "&&Quit"));
+                break;
+        }
+        const result = await this._dialogService.confirm({
+            message,
+            detail: ( localize(
+                'areYouSureQuiteBulkEdit.detail',
+                "'{0}' is in progress.",
+                label || ( localize('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: ( localize(
+                'refactoring.autoSave',
+                "Controls if files that were part of a refactoring are saved automatically"
+            )),
+            default: true,
+            type: 'boolean'
+        }
+    }
+});
+export { BulkEditService };