@theia/plugin-ext 1.34.2 → 1.36.0-next.21

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);
@@ -752,7 +753,8 @@ export function createAPIFactory(
 
         const extensions: typeof theia.extensions = Object.freeze({
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            getExtension<T = any>(extensionId: string): theia.Extension<T> | undefined {
+            getExtension<T = any>(extensionId: string, includeFromDifferentExtensionHosts: boolean = false): theia.Extension<T> | undefined {
+                includeFromDifferentExtensionHosts = false;
                 const plg = pluginManager.getPluginById(extensionId.toLowerCase());
                 if (plg) {
                     return new PluginExt(pluginManager, plg);
@@ -763,6 +765,10 @@ export function createAPIFactory(
             get all(): readonly theia.Extension<any>[] {
                 return pluginManager.getAllPlugins().map(plg => new PluginExt(pluginManager, plg));
             },
+            get allAcrossExtensionHosts(): readonly theia.Extension<any>[] {
+                // we only support one extension host ATM so equivalent to calling "all()"
+                return this.all;
+            },
             get onDidChange(): theia.Event<void> {
                 return pluginManager.onDidChange;
             }
@@ -853,6 +859,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 +1204,7 @@ export function createAPIFactory(
             DocumentHighlightKind,
             DocumentHighlight,
             DocumentLink,
+            DocumentDropEdit,
             CodeLens,
             CodeActionKind,
             CodeActionTrigger,
@@ -1364,13 +1374,15 @@ export class PluginExt<T> extends Plugin<T> implements ExtensionPlugin<T> {
     extensionPath: string;
     extensionUri: theia.Uri;
     extensionKind: ExtensionKind;
+    isFromDifferentExtensionHost: boolean;
 
-    constructor(protected override readonly pluginManager: PluginManager, plugin: InternalPlugin) {
+    constructor(protected override readonly pluginManager: PluginManager, plugin: InternalPlugin, isFromDifferentExtensionHost = false) {
         super(pluginManager, plugin);
 
         this.extensionPath = this.pluginPath;
         this.extensionUri = this.pluginUri;
         this.extensionKind = ExtensionKind.UI; // stub as a local extension (not running on a remote workspace)
+        this.isFromDifferentExtensionHost = isFromDifferentExtensionHost;
     }
 
     override get isActive(): boolean {

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

@@ -404,10 +404,13 @@ export class Position {
         return result!;
     }
 
-    static isPosition(other: {}): other is Position {
+    static isPosition(other: unknown): other is Position {
         if (!other) {
             return false;
         }
+        if (typeof other !== 'object' || Array.isArray(other)) {
+            return false;
+        }
         if (other instanceof Position) {
             return true;
         }
@@ -1530,6 +1533,17 @@ export class DocumentLink {
     }
 }
 
+@es5ClassCompat
+export class DocumentDropEdit {
+    insertText: string | SnippetString;
+
+    additionalEdit?: WorkspaceEdit;
+
+    constructor(insertText: string | SnippetString) {
+        this.insertText = insertText;
+    }
+}
+
 @es5ClassCompat
 export class CodeLens {
 

package/src/plugin/webview-views.ts

@@ -167,8 +167,8 @@ export class WebviewViewExtImpl implements theia.WebviewView {
 
     set title(value: string | undefined) {
         this.assertNotDisposed();
-        if (this.title !== value) {
-            this.title = value;
+        if (this._title !== value) {
+            this._title = value;
             this.proxy.$setWebviewViewTitle(this.handle, value);
         }
     }