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

package/bulkEdit.js

@@ -1,6 +1,7 @@
 import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
 import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
 import { BulkEditService } from './vscode/src/vs/workbench/contrib/bulkEdit/browser/bulkEditService.js';
+import './vscode/src/vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution.js';
 
 function getServiceOverride() {
     return {

package/external/rollup-plugin-styles/dist/runtime/inject-css.js

@@ -0,0 +1,3 @@
+var e=[],t=[];function n(n,r){if(n&&"undefined"!=typeof document){var a,s=!0===r.prepend?"prepend":"append",d=!0===r.singleTag,i="string"==typeof r.container?document.querySelector(r.container):document.getElementsByTagName("head")[0];if(d){var u=e.indexOf(i);-1===u&&(u=e.push(i)-1,t[u]={}),a=t[u]&&t[u][s]?t[u][s]:t[u][s]=c();}else a=c();65279===n.charCodeAt(0)&&(n=n.substring(1)),a.styleSheet?a.styleSheet.cssText+=n:a.appendChild(document.createTextNode(n));}function c(){var e=document.createElement("style");if(e.setAttribute("type","text/css"),r.attributes)for(var t=( Object.keys(r.attributes)),n=0;n<t.length;n++)e.setAttribute(t[n],r.attributes[t[n]]);var a="prepend"===s?"afterbegin":"beforeend";return i.insertAdjacentElement(a,e),e}}
+
+export { n as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-bulk-edit-service-override",
-  "version": "1.85.0",
+  "version": "1.85.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.85.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.1",
     "monaco-editor": "0.45.0"
   }
 }

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

@@ -0,0 +1,80 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { ResourceTextEdit, ResourceFileEdit } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { ResourceNotebookCellEdit } from 'vscode/vscode/vs/workbench/contrib/bulkEdit/browser/bulkCellEdits';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+
+let ConflictDetector = class ConflictDetector {
+    constructor(edits, fileService, modelService, logService) {
+        this._conflicts = ( new ResourceMap());
+        this._disposables = ( new DisposableStore());
+        this._onDidConflict = ( new Emitter());
+        this.onDidConflict = this._onDidConflict.event;
+        const _workspaceEditResources = ( new ResourceMap());
+        for (const edit of edits) {
+            if (edit instanceof ResourceTextEdit) {
+                _workspaceEditResources.set(edit.resource, true);
+                if (typeof edit.versionId === 'number') {
+                    const model = modelService.getModel(edit.resource);
+                    if (model && model.getVersionId() !== edit.versionId) {
+                        this._conflicts.set(edit.resource, true);
+                        this._onDidConflict.fire(this);
+                    }
+                }
+            }
+            else if (edit instanceof ResourceFileEdit) {
+                if (edit.newResource) {
+                    _workspaceEditResources.set(edit.newResource, true);
+                }
+                else if (edit.oldResource) {
+                    _workspaceEditResources.set(edit.oldResource, true);
+                }
+            }
+            else if (edit instanceof ResourceNotebookCellEdit) {
+                _workspaceEditResources.set(edit.resource, true);
+            }
+            else {
+                logService.warn('UNKNOWN edit type', edit);
+            }
+        }
+        this._disposables.add(fileService.onDidFilesChange(e => {
+            for (const uri of ( _workspaceEditResources.keys())) {
+                if (!modelService.getModel(uri) && e.contains(uri)) {
+                    this._conflicts.set(uri, true);
+                    this._onDidConflict.fire(this);
+                    break;
+                }
+            }
+        }));
+        const onDidChangeModel = (model) => {
+            if (( _workspaceEditResources.has(model.uri))) {
+                this._conflicts.set(model.uri, true);
+                this._onDidConflict.fire(this);
+            }
+        };
+        for (const model of modelService.getModels()) {
+            this._disposables.add(model.onDidChangeContent(() => onDidChangeModel(model)));
+        }
+    }
+    dispose() {
+        this._disposables.dispose();
+        this._onDidConflict.dispose();
+    }
+    list() {
+        return [...( this._conflicts.keys())];
+    }
+    hasConflicts() {
+        return this._conflicts.size > 0;
+    }
+};
+ConflictDetector = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILogService))
+], ConflictDetector));
+
+export { ConflictDetector };

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

