@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

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

@@ -0,0 +1,184 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { Registry } from '../../../../platform/registry/common/platform.js';
+import { Disposable } from '../../../../base/common/lifecycle.js';
+import { Extensions } from '../../../../platform/configuration/common/configurationRegistry.js';
+import { workbenchConfigurationNodeBase } from '../../../common/configuration.js';
+import { RegisteredEditorPriority, IEditorResolverService } from '../../../services/editor/common/editorResolverService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { coalesce } from '../../../../base/common/arrays.js';
+import { Event } from '../../../../base/common/event.js';
+import { IWorkbenchEnvironmentService } from '../../../services/environment/common/environmentService.js';
+import { getLargeFileConfirmationLimit, ByteSize } from '../../../../platform/files/common/files.js';
+var DynamicEditorConfigurations_1;
+let DynamicEditorConfigurations = class DynamicEditorConfigurations extends Disposable {
+    static { DynamicEditorConfigurations_1 = this; }
+    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'
+            )),
+            priority: RegisteredEditorPriority.builtin
+        },
+        {
+            id: 'mainThreadWebview-markdown.preview',
+            label: ( localizeWithPath(
+                'vs/workbench/browser/parts/editor/editorConfiguration',
+                'markdownPreview',
+                "Markdown Preview"
+            )),
+            priority: RegisteredEditorPriority.builtin
+        },
+        {
+            id: 'mainThreadWebview-simpleBrowser.view',
+            label: ( localizeWithPath(
+                'vs/workbench/browser/parts/editor/editorConfiguration',
+                'simpleBrowser',
+                "Simple Browser"
+            )),
+            priority: RegisteredEditorPriority.builtin
+        },
+        {
+            id: 'mainThreadWebview-browserPreview',
+            label: ( localizeWithPath(
+                'vs/workbench/browser/parts/editor/editorConfiguration',
+                'livePreview',
+                "Live Preview"
+            )),
+            priority: RegisteredEditorPriority.builtin
+        }
+    ]; }
+    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));
+        (async () => {
+            await extensionService.whenInstalledExtensionsRegistered();
+            this.updateDynamicEditorConfigurations();
+            this.registerListeners();
+        })();
+    }
+    registerListeners() {
+        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 autoLockGroupConfiguration = Object.create(null);
+        for (const editor of lockableEditors) {
+            autoLockGroupConfiguration[editor.id] = {
+                type: 'boolean',
+                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));
+        }
+        const oldAutoLockConfigurationNode = this.autoLockConfigurationNode;
+        this.autoLockConfigurationNode = {
+            ...workbenchConfigurationNodeBase,
+            properties: {
+                'workbench.editor.autoLockGroups': {
+                    type: 'object',
+                    description: ( localizeWithPath(
+                        'vs/workbench/browser/parts/editor/editorConfiguration',
+                        'workbench.editor.autoLockGroups',
+                        "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,
+                    default: defaultAutoLockGroupConfiguration,
+                    additionalProperties: false
+                }
+            }
+        };
+        const oldDefaultBinaryEditorConfigurationNode = this.defaultBinaryEditorConfigurationNode;
+        this.defaultBinaryEditorConfigurationNode = {
+            ...workbenchConfigurationNodeBase,
+            properties: {
+                'workbench.editor.defaultBinaryEditor': {
+                    type: 'string',
+                    default: '',
+                    enum: [...binaryEditorCandidates, ''],
+                    description: ( localizeWithPath(
+                        'vs/workbench/browser/parts/editor/editorConfiguration',
+                        'workbench.editor.defaultBinaryEditor',
+                        "The default editor for files detected as binary. If undefined, the user will be presented with a picker."
+                    )),
+                }
+            }
+        };
+        const oldEditorAssociationsConfigurationNode = this.editorAssociationsConfigurationNode;
+        this.editorAssociationsConfigurationNode = {
+            ...workbenchConfigurationNodeBase,
+            properties: {
+                'workbench.editorAssociations': {
+                    type: 'object',
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/browser/parts/editor/editorConfiguration',
+                        'editor.editorAssociations',
+                        "Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `\"*.hex\": \"hexEditor.hexedit\"`). These have precedence over the default behavior."
+                    )),
+                    patternProperties: {
+                        '.*': {
+                            type: 'string',
+                            enum: binaryEditorCandidates,
+                        }
+                    }
+                }
+            }
+        };
+        const oldEditorLargeFileConfirmationConfigurationNode = this.editorLargeFileConfirmationConfigurationNode;
+        this.editorLargeFileConfirmationConfigurationNode = {
+            ...workbenchConfigurationNodeBase,
+            properties: {
+                'workbench.editorLargeFileConfirmation': {
+                    type: 'number',
+                    default: getLargeFileConfirmationLimit(this.environmentService.remoteAuthority) / ByteSize.MB,
+                    minimum: 1,
+                    scope: 4 ,
+                    markdownDescription: ( localizeWithPath(
+                        'vs/workbench/browser/parts/editor/editorConfiguration',
+                        'editorLargeFileSizeConfirmation',
+                        "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."
+                    )),
+                }
+            }
+        };
+        this.configurationRegistry.updateConfigurations({
+            add: [
+                this.autoLockConfigurationNode,
+                this.defaultBinaryEditorConfigurationNode,
+                this.editorAssociationsConfigurationNode,
+                this.editorLargeFileConfirmationConfigurationNode
+            ],
+            remove: coalesce([
+                oldAutoLockConfigurationNode,
+                oldDefaultBinaryEditorConfigurationNode,
+                oldEditorAssociationsConfigurationNode,
+                oldEditorLargeFileConfirmationConfigurationNode
+            ])
+        });
+    }
+};
+DynamicEditorConfigurations = DynamicEditorConfigurations_1 = ( __decorate([
+    ( __param(0, IEditorResolverService)),
+    ( __param(1, IExtensionService)),
+    ( __param(2, IWorkbenchEnvironmentService))
+], DynamicEditorConfigurations));
+export { DynamicEditorConfigurations };