@codingame/monaco-vscode-view-common-service-override 4.5.1 → 5.0.0

package/vscode/src/vs/workbench/browser/parts/editor/editorConfiguration.js

@@ -13,62 +13,47 @@ import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/service
 import { getLargeFileConfirmationLimit, ByteSize } from 'vscode/vscode/vs/platform/files/common/files';
 
 var DynamicEditorConfigurations_1;
+const _moduleId = "vs/workbench/browser/parts/editor/editorConfiguration";
 let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disposable {
     static { DynamicEditorConfigurations_1 = this; }
     static { this.ID = 'workbench.contrib.dynamicEditorConfigurations'; }
-    static { this.AUTO_LOCK_DEFAULT_ENABLED = ( new Set([
+    static { this.AUTO_LOCK_DEFAULT_ENABLED = ( (new Set([
         'terminalEditor',
         'mainThreadWebview-simpleBrowser.view',
         'mainThreadWebview-browserPreview'
-    ])); }
+    ]))); }
     static { this.AUTO_LOCK_EXTRA_EDITORS = [
         {
             id: 'workbench.input.interactive',
-            label: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/editorConfiguration',
-                'interactiveWindow',
-                'Interactive Window'
-            )),
+            label: ( localizeWithPath(_moduleId, 0, 'Interactive Window')),
             priority: RegisteredEditorPriority.builtin
         },
         {
             id: 'mainThreadWebview-markdown.preview',
-            label: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/editorConfiguration',
-                'markdownPreview',
-                "Markdown Preview"
-            )),
+            label: ( localizeWithPath(_moduleId, 1, "Markdown Preview")),
             priority: RegisteredEditorPriority.builtin
         },
         {
             id: 'mainThreadWebview-simpleBrowser.view',
-            label: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/editorConfiguration',
-                'simpleBrowser',
-                "Simple Browser"
-            )),
+            label: ( localizeWithPath(_moduleId, 2, "Simple Browser")),
             priority: RegisteredEditorPriority.builtin
         },
         {
             id: 'mainThreadWebview-browserPreview',
-            label: ( localizeWithPath(
-                'vs/workbench/browser/parts/editor/editorConfiguration',
-                'livePreview',
-                "Live Preview"
-            )),
+            label: ( localizeWithPath(_moduleId, 3, "Live Preview")),
             priority: RegisteredEditorPriority.builtin
         }
     ]; }
