@theia/plugin-ext 1.34.1 → 1.35.0

package/src/main/browser/webview/webview-context-keys.ts

@@ -0,0 +1,49 @@
+// *****************************************************************************
+// Copyright (C) 2023 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable, postConstruct } from '@theia/core/shared/inversify';
+import { ContextKey, ContextKeyService } from '@theia/core/lib/browser/context-key-service';
+import { ApplicationShell, FocusTracker, Widget } from '@theia/core/lib/browser';
+import { WebviewWidget } from './webview';
+
+@injectable()
+export class WebviewContextKeys {
+
+    /**
+     * Context key representing the `viewType` of the active `WebviewWidget`, if any.
+     */
+    activeWebviewPanelId: ContextKey<string>;
+
+    @inject(ApplicationShell)
+    protected applicationShell: ApplicationShell;
+
+    @inject(ContextKeyService)
+    protected contextKeyService: ContextKeyService;
+
+    @postConstruct()
+    protected postConstruct(): void {
+        this.activeWebviewPanelId = this.contextKeyService.createKey('activeWebviewPanelId', '');
+        this.applicationShell.onDidChangeCurrentWidget(this.handleDidChangeCurrentWidget, this);
+    }
+
+    protected handleDidChangeCurrentWidget(change: FocusTracker.IChangedArgs<Widget>): void {
+        if (change.newValue instanceof WebviewWidget) {
+            this.activeWebviewPanelId.set(change.newValue.viewType);
+        } else {
+            this.activeWebviewPanelId.set('');
+        }
+    }
+}

package/src/plugin/dialogs.ts

@@ -30,8 +30,8 @@ export class DialogsExtImpl {
             title: options.title,
             openLabel: options.openLabel,
             defaultUri: options.defaultUri ? options.defaultUri.path : undefined,
-            canSelectFiles: options.canSelectFiles ? options.canSelectFiles : true,
-            canSelectFolders: options.canSelectFolders ? options.canSelectFolders : false,
+            canSelectFiles: typeof options.canSelectFiles === 'boolean' ? options.canSelectFiles : true,
+            canSelectFolders: typeof options.canSelectFolders === 'boolean' ? options.canSelectFolders : false,
             canSelectMany: options.canSelectMany,
             filters: options.filters
         } as OpenDialogOptionsMain;

package/src/plugin/file-system-ext-impl.ts

@@ -35,16 +35,16 @@ import { PLUGIN_RPC_CONTEXT, FileSystemExt, FileSystemMain, IFileChangeDto } fro
 import * as vscode from '@theia/plugin';
 import * as files from '@theia/filesystem/lib/common/files';
 import * as typeConverter from './type-converters';
-import { LanguagesExtImpl } from './languages';
 import { Schemes as Schemas } from '../common/uri-components';
 import { State, StateMachine, LinkComputer, Edge } from '../common/link-computer';
 import { commonPrefixLength } from '@theia/core/lib/common/strings';
 import { CharCode } from '@theia/core/lib/common/char-code';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { Emitter } from '@theia/core/shared/vscode-languageserver-protocol';
 
 type IDisposable = vscode.Disposable;
 