@@ -0,0 +1,364 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
+import { IBulkEditService } from 'monaco-editor/esm/vs/editor/browser/services/bulkEditService.js';
+import { BulkEditPane } from './bulkEditPane.js';
+import { IViewsService, Extensions as Extensions$1 } from 'vscode/vscode/vs/workbench/common/views';
+import { FocusedViewContext } from 'vscode/vscode/vs/workbench/common/contextkeys';
+import { localizeWithPath, localize2WithPath } from 'monaco-editor/esm/vs/nls.js';
+import { ViewPaneContainer } from 'vscode/vscode/vs/workbench/browser/parts/views/viewPaneContainer';
+import { RawContextKey, ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IEditorGroupsService } from 'vscode/vscode/vs/workbench/services/editor/common/editorGroupsService';
+import { BulkEditPreviewProvider } from './bulkEditPreview.js';
+import { WorkbenchListFocusContextKey } from 'monaco-editor/esm/vs/platform/list/browser/listService.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { registerAction2, Action2, MenuId } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import '../../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+import { IPaneCompositePartService } from 'vscode/vscode/vs/workbench/services/panecomposite/browser/panecomposite';
+import { IDialogService } from 'vscode/vscode/vs/platform/dialogs/common/dialogs';
+
+var BulkEditPreviewContribution_1;
+async function getBulkEditPane(viewsService) {
+    const view = await viewsService.openView(BulkEditPane.ID, true);
+    if (view instanceof BulkEditPane) {
+        return view;
+    }
+    return undefined;
+}
+let UXState = class UXState {
+    constructor(_paneCompositeService, _editorGroupsService) {
+        this._paneCompositeService = _paneCompositeService;
+        this._editorGroupsService = _editorGroupsService;
+        this._activePanel = _paneCompositeService.getActivePaneComposite(1 )?.getId();
+    }
+    async restore(panels, editors) {
+        if (panels) {
+            if (typeof this._activePanel === 'string') {
+                await this._paneCompositeService.openPaneComposite(this._activePanel, 1 );
+            }
+            else {
+                this._paneCompositeService.hideActivePaneComposite(1 );
+            }
+        }
+        if (editors) {
+            for (const group of this._editorGroupsService.groups) {
+                const previewEditors = [];
+                for (const input of group.editors) {
+                    const resource = EditorResourceAccessor.getCanonicalUri(input, { supportSideBySide: SideBySideEditor.PRIMARY });
+                    if (resource?.scheme === BulkEditPreviewProvider.Schema) {
+                        previewEditors.push(input);
+                    }
+                }
+                if (previewEditors.length) {
+                    group.closeEditors(previewEditors, { preserveFocus: true });
+                }
+            }
+        }
+    }
+};
+UXState = ( __decorate([
+    ( __param(0, IPaneCompositePartService)),
+    ( __param(1, IEditorGroupsService))
+], UXState));
+class PreviewSession {
+    constructor(uxState, cts = ( new CancellationTokenSource())) {
+        this.uxState = uxState;
+        this.cts = cts;
+    }
+}
+let BulkEditPreviewContribution = class BulkEditPreviewContribution {
+    static { BulkEditPreviewContribution_1 = this; }
+    static { this.ctxEnabled = ( new RawContextKey('refactorPreview.enabled', false)); }
+    constructor(_paneCompositeService, _viewsService, _editorGroupsService, _dialogService, bulkEditService, contextKeyService) {
+        this._paneCompositeService = _paneCompositeService;
+        this._viewsService = _viewsService;
+        this._editorGroupsService = _editorGroupsService;
+        this._dialogService = _dialogService;
+        bulkEditService.setPreviewHandler(edits => this._previewEdit(edits));
+        this._ctxEnabled = BulkEditPreviewContribution_1.ctxEnabled.bindTo(contextKeyService);
+    }
+    async _previewEdit(edits) {
+        this._ctxEnabled.set(true);
+        const uxState = this._activeSession?.uxState ?? ( new UXState(this._paneCompositeService, this._editorGroupsService));
+        const view = await getBulkEditPane(this._viewsService);
+        if (!view) {
+            this._ctxEnabled.set(false);
+            return edits;
+        }
+        if (view.hasInput()) {
+            const { confirmed } = await this._dialogService.confirm({
+                type: Severity.Info,
+                message: ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                    'overlap',
+                    "Another refactoring is being previewed."
+                )),
+                detail: ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                    'detail',
+                    "Press 'Continue' to discard the previous refactoring and continue with the current refactoring."
+                )),
+                primaryButton: ( localizeWithPath(
+                    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                    { key: 'continue', comment: ['&& denotes a mnemonic'] },
+                    "&&Continue"
+                ))
+            });
+            if (!confirmed) {
+                return [];
+            }
+        }
+        let session;
+        if (this._activeSession) {
+            await this._activeSession.uxState.restore(false, true);
+            this._activeSession.cts.dispose(true);
+            session = ( new PreviewSession(uxState));
+        }
+        else {
+            session = ( new PreviewSession(uxState));
+        }
+        this._activeSession = session;
+        try {
+            return (await view.setInput(edits, session.cts.token)) ?? [];
+        }
+        finally {
+            if (this._activeSession === session) {
+                await this._activeSession.uxState.restore(true, true);
+                this._activeSession.cts.dispose();
+                this._ctxEnabled.set(false);
+                this._activeSession = undefined;
+            }
+        }
+    }
+};
+BulkEditPreviewContribution = BulkEditPreviewContribution_1 = ( __decorate([
+    ( __param(0, IPaneCompositePartService)),
+    ( __param(1, IViewsService)),
+    ( __param(2, IEditorGroupsService)),
+    ( __param(3, IDialogService)),
+    ( __param(4, IBulkEditService)),
+    ( __param(5, IContextKeyService))
+], BulkEditPreviewContribution));
+registerAction2(class ApplyAction extends Action2 {
+    constructor() {
+        super({
+            id: 'refactorPreview.apply',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'apply',
+                "Apply Refactoring"
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'cat',
+                "Refactor Preview"
+            )),
+            icon: Codicon.check,
+            precondition: ( ContextKeyExpr.and(BulkEditPreviewContribution.ctxEnabled, BulkEditPane.ctxHasCheckedChanges)),
+            menu: [{
+                    id: MenuId.BulkEditContext,
+                    order: 1
+                }],
+            keybinding: {
+                weight: 100  - 10,
+                when: ( ContextKeyExpr.and(BulkEditPreviewContribution.ctxEnabled, ( FocusedViewContext.isEqualTo(BulkEditPane.ID)))),
+                primary: 1024  + 3 ,
+            }
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = await getBulkEditPane(viewsService);
+        view?.accept();
+    }
+});
+registerAction2(class DiscardAction extends Action2 {
+    constructor() {
+        super({
+            id: 'refactorPreview.discard',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'Discard',
+                "Discard Refactoring"
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'cat',
+                "Refactor Preview"
+            )),
+            icon: Codicon.clearAll,
+            precondition: BulkEditPreviewContribution.ctxEnabled,
+            menu: [{
+                    id: MenuId.BulkEditContext,
+                    order: 2
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = await getBulkEditPane(viewsService);
+        view?.discard();
+    }
+});
+registerAction2(class ToggleAction extends Action2 {
+    constructor() {
+        super({
+            id: 'refactorPreview.toggleCheckedState',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'toogleSelection',
+                "Toggle Change"
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'cat',
+                "Refactor Preview"
+            )),
+            precondition: BulkEditPreviewContribution.ctxEnabled,
+            keybinding: {
+                weight: 200 ,
+                when: WorkbenchListFocusContextKey,
+                primary: 10 ,
+            },
+            menu: {
+                id: MenuId.BulkEditContext,
+                group: 'navigation'
+            }
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = await getBulkEditPane(viewsService);
+        view?.toggleChecked();
+    }
+});
+registerAction2(class GroupByFile extends Action2 {
+    constructor() {
+        super({
+            id: 'refactorPreview.groupByFile',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'groupByFile',
+                "Group Changes By File"
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'cat',
+                "Refactor Preview"
+            )),
+            icon: Codicon.ungroupByRefType,
+            precondition: ( ContextKeyExpr.and(BulkEditPane.ctxHasCategories, ( BulkEditPane.ctxGroupByFile.negate()), BulkEditPreviewContribution.ctxEnabled)),
+            menu: [{
+                    id: MenuId.BulkEditTitle,
+                    when: ( ContextKeyExpr.and(BulkEditPane.ctxHasCategories, ( BulkEditPane.ctxGroupByFile.negate()))),
+                    group: 'navigation',
+                    order: 3,
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = await getBulkEditPane(viewsService);
+        view?.groupByFile();
+    }
+});
+registerAction2(class GroupByType extends Action2 {
+    constructor() {
+        super({
+            id: 'refactorPreview.groupByType',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'groupByType',
+                "Group Changes By Type"
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'cat',
+                "Refactor Preview"
+            )),
+            icon: Codicon.groupByRefType,
+            precondition: ( ContextKeyExpr.and(
+                BulkEditPane.ctxHasCategories,
+                BulkEditPane.ctxGroupByFile,
+                BulkEditPreviewContribution.ctxEnabled
+            )),
+            menu: [{
+                    id: MenuId.BulkEditTitle,
+                    when: ( ContextKeyExpr.and(BulkEditPane.ctxHasCategories, BulkEditPane.ctxGroupByFile)),
+                    group: 'navigation',
+                    order: 3
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = await getBulkEditPane(viewsService);
+        view?.groupByType();
+    }
+});
+registerAction2(class ToggleGrouping extends Action2 {
+    constructor() {
+        super({
+            id: 'refactorPreview.toggleGrouping',
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'groupByType',
+                "Group Changes By Type"
+            )),
+            category: ( localize2WithPath(
+                'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+                'cat',
+                "Refactor Preview"
+            )),
+            icon: Codicon.listTree,
+            toggled: ( BulkEditPane.ctxGroupByFile.negate()),
+            precondition: ( ContextKeyExpr.and(BulkEditPane.ctxHasCategories, BulkEditPreviewContribution.ctxEnabled)),
+            menu: [{
+                    id: MenuId.BulkEditContext,
+                    order: 3
+                }]
+        });
+    }
+    async run(accessor) {
+        const viewsService = accessor.get(IViewsService);
+        const view = await getBulkEditPane(viewsService);
+        view?.toggleGrouping();
+    }
+});
+( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(BulkEditPreviewContribution, 2 );
+const refactorPreviewViewIcon = registerIcon('refactor-preview-view-icon', Codicon.lightbulb, ( localizeWithPath(
+    'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+    'refactorPreviewViewIcon',
+    'View icon of the refactor preview view.'
+)));
+const container = ( Registry.as(Extensions$1.ViewContainersRegistry)).registerViewContainer({
+    id: BulkEditPane.ID,
+    title: ( localize2WithPath(
+        'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+        'panel',
+        "Refactor Preview"
+    )),
+    hideIfEmpty: true,
+    ctorDescriptor: ( new SyncDescriptor(
+        ViewPaneContainer,
+        [BulkEditPane.ID, { mergeViewWithContainerWhenSingleView: true }]
+    )),
+    icon: refactorPreviewViewIcon,
+    storageId: BulkEditPane.ID
+}, 1 );
+( Registry.as(Extensions$1.ViewsRegistry)).registerViews([{
+        id: BulkEditPane.ID,
+        name: ( localize2WithPath(
+            'vs/workbench/contrib/bulkEdit/browser/preview/bulkEdit.contribution',
+            'panel',
+            "Refactor Preview"
+        )),
+        when: BulkEditPreviewContribution.ctxEnabled,
+        ctorDescriptor: ( new SyncDescriptor(BulkEditPane)),
+        containerIcon: refactorPreviewViewIcon,
+    }], container);

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

@@ -0,0 +1,6 @@
+import n from '../../../../../../../../external/rollup-plugin-styles/dist/runtime/inject-css.js';
+
+var css = ".monaco-workbench .bulk-edit-panel .highlight.insert{background-color:var(--vscode-diffEditor-insertedTextBackground)}.monaco-workbench .bulk-edit-panel .highlight.remove{background-color:var(--vscode-diffEditor-removedTextBackground);text-decoration:line-through}.monaco-workbench .bulk-edit-panel .message{padding:10px 20px}.monaco-workbench .bulk-edit-panel[data-state=data] .content,.monaco-workbench .bulk-edit-panel[data-state=message] .message{display:flex}.monaco-workbench .bulk-edit-panel[data-state=data] .message,.monaco-workbench .bulk-edit-panel[data-state=message] .content{display:none}.monaco-workbench .bulk-edit-panel .content{display:flex;flex-direction:column;justify-content:space-between}.monaco-workbench .bulk-edit-panel .content .buttons{padding-left:20px;padding-top:10px}.monaco-workbench .bulk-edit-panel .content .buttons .monaco-button{display:inline-flex;margin:0 4px;padding:4px 8px;width:inherit}.monaco-workbench .bulk-edit-panel .monaco-tl-contents{display:flex}.monaco-workbench .bulk-edit-panel .monaco-tl-contents .edit-checkbox{align-self:center}.monaco-workbench .bulk-edit-panel .monaco-tl-contents .edit-checkbox.disabled{opacity:.5}.monaco-workbench .bulk-edit-panel .monaco-tl-contents .monaco-icon-label.delete .monaco-icon-label-container{text-decoration:line-through}.monaco-workbench .bulk-edit-panel .monaco-tl-contents .details{font-size:.9em;margin-left:.5em;opacity:.7;white-space:pre}.monaco-workbench .bulk-edit-panel .monaco-tl-contents.category{align-items:center;display:flex;flex:1;flex-flow:row nowrap}.monaco-workbench .bulk-edit-panel .monaco-tl-contents.category .theme-icon,.monaco-workbench .bulk-edit-panel .monaco-tl-contents.textedit .theme-icon{margin-right:4px}.monaco-workbench .bulk-edit-panel .monaco-tl-contents.category .uri-icon,.monaco-workbench .bulk-edit-panel .monaco-tl-contents.textedit .uri-icon,.monaco-workbench.hc-light .bulk-edit-panel .monaco-tl-contents.category .uri-icon,.monaco-workbench.hc-light .bulk-edit-panel .monaco-tl-contents.textedit .uri-icon{background-image:var(--background-light);background-position:0;background-repeat:no-repeat;background-size:contain;height:100%;margin-right:4px;min-width:16px;width:16px}.monaco-workbench.hc-black .bulk-edit-panel .monaco-tl-contents.category .uri-icon,.monaco-workbench.hc-black .bulk-edit-panel .monaco-tl-contents.textedit .uri-icon,.monaco-workbench.vs-dark .bulk-edit-panel .monaco-tl-contents.category .uri-icon,.monaco-workbench.vs-dark .bulk-edit-panel .monaco-tl-contents.textedit .uri-icon{background-image:var(--background-dark)}.monaco-workbench .bulk-edit-panel .monaco-tl-contents.textedit .monaco-highlighted-label{overflow:hidden;text-overflow:ellipsis}";
+n(css,{});
+
+export { css, css as default };