@codingame/monaco-vscode-bulk-edit-service-override 1.85.0 → 1.85.1

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane.js

@@ -0,0 +1,337 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import './bulkEdit.css.js';
+import { WorkbenchAsyncDataTree } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { BulkEditDataSource, BulkEditDelegate, TextEditElementRenderer, FileElementRenderer, CategoryElementRenderer, BulkEditAccessibilityProvider, BulkEditIdentityProvider, BulkEditNaviLabelProvider, BulkEditSorter, FileElement, CategoryElement, TextEditElement } from './bulkEditTree.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { SIDE_GROUP, ACTIVE_GROUP, IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { BulkFileOperations, BulkEditPreviewProvider } from './bulkEditPreview.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { ViewPane } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPane';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { RawContextKey, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { ResourceLabels } from 'vscode/vscode/vs/workbench/browser/labels';
+import '../../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { basename, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IViewDescriptorService } from 'vscode/vscode/vs/workbench/common/views';
+import { IOpenerService } from 'monaco-editor/esm/vs/platform/opener/common/opener.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { ButtonBar } from 'monaco-editor/esm/vs/base/browser/ui/button/button.js';
+import { defaultButtonStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var BulkEditPane_1;
+let BulkEditPane = class BulkEditPane extends ViewPane {
+    static { BulkEditPane_1 = this; }
+    static { this.ID = 'refactorPreview'; }
+    static { this.ctxHasCategories = ( new RawContextKey('refactorPreview.hasCategories', false)); }
+    static { this.ctxGroupByFile = ( new RawContextKey('refactorPreview.groupByFile', true)); }
+    static { this.ctxHasCheckedChanges = ( new RawContextKey('refactorPreview.hasCheckedChanges', true)); }
+    static { this._memGroupByFile = `${BulkEditPane_1.ID}.groupByFile`; }
+    constructor(options, _instaService, _editorService, _labelService, _textModelService, _dialogService, _contextMenuService, _storageService, contextKeyService, viewDescriptorService, keybindingService, contextMenuService, configurationService, openerService, themeService, telemetryService) {
+        super({ ...options, titleMenuId: MenuId.BulkEditTitle }, keybindingService, contextMenuService, configurationService, contextKeyService, viewDescriptorService, _instaService, openerService, themeService, telemetryService);
+        this._instaService = _instaService;
+        this._editorService = _editorService;
+        this._labelService = _labelService;
+        this._textModelService = _textModelService;
+        this._dialogService = _dialogService;
+        this._contextMenuService = _contextMenuService;
+        this._storageService = _storageService;
+        this._treeViewStates = ( new Map());
+        this._disposables = ( new DisposableStore());
+        this._sessionDisposables = ( new DisposableStore());
+        this.element.classList.add('bulk-edit-panel', 'show-file-icons');
+        this._ctxHasCategories = BulkEditPane_1.ctxHasCategories.bindTo(contextKeyService);
+        this._ctxGroupByFile = BulkEditPane_1.ctxGroupByFile.bindTo(contextKeyService);
+        this._ctxHasCheckedChanges = BulkEditPane_1.ctxHasCheckedChanges.bindTo(contextKeyService);
+    }
+    dispose() {
+        this._tree.dispose();
+        this._disposables.dispose();
+    }
+    renderBody(parent) {
+        super.renderBody(parent);
+        const resourceLabels = this._instaService.createInstance(ResourceLabels, { onDidChangeVisibility: this.onDidChangeBodyVisibility });
+        this._disposables.add(resourceLabels);
+        const contentContainer = document.createElement('div');
+        contentContainer.className = 'content';
+        parent.appendChild(contentContainer);
+        const treeContainer = document.createElement('div');
+        contentContainer.appendChild(treeContainer);
+        this._treeDataSource = this._instaService.createInstance(BulkEditDataSource);
+        this._treeDataSource.groupByFile = this._storageService.getBoolean(BulkEditPane_1._memGroupByFile, 0 , true);
+        this._ctxGroupByFile.set(this._treeDataSource.groupByFile);
+        this._tree = this._instaService.createInstance(WorkbenchAsyncDataTree, this.id, treeContainer, ( new BulkEditDelegate()), [this._instaService.createInstance(TextEditElementRenderer), this._instaService.createInstance(FileElementRenderer, resourceLabels), this._instaService.createInstance(CategoryElementRenderer)], this._treeDataSource, {
+            accessibilityProvider: this._instaService.createInstance(BulkEditAccessibilityProvider),
+            identityProvider: ( new BulkEditIdentityProvider()),
+            expandOnlyOnTwistieClick: true,
+            multipleSelectionSupport: false,
+            keyboardNavigationLabelProvider: ( new BulkEditNaviLabelProvider()),
+            sorter: ( new BulkEditSorter()),
+            selectionNavigation: true
+        });
+        this._disposables.add(this._tree.onContextMenu(this._onContextMenu, this));
+        this._disposables.add(this._tree.onDidOpen(e => this._openElementAsEditor(e)));
+        const buttonsContainer = document.createElement('div');
+        buttonsContainer.className = 'buttons';
+        contentContainer.appendChild(buttonsContainer);
+        const buttonBar = ( new ButtonBar(buttonsContainer));
+        this._disposables.add(buttonBar);
+        const btnConfirm = buttonBar.addButton({ supportIcons: true, ...defaultButtonStyles });
+        btnConfirm.label = ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+            'ok',
+            'Apply'
+        ));
+        btnConfirm.onDidClick(() => this.accept(), this, this._disposables);
+        const btnCancel = buttonBar.addButton({ ...defaultButtonStyles, secondary: true });
+        btnCancel.label = ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+            'cancel',
+            'Discard'
+        ));
+        btnCancel.onDidClick(() => this.discard(), this, this._disposables);
+        this._message = document.createElement('span');
+        this._message.className = 'message';
+        this._message.innerText = ( localizeWithPath(
+            'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+            'empty.msg',
+            "Invoke a code action, like rename, to see a preview of its changes here."
+        ));
+        parent.appendChild(this._message);
+        this._setState("message" );
+    }
+    layoutBody(height, width) {
+        super.layoutBody(height, width);
+        const treeHeight = height - 50;
+        this._tree.getHTMLElement().parentElement.style.height = `${treeHeight}px`;
+        this._tree.layout(treeHeight, width);
+    }
+    _setState(state) {
+        this.element.dataset['state'] = state;
+    }
+    async setInput(edit, token) {
+        this._setState("data" );
+        this._sessionDisposables.clear();
+        this._treeViewStates.clear();
+        if (this._currentResolve) {
+            this._currentResolve(undefined);
+            this._currentResolve = undefined;
+        }
+        const input = await this._instaService.invokeFunction(BulkFileOperations.create, edit);
+        this._currentProvider = this._instaService.createInstance(BulkEditPreviewProvider, input);
+        this._sessionDisposables.add(this._currentProvider);
+        this._sessionDisposables.add(input);
+        const hasCategories = input.categories.length > 1;
+        this._ctxHasCategories.set(hasCategories);
+        this._treeDataSource.groupByFile = !hasCategories || this._treeDataSource.groupByFile;
+        this._ctxHasCheckedChanges.set(input.checked.checkedCount > 0);
+        this._currentInput = input;
+        return ( new Promise(resolve => {
+            token.onCancellationRequested(() => resolve(undefined));
+            this._currentResolve = resolve;
+            this._setTreeInput(input);
+            this._sessionDisposables.add(input.checked.onDidChange(() => {
+                this._tree.updateChildren();
+                this._ctxHasCheckedChanges.set(input.checked.checkedCount > 0);
+            }));
+        }));
+    }
+    hasInput() {
+        return Boolean(this._currentInput);
+    }
+    async _setTreeInput(input) {
+        const viewState = this._treeViewStates.get(this._treeDataSource.groupByFile);
+        await this._tree.setInput(input, viewState);
+        this._tree.domFocus();
+        if (viewState) {
+            return;
+        }
+        const expand = [...this._tree.getNode(input).children].slice(0, 10);
+        while (expand.length > 0) {
+            const { element } = expand.shift();
+            if (element instanceof FileElement) {
+                await this._tree.expand(element, true);
+            }
+            if (element instanceof CategoryElement) {
+                await this._tree.expand(element, true);
+                expand.push(...this._tree.getNode(element).children);
+            }
+        }
+    }
+    accept() {
+        const conflicts = this._currentInput?.conflicts.list();
+        if (!conflicts || conflicts.length === 0) {
+            this._done(true);
+            return;
+        }
+        let message;
+        if (conflicts.length === 1) {
+            message = ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                'conflict.1',
+                "Cannot apply refactoring because '{0}' has changed in the meantime.",
+                this._labelService.getUriLabel(conflicts[0], { relative: true })
+            ));
+        }
+        else {
+            message = ( localizeWithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                'conflict.N',
+                "Cannot apply refactoring because {0} other files have changed in the meantime.",
+                conflicts.length
+            ));
+        }
+        this._dialogService.warn(message).finally(() => this._done(false));
+    }
+    discard() {
+        this._done(false);
+    }
+    _done(accept) {
+        this._currentResolve?.(accept ? this._currentInput?.getWorkspaceEdit() : undefined);
+        this._currentInput = undefined;
+        this._setState("message" );
+        this._sessionDisposables.clear();
+    }
+    toggleChecked() {
+        const [first] = this._tree.getFocus();
+        if ((first instanceof FileElement || first instanceof TextEditElement) && !first.isDisabled()) {
+            first.setChecked(!first.isChecked());
+        }
+        else if (first instanceof CategoryElement) {
+            first.setChecked(!first.isChecked());
+        }
+    }
+    groupByFile() {
+        if (!this._treeDataSource.groupByFile) {
+            this.toggleGrouping();
+        }
+    }
+    groupByType() {
+        if (this._treeDataSource.groupByFile) {
+            this.toggleGrouping();
+        }
+    }
+    toggleGrouping() {
+        const input = this._tree.getInput();
+        if (input) {
+            const oldViewState = this._tree.getViewState();
+            this._treeViewStates.set(this._treeDataSource.groupByFile, oldViewState);
+            this._treeDataSource.groupByFile = !this._treeDataSource.groupByFile;
+            this._setTreeInput(input);
+            this._storageService.store(BulkEditPane_1._memGroupByFile, this._treeDataSource.groupByFile, 0 , 0 );
+            this._ctxGroupByFile.set(this._treeDataSource.groupByFile);
+        }
+    }
+    async _openElementAsEditor(e) {
+        const options = { ...e.editorOptions };
+        let fileElement;
+        if (e.element instanceof TextEditElement) {
+            fileElement = e.element.parent;
+            options.selection = e.element.edit.textEdit.textEdit.range;
+        }
+        else if (e.element instanceof FileElement) {
+            fileElement = e.element;
+            options.selection = e.element.edit.textEdits[0]?.textEdit.textEdit.range;
+        }
+        else {
+            return;
+        }
+        const previewUri = this._currentProvider.asPreviewUri(fileElement.edit.uri);
+        if (fileElement.edit.type & 4 ) {
+            this._editorService.openEditor({
+                label: ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                    'edt.title.del',
+                    "{0} (delete, refactor preview)",
+                    basename(fileElement.edit.uri)
+                )),
+                resource: previewUri,
+                options
+            });
+        }
+        else {
+            let leftResource;
+            try {
+                (await this._textModelService.createModelReference(fileElement.edit.uri)).dispose();
+                leftResource = fileElement.edit.uri;
+            }
+            catch {
+                leftResource = BulkEditPreviewProvider.emptyPreview;
+            }
+            let typeLabel;
+            if (fileElement.edit.type & 8 ) {
+                typeLabel = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                    'rename',
+                    "rename"
+                ));
+            }
+            else if (fileElement.edit.type & 2 ) {
+                typeLabel = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                    'create',
+                    "create"
+                ));
+            }
+            let label;
+            if (typeLabel) {
+                label = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                    'edt.title.2',
+                    "{0} ({1}, refactor preview)",
+                    basename(fileElement.edit.uri),
+                    typeLabel
+                ));
+            }
+            else {
+                label = ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPane',
+                    'edt.title.1',
+                    "{0} (refactor preview)",
+                    basename(fileElement.edit.uri)
+                ));
+            }
+            this._editorService.openEditor({
+                original: { resource: leftResource },
+                modified: { resource: previewUri },
+                label,
+                description: this._labelService.getUriLabel(dirname(leftResource), { relative: true }),
+                options
+            }, e.sideBySide ? SIDE_GROUP : ACTIVE_GROUP);
+        }
+    }
+    _onContextMenu(e) {
+        this._contextMenuService.showContextMenu({
+            menuId: MenuId.BulkEditContext,
+            contextKeyService: this.contextKeyService,
+            getAnchor: () => e.anchor
+        });
+    }
+};
+BulkEditPane = BulkEditPane_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, ILabelService)),
+    ( __param(4, ITextModelService)),
+    ( __param(5, IDialogService)),
+    ( __param(6, IContextMenuService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, IContextKeyService)),
+    ( __param(9, IViewDescriptorService)),
+    ( __param(10, IKeybindingService)),
+    ( __param(11, IContextMenuService)),
+    ( __param(12, IConfigurationService)),
+    ( __param(13, IOpenerService)),
+    ( __param(14, IThemeService)),
+    ( __param(15, ITelemetryService))
+], BulkEditPane));
+
+export { BulkEditPane };