-class FsLinkProvider {
+export class FsLinkProvider {
 
     private _schemes: string[] = [];
     private _stateMachine?: StateMachine;
@@ -204,12 +204,14 @@ export class FileSystemExtImpl implements FileSystemExt {
     private readonly _usedSchemes = new Set<string>();
     private readonly _watches = new Map<number, IDisposable>();
 
-    private _linkProviderRegistration?: IDisposable;
+    private readonly onWillRegisterFileSystemProviderEmitter = new Emitter<FsLinkProvider>();
+    readonly onWillRegisterFileSystemProvider = this.onWillRegisterFileSystemProviderEmitter.event;
+
     private _handlePool: number = 0;
 
     readonly fileSystem: vscode.FileSystem;
 
-    constructor(rpc: RPCProtocol, private _extHostLanguageFeatures: LanguagesExtImpl) {
+    constructor(rpc: RPCProtocol) {
         this._proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.FILE_SYSTEM_MAIN);
         this.fileSystem = new ConsumerFileSystem(this._proxy, this._capabilities);
 
@@ -218,18 +220,7 @@ export class FileSystemExtImpl implements FileSystemExt {
     }
 
     dispose(): void {
-        if (this._linkProviderRegistration) {
-            this._linkProviderRegistration.dispose();
-        }
-    }
-
-    private _registerLinkProviderIfNotYetRegistered(): void {
-        if (!this._linkProviderRegistration) {
-            this._linkProviderRegistration = this._extHostLanguageFeatures.registerDocumentLinkProvider('*', this._linkProvider, {
-                id: 'theia.fs-ext-impl',
-                name: 'fs-ext-impl'
-            });
-        }
+        this.onWillRegisterFileSystemProviderEmitter.dispose();
     }
 
     registerFileSystemProvider(scheme: string, provider: vscode.FileSystemProvider, options: { isCaseSensitive?: boolean, isReadonly?: boolean } = {}) {
@@ -238,8 +229,7 @@ export class FileSystemExtImpl implements FileSystemExt {
             throw new Error(`a provider for the scheme '${scheme}' is already registered`);
         }
 
-        //
-        this._registerLinkProviderIfNotYetRegistered();
+        this.onWillRegisterFileSystemProviderEmitter.fire(this._linkProvider);
 
         const handle = this._handlePool++;
         this._linkProvider.add(scheme);

package/src/plugin/known-commands.ts

@@ -14,8 +14,9 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { Range as R, Position as P, Location as L } from '@theia/core/shared/vscode-languageserver-protocol';
 import * as theia from '@theia/plugin';
+import { Range as R, Position as P, Location as L } from '@theia/core/shared/vscode-languageserver-protocol';
+import { URI as TheiaURI } from '@theia/core/lib/common/uri';
 import { cloneAndChange } from '../common/objects';
 import { Position, Range, Location, CallHierarchyItem, TypeHierarchyItem, URI, TextDocumentShowOptions } from './types-impl';
 import {
@@ -63,6 +64,9 @@ export namespace KnownCommands {
         }
     };
 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const identity = (args: any[]) => args;
+
     mappings['editor.action.select.all'] = ['editor.action.select.all', CONVERT_VSCODE_TO_MONACO];
     mappings['editor.action.toggleHighContrast'] = ['editor.action.toggleHighContrast', CONVERT_VSCODE_TO_MONACO];
     mappings['editor.action.moveCarretLeftAction'] = ['editor.action.moveCarretLeftAction', CONVERT_VSCODE_TO_MONACO];
@@ -302,6 +306,17 @@ export namespace KnownCommands {
     mappings['vscode.open'] = ['vscode.open', CONVERT_VSCODE_TO_MONACO];
     mappings['vscode.diff'] = ['vscode.diff', CONVERT_VSCODE_TO_MONACO];
 
+    // terminal commands
+    mappings['workbench.action.terminal.new'] = ['terminal:new', identity];
+    mappings['workbench.action.terminal.newWithProfile'] = ['terminal:new:profile', identity];
+    mappings['workbench.action.terminal.selectDefaultShell'] = ['terminal:profile:default', identity];
+    mappings['workbench.action.terminal.newInActiveWorkspace'] = ['terminal:new:active:workspace', identity];
+    mappings['workbench.action.terminal.clear'] = ['terminal:clear', identity];
+    mappings['openInTerminal'] = ['terminal:context', createConversionFunction((uri: URI) => new TheiaURI(uri))];
+    mappings['workbench.action.terminal.split'] = ['terminal:split', identity];
+    mappings['workbench.action.terminal.focusFind'] = ['terminal:find', identity];
+    mappings['workbench.action.terminal.hideFind'] = ['terminal:find:cancel', identity];
+
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     export function map<T>(id: string, args: any[] | undefined, toDo: (mappedId: string, mappedArgs: any[] | undefined, mappedResult: ConversionFunction | undefined) => T): T {
         if (mappings[id]) {

package/src/plugin/languages/document-drop-edit.ts

@@ -0,0 +1,44 @@
+// *****************************************************************************
+// Copyright (C) 2018 Red Hat, Inc. and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+import * as theia from '@theia/plugin';
+import { DataTransferDTO, DocumentDropEdit } from '../../common/plugin-api-rpc-model';
+import { CancellationToken } from '@theia/core/shared/vscode-languageserver-protocol';
+import { Position } from '../../common/plugin-api-rpc';
+import * as Converter from '../type-converters';
+import { DocumentsExtImpl } from '../documents';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { FileSystemExtImpl } from '../file-system-ext-impl';
+import * as os from 'os';
+import * as path from 'path';
+
+export class DocumentDropEditAdapter {
+    constructor(private readonly provider: theia.DocumentDropEditProvider,
+        private readonly documents: DocumentsExtImpl,
+        private readonly fileSystem: FileSystemExtImpl) { }
+
+    async provideDocumentDropEdits(resource: URI, position: Position, dataTransfer: DataTransferDTO, token: CancellationToken): Promise<DocumentDropEdit | undefined> {
+        return this.provider.provideDocumentDropEdits(
+            this.documents.getDocument(resource),
+            Converter.toPosition(position),
+            Converter.DataTransfer.toDataTransfer(dataTransfer, itemId => this.resolveFileData(itemId)),
+            token) as DocumentDropEdit | undefined;
+    }
+
+    private async resolveFileData(itemId: string): Promise<Uint8Array> {
+        const filePath = URI.file(path.resolve(os.tmpdir(), 'theia_upload', itemId));
+        return this.fileSystem.fileSystem.readFile(filePath);
+    }
+}

package/src/plugin/languages.ts

@@ -69,7 +69,9 @@ import {
     InlineValue,
     InlineValueContext,
     TypeHierarchyItem,
-    InlineCompletionContext
+    InlineCompletionContext,
+    DocumentDropEdit,
+    DataTransferDTO
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
@@ -109,6 +111,9 @@ import { LinkedEditingRangeAdapter } from './languages/linked-editing-range';
 import { serializeEnterRules, serializeIndentation, serializeRegExp } from './languages-utils';
 import { InlayHintsAdapter } from './languages/inlay-hints';
 import { InlineCompletionAdapter, InlineCompletionAdapterBase } from './languages/inline-completion';
+import { DocumentDropEditAdapter } from './languages/document-drop-edit';
+import { IDisposable } from '@theia/monaco-editor-core';
+import { FileSystemExtImpl, FsLinkProvider } from './file-system-ext-impl';
 
 type Adapter = CompletionAdapter |
     SignatureHelpAdapter |
@@ -139,7 +144,8 @@ type Adapter = CompletionAdapter |
     DocumentSemanticTokensAdapter |
     LinkedEditingRangeAdapter |
     TypeHierarchyAdapter |
-    InlineCompletionAdapter;
+    InlineCompletionAdapter |
+    DocumentDropEditAdapter;
 
 export class LanguagesExtImpl implements LanguagesExt {
 
@@ -147,15 +153,25 @@ export class LanguagesExtImpl implements LanguagesExt {
 
     private readonly diagnostics: Diagnostics;
 
+    private linkProviderRegistration?: IDisposable;
+
     private callId = 0;
     private adaptersMap = new Map<number, Adapter>();
 
     constructor(
         rpc: RPCProtocol,
         private readonly documents: DocumentsExtImpl,
-        private readonly commands: CommandRegistryImpl) {
+        private readonly commands: CommandRegistryImpl,
+        private readonly filesSystem: FileSystemExtImpl) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.LANGUAGES_MAIN);
         this.diagnostics = new Diagnostics(rpc);
+        filesSystem.onWillRegisterFileSystemProvider(linkProvider => this.registerLinkProviderIfNotYetRegistered(linkProvider));
+    }
+
+    dispose(): void {
+        if (this.linkProviderRegistration) {
+            this.linkProviderRegistration.dispose();
+        }
     }
 
     get onDidChangeDiagnostics(): Event<theia.DiagnosticChangeEvent> {
@@ -258,6 +274,15 @@ export class LanguagesExtImpl implements LanguagesExt {
         return undefined;
     }
 
+    private registerLinkProviderIfNotYetRegistered(linkProvider: FsLinkProvider): void {
+        if (!this.linkProviderRegistration) {
+            this.linkProviderRegistration = this.registerDocumentLinkProvider('*', linkProvider, {
+                id: 'theia.fs-ext-impl',
+                name: 'fs-ext-impl'
+            });
+        }
+    }
+
     // ### Completion begin
     $provideCompletionItems(handle: number, resource: UriComponents, position: Position,
         context: CompletionContext, token: theia.CancellationToken): Promise<CompletionResultDto | undefined> {
@@ -463,6 +488,19 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Document Formatting Edit end
 
+    // ### Drop Edit Provider start
+    $provideDocumentDropEdits(handle: number, resource: UriComponents, position: Position,
+        dataTransfer: DataTransferDTO, token: theia.CancellationToken): Promise<DocumentDropEdit | undefined> {
+        return this.withAdapter(handle, DocumentDropEditAdapter, adapter => adapter.provideDocumentDropEdits(URI.revive(resource), position, dataTransfer, token), undefined);
+    }
+
+    registerDocumentDropEditProvider(selector: theia.DocumentSelector, provider: theia.DocumentDropEditProvider): theia.Disposable {
+        const callId = this.addNewAdapter(new DocumentDropEditAdapter(provider, this.documents, this.filesSystem));
+        this.proxy.$registerDocumentDropEditProvider(callId, this.transformDocumentSelector(selector));
+        return this.createDisposable(callId);
+    }
+    // ### Drop Edit Provider end
+
     // ### Document Range Formatting Edit begin
     registerDocumentRangeFormattingEditProvider(selector: theia.DocumentSelector, provider: theia.DocumentRangeFormattingEditProvider,
         pluginInfo: PluginInfo): theia.Disposable {

package/src/plugin/plugin-context.ts

@@ -87,6 +87,7 @@ import {
     DocumentHighlightKind,
     DocumentHighlight,
     DocumentLink,
+    DocumentDropEdit,
     CodeLens,
     CodeActionKind,
     CodeActionTrigger,
@@ -257,11 +258,11 @@ export function createAPIFactory(
     const statusBarMessageRegistryExt = new StatusBarMessageRegistryExt(rpc);
     const terminalExt = rpc.set(MAIN_RPC_CONTEXT.TERMINAL_EXT, new TerminalServiceExtImpl(rpc));
     const outputChannelRegistryExt = rpc.set(MAIN_RPC_CONTEXT.OUTPUT_CHANNEL_REGISTRY_EXT, new OutputChannelRegistryExtImpl(rpc));
-    const languagesExt = rpc.set(MAIN_RPC_CONTEXT.LANGUAGES_EXT, new LanguagesExtImpl(rpc, documents, commandRegistry));
     const treeViewsExt = rpc.set(MAIN_RPC_CONTEXT.TREE_VIEWS_EXT, new TreeViewsExtImpl(rpc, commandRegistry));
     const tasksExt = rpc.set(MAIN_RPC_CONTEXT.TASKS_EXT, new TasksExtImpl(rpc, terminalExt));
     const connectionExt = rpc.set(MAIN_RPC_CONTEXT.CONNECTION_EXT, new ConnectionImpl(rpc.getProxy(PLUGIN_RPC_CONTEXT.CONNECTION_MAIN)));
-    const fileSystemExt = rpc.set(MAIN_RPC_CONTEXT.FILE_SYSTEM_EXT, new FileSystemExtImpl(rpc, languagesExt));
+    const fileSystemExt = rpc.set(MAIN_RPC_CONTEXT.FILE_SYSTEM_EXT, new FileSystemExtImpl(rpc));
+    const languagesExt = rpc.set(MAIN_RPC_CONTEXT.LANGUAGES_EXT, new LanguagesExtImpl(rpc, documents, commandRegistry, fileSystemExt));
     const extHostFileSystemEvent = rpc.set(MAIN_RPC_CONTEXT.ExtHostFileSystemEventService, new ExtHostFileSystemEventService(rpc, editorsAndDocumentsExt));
     const scmExt = rpc.set(MAIN_RPC_CONTEXT.SCM_EXT, new ScmExtImpl(rpc, commandRegistry));
     const decorationsExt = rpc.set(MAIN_RPC_CONTEXT.DECORATIONS_EXT, new DecorationsExtImpl(rpc));
@@ -669,8 +670,8 @@ export function createAPIFactory(
             saveAll(includeUntitled?: boolean): PromiseLike<boolean> {
                 return editors.saveAll(includeUntitled);
             },
-            applyEdit(edit: theia.WorkspaceEdit): PromiseLike<boolean> {
-                return editors.applyWorkspaceEdit(edit);
+            applyEdit(edit: theia.WorkspaceEdit, metadata?: theia.WorkspaceEditMetadata): PromiseLike<boolean> {
+                return editors.applyWorkspaceEdit(edit, metadata);
             },
             registerTextDocumentContentProvider(scheme: string, provider: theia.TextDocumentContentProvider): theia.Disposable {
                 return workspaceExt.registerTextDocumentContentProvider(scheme, provider);
@@ -853,6 +854,9 @@ export function createAPIFactory(
             ): theia.Disposable {
                 return languagesExt.registerOnTypeFormattingEditProvider(selector, provider, [firstTriggerCharacter].concat(moreTriggerCharacters), pluginToPluginInfo(plugin));
             },
+            registerDocumentDropEditProvider(selector: theia.DocumentSelector, provider: theia.DocumentDropEditProvider) {
+                return languagesExt.registerDocumentDropEditProvider(selector, provider);
+            },
             registerDocumentLinkProvider(selector: theia.DocumentSelector, provider: theia.DocumentLinkProvider): theia.Disposable {
                 return languagesExt.registerDocumentLinkProvider(selector, provider, pluginToPluginInfo(plugin));
             },
@@ -1195,6 +1199,7 @@ export function createAPIFactory(
             DocumentHighlightKind,
             DocumentHighlight,
             DocumentLink,
+            DocumentDropEdit,
             CodeLens,
             CodeActionKind,
             CodeActionTrigger,

package/src/plugin/preference-registry.spec.ts

@@ -41,36 +41,6 @@ describe('PreferenceRegistryExtImpl:', () => {
         preferenceRegistryExtImpl = new PreferenceRegistryExtImpl(mockRPC, mockWorkspace);
     });
 
-    it('should parse configuration data without overrides', () => {
-        const value: Record<string, any> = {
-            'my.key1.foo': 'value1',
-            'my.key1.bar': 'value2',
-        };
-        const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
-        expect(result.contents.my).to.be.an('object');
-        expect(result.contents.my.key1).to.be.an('object');
-
-        expect(result.contents.my.key1.foo).to.be.an('string');
-        expect(result.contents.my.key1.foo).to.equal('value1');
-
-        expect(result.contents.my.key1.bar).to.be.an('string');
-        expect(result.contents.my.key1.bar).to.equal('value2');
-        expect(result.keys).deep.equal(['my.key1.foo', 'my.key1.bar']);
-    });
-
-    it('should parse configuration with overrides', () => {
-        const value: Record<string, any> = {
-            'editor.tabSize': 2,
-            '[typescript].editor.tabSize': 4,
-        };
-        const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
-        expect(result.contents.editor.tabSize).to.equal(2);
-        const tsOverride = result.overrides[0];
-        expect(tsOverride.contents.editor.tabSize).to.equal(4);
-        expect(tsOverride.identifiers).deep.equal(['typescript']);
-        expect(tsOverride.keys).deep.equal(['editor.tabSize']);
-    });
-
     describe('Prototype pollution', () => {
         it('Ignores key `__proto__`', () => {
             const value: Record<string, any> = {
@@ -80,16 +50,18 @@ describe('PreferenceRegistryExtImpl:', () => {
                 '__proto__': {},
                 '[typescript].someKey.foo': 'value',
                 '[typescript].__proto__.injectedParsedPrototype': true,
+                'b': { '__proto__.injectedParsedPrototype': true },
+                'c': { '__proto__': { 'injectedParsedPrototype': true } }
             };
-            const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
-            expect(result.contents.my).to.be.an('object');
-            expect(result.contents.__proto__).to.be.an('undefined');
-            expect(result.contents.my.key1.foo).to.equal('value1');
-            expect(result.overrides[0].contents.__proto__).to.be.an('undefined');
+            const configuration = preferenceRegistryExtImpl['getConfigurationModel']('test', value);
+            const result = configuration['_contents'];
+            expect(result.my, 'Safe keys are preserved.').to.be.an('object');
+            expect(result.__proto__, 'Keys containing __proto__ are ignored').to.be.an('undefined');
+            expect(result.my.key1.foo, 'Safe keys are dendrified.').to.equal('value1');
             const prototypeObject = Object.prototype as any;
-            expect(prototypeObject.injectedParsedPrototype).to.be.an('undefined');
+            expect(prototypeObject.injectedParsedPrototype, 'Object.prototype is unaffected').to.be.an('undefined');
             const rawObject = {} as any;
-            expect(rawObject.injectedParsedPrototype).to.be.an('undefined');
+            expect(rawObject.injectedParsedPrototype, 'Instantiated objects are unaffected.').to.be.an('undefined');
         });
 
         it('Ignores key `constructor.prototype`', () => {
@@ -98,17 +70,19 @@ describe('PreferenceRegistryExtImpl:', () => {
                 'a.constructor.prototype.injectedParsedConstructorPrototype': true,
                 'constructor.prototype.injectedParsedConstructorPrototype': true,
                 '[python].some.key.foo': 'value',
-                '[python].a.constructor.prototype.injectedParsedConstructorPrototype': true
+                '[python].a.constructor.prototype.injectedParsedConstructorPrototype': true,
+                'constructor': { 'prototype.injectedParsedConstructorPrototype': true },
+                'b': { 'constructor': { 'prototype': { 'injectedParsedConstructorPrototype': true } } }
             };
-            const result = preferenceRegistryExtImpl['parseConfigurationData'](value);
-            expect(result.contents.my).to.be.an('object');
-            expect(result.contents.__proto__).to.be.an('undefined');
-            expect(result.contents.my.key1.foo).to.equal('value1');
+            const configuration = preferenceRegistryExtImpl['getConfigurationModel']('test', value);
+            const result = configuration['_contents'];
+            expect(result.my, 'Safe keys are preserved').to.be.an('object');
+            expect(result.__proto__, 'Keys containing __proto__ are ignored').to.be.an('undefined');
+            expect(result.my.key1.foo, 'Safe keys are dendrified.').to.equal('value1');
             const prototypeObject = Object.prototype as any;
-            expect(prototypeObject.injectedParsedConstructorPrototype).to.be.an('undefined');
-            expect(result.overrides[0].contents.__proto__).to.be.an('undefined');
+            expect(prototypeObject.injectedParsedConstructorPrototype, 'Object.prototype is unaffected').to.be.an('undefined');
             const rawObject = {} as any;
-            expect(rawObject.injectedParsedConstructorPrototype).to.be.an('undefined');
+            expect(rawObject.injectedParsedConstructorPrototype, 'Instantiated objects are unaffected.').to.be.an('undefined');
         });
     });
 
@@ -250,6 +224,16 @@ describe('PreferenceRegistryExtImpl:', () => {
             const valuesRetrieved = preferenceRegistryExtImpl.getConfiguration(undefined, { uri: workspaceRoot, languageId: 'python' }).get('editor') as Record<string, unknown>;
             expect(valuesRetrieved.tabSize).equal(4);
         });
+        it('Allows access to language overrides in bracket form', () => {
+            const pythonOverrides = preferenceRegistryExtImpl.getConfiguration().get<Record<string, any>>('[python]');
+            expect(pythonOverrides).not.to.be.undefined;
+            expect(pythonOverrides?.['editor.renderWhitespace']).equal('all');
+        });
+        // https://github.com/eclipse-theia/theia/issues/12043
+        it('Allows access to preferences without specifying the section', () => {
+            const inspection = preferenceRegistryExtImpl.getConfiguration().inspect('editor.fontSize');
+            expect(inspection?.defaultValue).equal(14);
+        });
     });
 
     describe('Proxy Behavior', () => {

package/src/plugin/preference-registry.ts

@@ -20,8 +20,8 @@ import { Emitter, Event } from '@theia/core/lib/common/event';
 import { isOSX, isWindows } from '@theia/core/lib/common/os';
 import { URI } from '@theia/core/shared/vscode-uri';
 import { ResourceMap } from '@theia/monaco-editor-core/esm/vs/base/common/map';
-import { IConfigurationOverrides, IOverrides } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configuration';
-import { Configuration, ConfigurationModel } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configurationModels';
+import { IConfigurationOverrides } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configuration';
+import { Configuration, ConfigurationModel, ConfigurationModelParser } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configurationModels';
 import { Workspace, WorkspaceFolder } from '@theia/monaco-editor-core/esm/vs/platform/workspace/common/workspace';
 import * as theia from '@theia/plugin';
 import { v4 } from 'uuid';
@@ -234,12 +234,12 @@ export class PreferenceRegistryExtImpl implements PreferenceRegistryExt {
     }
 
     private parse(data: PreferenceData): Configuration {
-        const defaultConfiguration = this.getConfigurationModel(data[PreferenceScope.Default]);
-        const userConfiguration = this.getConfigurationModel(data[PreferenceScope.User]);
-        const workspaceConfiguration = this.getConfigurationModel(data[PreferenceScope.Workspace]);
+        const defaultConfiguration = this.getConfigurationModel('Default', data[PreferenceScope.Default]);
+        const userConfiguration = this.getConfigurationModel('User', data[PreferenceScope.User]);
+        const workspaceConfiguration = this.getConfigurationModel('Workspace', data[PreferenceScope.Workspace]);
         const folderConfigurations = new ResourceMap<ConfigurationModel>();
         Object.keys(data[PreferenceScope.Folder]).forEach(resource => {
-            folderConfigurations.set(URI.parse(resource), this.getConfigurationModel(data[PreferenceScope.Folder][resource]));
+            folderConfigurations.set(URI.parse(resource), this.getConfigurationModel(`Folder: ${resource}`, data[PreferenceScope.Folder][resource]));
         });
         return new Configuration(
             defaultConfiguration,
@@ -252,53 +252,41 @@ export class PreferenceRegistryExtImpl implements PreferenceRegistryExt {
         );
     }
 
-    private getConfigurationModel(data: { [key: string]: any }): ConfigurationModel {
-        if (!data) {
-            return new ConfigurationModel();
-        }
-        const configData = this.parseConfigurationData(data);
-        return new ConfigurationModel(configData.contents, configData.keys, configData.overrides);
+    private getConfigurationModel(label: string, data: { [key: string]: any }): ConfigurationModel {
+        const parser = new ConfigurationModelParser(label);
+        const sanitized = this.sanitize(data);
+        parser.parseRaw(sanitized);
+        return parser.configurationModel;
     }
 
-    private readonly OVERRIDE_PROPERTY = '^\\[(.*)\\]$';
-    private readonly OVERRIDE_PROPERTY_PATTERN = new RegExp(this.OVERRIDE_PROPERTY);
-    private readonly OVERRIDE_KEY_TEST = /^\[([^\]]+)\]\./;
-
-    private parseConfigurationData(data: { [key: string]: any }): Omit<IOverrides, 'identifiers'> & { overrides: IOverrides[] } {
-        const keys = new Array<string>();
-        const overrides: Record<string, IOverrides> = Object.create(null);
-        const contents = Object.keys(data).reduce((result: any, key: string) => {
-            if (injectionRe.test(key)) {
-                return result;
-            }
-            const parts = key.split('.');
-            let branch = result;
-            const isOverride = this.OVERRIDE_KEY_TEST.test(key);
-            if (!isOverride) {
-                keys.push(key);
-            }
-            for (let i = 0; i < parts.length; i++) {
-                if (i === 0 && isOverride) {
-                    const identifier = this.OVERRIDE_PROPERTY_PATTERN.exec(parts[i])![1];
-                    if (!overrides[identifier]) {
-                        overrides[identifier] = { keys: [], identifiers: [identifier], contents: Object.create(null) };
+    /**
+     * Creates a new object and assigns those keys of raw to it that are not likely to cause prototype polution.
+     * Also preprocesses override identifiers so that they take the form [identifier]: {...contents}.
+     */
+    private sanitize<T = unknown>(raw: T): T {
+        if (!isObject(raw)) { return raw; }
+        const asObject = raw as Record<string, unknown>;
+        const sanitized = Object.create(null);
+        for (const key of Object.keys(asObject)) {
+            if (!injectionRe.test(key)) {
+                const override = this.OVERRIDE_KEY_TEST.exec(key);
+                if (override) {
+                    const overrideKey = `[${override[1]}]`;
+                    const remainder = key.slice(override[0].length);
+                    if (!isObject(sanitized[overrideKey])) {
+                        sanitized[overrideKey] = Object.create(null);
                     }
-                    branch = overrides[identifier].contents;
-                    overrides[identifier].keys.push(key.slice(parts[i].length + 1));
-                } else if (i === parts.length - 1) {
-                    branch[parts[i]] = data[key];
+                    sanitized[overrideKey][remainder] = this.sanitize(asObject[key]);
                 } else {
-                    if (!branch[parts[i]]) {
-                        branch[parts[i]] = Object.create(null);
-                    }
-                    branch = branch[parts[i]];
+                    sanitized[key] = this.sanitize(asObject[key]);
                 }
             }
-            return result;
-        }, Object.create(null));
-        return { contents, keys, overrides: Object.values(overrides) };
+        }
+        return sanitized;
     }
 
+    private readonly OVERRIDE_KEY_TEST = /^\[([^\]]+)\]\./;
+
     private toConfigurationChangeEvent(eventData: PreferenceChangeExt[]): theia.ConfigurationChangeEvent {
         return Object.freeze({
             affectsConfiguration: (section: string, scope?: theia.ConfigurationScope): boolean => {

package/src/plugin/text-editors.ts

@@ -119,9 +119,9 @@ export class TextEditorsExtImpl implements TextEditorsExt {
         return new TextEditorDecorationType(this.proxy, options);
     }
 
-    applyWorkspaceEdit(edit: theia.WorkspaceEdit): Promise<boolean> {
+    applyWorkspaceEdit(edit: theia.WorkspaceEdit, metadata?: theia.WorkspaceEditMetadata): Promise<boolean> {
         const dto = Converters.fromWorkspaceEdit(edit, this.editorsAndDocuments);
-        return this.proxy.$tryApplyWorkspaceEdit(dto);
+        return this.proxy.$tryApplyWorkspaceEdit(dto, metadata);
     }
 
     saveAll(includeUntitled?: boolean): PromiseLike<boolean> {

package/src/plugin/type-converters.ts

@@ -1348,3 +1348,40 @@ export namespace InlayHintKind {
         return kind;
     }
 }
+
+export namespace DataTransferItem {
+    export function to(mime: string, item: model.DataTransferItemDTO, resolveFileData: (itemId: string) => Promise<Uint8Array>): theia.DataTransferItem {
+        const file = item.fileData;
+        if (file) {
+            return new class extends types.DataTransferItem {
+                override asFile(): theia.DataTransferFile {
+                    return {
+                        name: file.name,
+                        uri: URI.revive(file.uri),
+                        data: () => resolveFileData(item.id),
+                    };
+                }
+            }('');
+        }
+
+        if (mime === 'text/uri-list' && item.uriListData) {
+            return new types.DataTransferItem(reviveUriList(item.uriListData));
+        }
+
+        return new types.DataTransferItem(item.asString);
+    }
+
+    function reviveUriList(parts: ReadonlyArray<string | UriComponents>): string {
+        return parts.map(part => typeof part === 'string' ? part : URI.revive(part).toString()).join('\r\n');
+    }
+}
+
+export namespace DataTransfer {
+    export function toDataTransfer(value: model.DataTransferDTO, resolveFileData: (itemId: string) => Promise<Uint8Array>): theia.DataTransfer {
+        const dataTransfer = new types.DataTransfer();
+        for (const [mimeType, item] of value.items) {
+            dataTransfer.set(mimeType, DataTransferItem.to(mimeType, item, resolveFileData));
+        }
+        return dataTransfer;
+    }
+}

package/src/plugin/types-impl.ts

@@ -1530,6 +1530,17 @@ export class DocumentLink {
     }
 }
 
+@es5ClassCompat
+export class DocumentDropEdit {
+    insertText: string | SnippetString;
+
+    additionalEdit?: WorkspaceEdit;
+
+    constructor(insertText: string | SnippetString) {
+        this.insertText = insertText;
+    }
+}
+
 @es5ClassCompat
 export class CodeLens {