-    static { this.AUTO_LOCK_REMOVE_EDITORS = ( new Set([
+    static { this.AUTO_LOCK_REMOVE_EDITORS = ( (new Set([
         'vscode-interactive-input',
         'interactive',
         'vscode.markdown.preview.editor'
-    ])); }
+    ]))); }
     constructor(editorResolverService, extensionService, environmentService) {
         super();
         this.editorResolverService = editorResolverService;
         this.environmentService = environmentService;
-        this.configurationRegistry = ( Registry.as(Extensions.Configuration));
+        this.configurationRegistry = ( (Registry.as(Extensions.Configuration)));
         (async () => {
             await extensionService.whenInstalledExtensionsRegistered();
             this.updateDynamicEditorConfigurations();
@@ -79,19 +64,19 @@ let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disp
         this._register(Event.debounce(this.editorResolverService.onDidChangeEditorRegistrations, (_, e) => e)(() => this.updateDynamicEditorConfigurations()));
     }
     updateDynamicEditorConfigurations() {
-        const lockableEditors = [...this.editorResolverService.getEditors(), ...DynamicEditorConfigurations_1.AUTO_LOCK_EXTRA_EDITORS].filter(e => !( DynamicEditorConfigurations_1.AUTO_LOCK_REMOVE_EDITORS.has(e.id)));
-        const binaryEditorCandidates = ( this.editorResolverService.getEditors().filter(e => e.priority !== RegisteredEditorPriority.exclusive).map(e => e.id));
+        const lockableEditors = [...this.editorResolverService.getEditors(), ...DynamicEditorConfigurations_1.AUTO_LOCK_EXTRA_EDITORS].filter(e => !( (DynamicEditorConfigurations_1.AUTO_LOCK_REMOVE_EDITORS.has(e.id))));
+        const binaryEditorCandidates = ( (this.editorResolverService.getEditors().filter(e => e.priority !== RegisteredEditorPriority.exclusive).map(e => e.id)));
         const autoLockGroupConfiguration = Object.create(null);
         for (const editor of lockableEditors) {
             autoLockGroupConfiguration[editor.id] = {
                 type: 'boolean',
-                default: ( DynamicEditorConfigurations_1.AUTO_LOCK_DEFAULT_ENABLED.has(editor.id)),
+                default: ( (DynamicEditorConfigurations_1.AUTO_LOCK_DEFAULT_ENABLED.has(editor.id))),
                 description: editor.label
             };
         }
         const defaultAutoLockGroupConfiguration = Object.create(null);
         for (const editor of lockableEditors) {
-            defaultAutoLockGroupConfiguration[editor.id] = ( DynamicEditorConfigurations_1.AUTO_LOCK_DEFAULT_ENABLED.has(editor.id));
+            defaultAutoLockGroupConfiguration[editor.id] = ( (DynamicEditorConfigurations_1.AUTO_LOCK_DEFAULT_ENABLED.has(editor.id)));
         }
         const oldAutoLockConfigurationNode = this.autoLockConfigurationNode;
         this.autoLockConfigurationNode = {
@@ -100,8 +85,8 @@ let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disp
                 'workbench.editor.autoLockGroups': {
                     type: 'object',
                     description: ( localizeWithPath(
-                        'vs/workbench/browser/parts/editor/editorConfiguration',
-                        'workbench.editor.autoLockGroups',
+                        _moduleId,
+                        4,
                         "If an editor matching one of the listed types is opened as the first in an editor group and more than one group is open, the group is automatically locked. Locked groups will only be used for opening editors when explicitly chosen by a user gesture (for example drag and drop), but not by default. Consequently, the active editor in a locked group is less likely to be replaced accidentally with a different editor."
                     )),
                     properties: autoLockGroupConfiguration,
@@ -119,8 +104,8 @@ let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disp
                     default: '',
                     enum: [...binaryEditorCandidates, ''],
                     description: ( localizeWithPath(
-                        'vs/workbench/browser/parts/editor/editorConfiguration',
-                        'workbench.editor.defaultBinaryEditor',
+                        _moduleId,
+                        5,
                         "The default editor for files detected as binary. If undefined, the user will be presented with a picker."
                     )),
                 }
@@ -133,8 +118,8 @@ let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disp
                 'workbench.editorAssociations': {
                     type: 'object',
                     markdownDescription: ( localizeWithPath(
-                        'vs/workbench/browser/parts/editor/editorConfiguration',
-                        'editor.editorAssociations',
+                        _moduleId,
+                        6,
                         "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
                     )),
                     patternProperties: {
@@ -156,8 +141,8 @@ let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disp
                     minimum: 1,
                     scope: 4 ,
                     markdownDescription: ( localizeWithPath(
-                        'vs/workbench/browser/parts/editor/editorConfiguration',
-                        'editorLargeFileSizeConfirmation',
+                        _moduleId,
+                        7,
                         "Controls the minimum size of a file in MB before asking for confirmation when opening in the editor. Note that this setting may not apply to all editor types and environments."
                     )),
                 }
@@ -179,10 +164,10 @@ let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disp
         });
     }
 };
-DynamicEditorConfigurations = DynamicEditorConfigurations_1 = ( __decorate([
-    ( __param(0, IEditorResolverService)),
-    ( __param(1, IExtensionService)),
-    ( __param(2, IWorkbenchEnvironmentService))
-], DynamicEditorConfigurations));
+DynamicEditorConfigurations = DynamicEditorConfigurations_1 = ( (__decorate([
+    ( (__param(0, IEditorResolverService))),
+    ( (__param(1, IExtensionService))),
+    ( (__param(2, IWorkbenchEnvironmentService)))
+], DynamicEditorConfigurations)));
 
 export { DynamicEditorConfigurations };

package/vscode/src/vs/workbench/browser/parts/editor/editorDropTarget.js

@@ -36,6 +36,7 @@ import { ITreeViewsDnDService } from 'vscode/vscode/vs/editor/common/services/tr
 import { DraggedTreeItemsIdentifier } from 'vscode/vscode/vs/editor/common/services/treeViewsDnd';
 
 var DropOverlay_1;
+const _moduleId = "vs/workbench/browser/parts/editor/editorDropTarget";
 function isDropIntoEditorEnabledGlobally(configurationService) {
     return configurationService.getValue('editor.dropIntoEditor.enabled');
 }
@@ -58,7 +59,7 @@ let DropOverlay = class DropOverlay extends Themable {
         this.editorTransfer = LocalSelectionTransfer.getInstance();
         this.groupTransfer = LocalSelectionTransfer.getInstance();
         this.treeItemsTransfer = LocalSelectionTransfer.getInstance();
-        this.cleanupOverlayScheduler = this._register(( new RunOnceScheduler(() => this.dispose(), 300)));
+        this.cleanupOverlayScheduler = this._register(( (new RunOnceScheduler(() => this.dispose(), 300))));
         this.enableDropIntoEditor = isDropIntoEditorEnabledGlobally(this.configurationService) && this.isDropIntoActiveEditorEnabled();
         this.create();
     }
@@ -78,8 +79,8 @@ let DropOverlay = class DropOverlay extends Themable {
         container.appendChild(this.overlay);
         if (this.enableDropIntoEditor) {
             this.dropIntoPromptElement = renderFormattedText(( localizeWithPath(
-                'vs/workbench/browser/parts/editor/editorDropTarget',
-                'dropIntoEditorPrompt',
+                _moduleId,
+                0,
                 "Hold __{0}__ to drop into editor",
                 isMacintosh ? '⇧' : 'Shift'
             )), {});
@@ -112,7 +113,7 @@ let DropOverlay = class DropOverlay extends Themable {
         }
     }
     registerListeners(container) {
-        this._register(( new DragAndDropObserver(container, {
+        this._register(( (new DragAndDropObserver(container, {
             onDragOver: e => {
                 if (this.enableDropIntoEditor && isDragIntoEditorEvent(e)) {
                     this.dispose();
@@ -160,7 +161,7 @@ let DropOverlay = class DropOverlay extends Themable {
                     this.handleDrop(e, this.currentDropOperation.splitDirection);
                 }
             }
-        })));
+        }))));
         this._register(addDisposableListener(container, EventType.MOUSE_OVER, () => {
             if (!this.cleanupOverlayScheduler.isScheduled()) {
                 this.cleanupOverlayScheduler.schedule();
@@ -267,7 +268,7 @@ let DropOverlay = class DropOverlay extends Themable {
                     const dataTransferItem = await this.treeViewsDragAndDropService.removeDragOperationTransfer(id.identifier);
                     if (dataTransferItem) {
                         const treeDropData = await extractTreeDropData(dataTransferItem);
-                        editors.push(...( treeDropData.map(editor => ({ ...editor, options: { ...editor.options, pinned: true } }))));
+                        editors.push(...( (treeDropData.map(editor => ({ ...editor, options: { ...editor.options, pinned: true } })))));
                     }
                 }
                 if (editors.length) {
@@ -420,15 +421,15 @@ let DropOverlay = class DropOverlay extends Themable {
         this._disposed = true;
     }
 };
-DropOverlay = DropOverlay_1 = ( __decorate([
-    ( __param(1, IThemeService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IEditorService)),
-    ( __param(5, IEditorGroupsService)),
-    ( __param(6, ITreeViewsDnDService)),
-    ( __param(7, IWorkspaceContextService))
-], DropOverlay));
+DropOverlay = DropOverlay_1 = ( (__decorate([
+    ( (__param(1, IThemeService))),
+    ( (__param(2, IConfigurationService))),
+    ( (__param(3, IInstantiationService))),
+    ( (__param(4, IEditorService))),
+    ( (__param(5, IEditorGroupsService))),
+    ( (__param(6, ITreeViewsDnDService))),
+    ( (__param(7, IWorkspaceContextService)))
+], DropOverlay)));
 let EditorDropTarget = class EditorDropTarget extends Themable {
     constructor(container, delegate, editorGroupService, themeService, configurationService, instantiationService) {
         super(themeService);
@@ -463,8 +464,8 @@ let EditorDropTarget = class EditorDropTarget extends Themable {
         if (!this.editorTransfer.hasData(DraggedEditorIdentifier.prototype) &&
             !this.groupTransfer.hasData(DraggedEditorGroupIdentifier.prototype) &&
             event.dataTransfer) {
-            const dndContributions = ( Registry.as(Extensions.DragAndDropContribution)).getAll();
-            const dndContributionKeys = ( Array.from(dndContributions).map(e => e.dataFormatKey));
+            const dndContributions = ( (Registry.as(Extensions.DragAndDropContribution))).getAll();
+            const dndContributionKeys = ( (Array.from(dndContributions).map(e => e.dataFormatKey)));
             if (!containsDragType(event, DataTransfers.FILES, CodeDataTransfers.FILES, DataTransfers.RESOURCES, CodeDataTransfers.EDITORS, ...dndContributionKeys)) {
                 event.dataTransfer.dropEffect = 'none';
                 return;
@@ -513,11 +514,11 @@ let EditorDropTarget = class EditorDropTarget extends Themable {
         }
     }
 };
-EditorDropTarget = ( __decorate([
-    ( __param(2, IEditorGroupsService)),
-    ( __param(3, IThemeService)),
-    ( __param(4, IConfigurationService)),
-    ( __param(5, IInstantiationService))
-], EditorDropTarget));
+EditorDropTarget = ( (__decorate([
+    ( (__param(2, IEditorGroupsService))),
+    ( (__param(3, IThemeService))),
+    ( (__param(4, IConfigurationService))),
+    ( (__param(5, IInstantiationService)))
+], EditorDropTarget)));
 
 export { EditorDropTarget };

package/vscode/src/vs/workbench/browser/parts/editor/editorPart.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
 import { IThemeService } from 'vscode/vscode/vs/platform/theme/common/themeService.service';
 import { Part } from 'vscode/vscode/vs/workbench/browser/part';
 import { $, getWindow, getActiveElement, isAncestorOfActiveElement, addDisposableGenericMouseDownListener, EventHelper, Dimension } from 'vscode/vscode/vs/base/browser/dom';
-import { Relay, Event, Emitter } from 'vscode/vscode/vs/base/common/event';
+import { Relay, Event, Emitter, PauseableEmitter } from 'vscode/vscode/vs/base/common/event';
 import 'vscode/vscode/vs/platform/theme/common/colorUtils';
 import { contrastBorder } from 'vscode/vscode/vs/platform/theme/common/colors/baseColors';
 import 'vscode/vscode/vs/platform/theme/common/colors/chartsColors';
@@ -104,7 +104,7 @@ let EditorPart = class EditorPart extends Part {
         this.onDidActivateGroup = this._onDidActivateGroup.event;
         this._onDidAddGroup = this._register(( new Emitter()));
         this.onDidAddGroup = this._onDidAddGroup.event;
-        this._onDidRemoveGroup = this._register(( new Emitter()));
+        this._onDidRemoveGroup = this._register(( new PauseableEmitter()));
         this.onDidRemoveGroup = this._onDidRemoveGroup.event;
         this._onDidMoveGroup = this._register(( new Emitter()));
         this.onDidMoveGroup = this._onDidMoveGroup.event;
@@ -224,7 +224,7 @@ let EditorPart = class EditorPart extends Part {
         if (typeof scope.location === 'number') {
             return this.doFindGroupByLocation(scope.location, source, wrap);
         }
-        throw new Error('invalid arguments');
+        throw ( new Error('invalid arguments'));
     }
     doFindGroupByDirection(direction, source, wrap) {
         const sourceGroupView = this.assertGroupView(source);
@@ -581,7 +581,7 @@ let EditorPart = class EditorPart extends Part {
         const sourceView = this.assertGroupView(group);
         const targetView = this.assertGroupView(location);
         if (sourceView.id === targetView.id) {
-            throw new Error('Cannot move group into its own');
+            throw ( new Error('Cannot move group into its own'));
         }
         const restoreFocus = this.shouldRestoreFocus(sourceView.element);
         let movedView;
@@ -623,26 +623,31 @@ let EditorPart = class EditorPart extends Part {
             editors.push({ editor, options });
             index++;
         }
+        let result = true;
         if (options?.mode === 0 ) {
             sourceView.copyEditors(editors, targetView);
         }
         else {
-            sourceView.moveEditors(editors, targetView);
+            result = sourceView.moveEditors(editors, targetView);
         }
         if (sourceView.isEmpty && !sourceView.disposed ) {
             this.removeGroup(sourceView, true);
         }
-        return targetView;
+        return result;
     }
     mergeAllGroups(target) {
         const targetView = this.assertGroupView(target);
+        let result = true;
         for (const group of this.getGroups(1 )) {
             if (group === targetView) {
                 continue;
             }
-            this.mergeGroup(group, targetView);
+            const merged = this.mergeGroup(group, targetView);
+            if (!merged) {
+                result = false;
+            }
         }
-        return targetView;
+        return result;
     }
     assertGroupView(group) {
         let groupView;
@@ -653,7 +658,7 @@ let EditorPart = class EditorPart extends Part {
             groupView = group;
         }
         if (!groupView) {
-            throw new Error('Invalid editor group provided!');
+            throw ( new Error('Invalid editor group provided!'));
         }
         return groupView;
     }
@@ -952,17 +957,41 @@ let EditorPart = class EditorPart extends Part {
             mostRecentActiveGroups: this.mostRecentActiveGroups
         };
     }
-    async applyState(state) {
-        for (const group of this.getGroups(1 )) {
-            const closed = await group.closeAllEditors();
-            if (!closed) {
-                return false;
-            }
+    applyState(state) {
+        if (state === 'empty') {
+            return this.doApplyEmptyState();
         }
-        this.disposeGroups();
+        else {
+            return this.doApplyState(state);
+        }
+    }
+    async doApplyState(state) {
+        const groups = await this.doPrepareApplyState();
+        const resumeEvents = this.disposeGroups(true );
         this.mostRecentActiveGroups = state.mostRecentActiveGroups;
-        this.doApplyGridState(state.serializedGrid, state.activeGroup);
-        return true;
+        try {
+            this.doApplyGridState(state.serializedGrid, state.activeGroup);
+        }
+        finally {
+            resumeEvents();
+        }
+        await this.activeGroup.openEditors(( groups
+            .flatMap(group => group.editors)
+            .filter(editor => this.editorPartsView.groups.every(groupView => !groupView.contains(editor)))
+            .map(editor => ({
+            editor, options: { pinned: true, preserveFocus: true, inactive: true }
+        }))));
+    }
+    async doApplyEmptyState() {
+        await this.doPrepareApplyState();
+        this.mergeAllGroups(this.activeGroup);
+    }
+    async doPrepareApplyState() {
+        const groups = this.getGroups(1 );
+        for (const group of groups) {
+            await group.closeAllEditors({ excludeConfirming: true });
+        }
+        return groups;
     }
     doApplyGridState(gridState, activeGroupId, editorGroupViewsToReuse) {
         this.doCreateGridControlWithState(gridState, activeGroupId, editorGroupViewsToReuse);
@@ -989,13 +1018,19 @@ let EditorPart = class EditorPart extends Part {
             type: "workbench.parts.editor"
         };
     }
-    disposeGroups() {
+    disposeGroups(surpressEvents) {
+        if (surpressEvents) {
+            this._onDidRemoveGroup.pause();
+        }
         for (const group of this.groups) {
             group.dispose();
             this._onDidRemoveGroup.fire(group);
         }
         this.groupViews.clear();
         this.mostRecentActiveGroups = [];
+        if (surpressEvents) {
+            return () => this._onDidRemoveGroup.resume();
+        }
     }
     dispose() {
         this.disposeGroups();