@theia/plugin-ext 1.34.0 → 1.35.0

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/tabs.ts

@@ -291,14 +291,6 @@ export class TabsExtImpl implements TabsExt {
                         return this._closeTabs(tabsOrTabGroups as theia.Tab[], preserveFocus);
                     }
                 },
-                // move: async (tab: theia.Tab, viewColumn: ViewColumn, index: number, preserveFocus?: boolean) => {
-                //  const extHostTab = this._findExtHostTabFromApi(tab);
-                //  if (!extHostTab) {
-                //      throw new Error('Invalid tab');
-                //  }
-                //  this._proxy.$moveTab(extHostTab.tabId, index, typeConverters.ViewColumn.from(viewColumn), preserveFocus);
-                //  return;
-                // }
             };
             this.apiObject = Object.freeze(obj);
         }
@@ -306,7 +298,6 @@ export class TabsExtImpl implements TabsExt {
     }
 
     $acceptEditorTabModel(tabGroups: TabGroupDto[]): void {
-
         const groupIdsBefore = new Set(this.tabGroupArr.map(group => group.groupId));
         const groupIdsAfter = new Set(tabGroups.map(dto => dto.groupId));
         const diff = diffSets(groupIdsBefore, groupIdsAfter);
@@ -314,23 +305,28 @@ export class TabsExtImpl implements TabsExt {
         const closed: theia.TabGroup[] = this.tabGroupArr.filter(group => diff.removed.includes(group.groupId)).map(group => group.apiObject);
         const opened: theia.TabGroup[] = [];
         const changed: theia.TabGroup[] = [];
+        const tabsOpened: theia.Tab[] = [];
 
         this.tabGroupArr = tabGroups.map(tabGroup => {
             const group = new TabGroupExt(tabGroup, () => this.activeGroupId);
             if (diff.added.includes(group.groupId)) {
-                opened.push(group.apiObject);
+                opened.push({ activeTab: undefined, isActive: group.apiObject.isActive, tabs: [], viewColumn: group.apiObject.viewColumn });
+                tabsOpened.push(...group.apiObject.tabs);
             } else {
                 changed.push(group.apiObject);
             }
             return group;
         });
 
-        // Set the active tab group id
-        const activeTabGroupId = assertIsDefined(tabGroups.find(group => group.isActive === true)?.groupId);
-        if (activeTabGroupId !== undefined && this.activeGroupId !== activeTabGroupId) {
-            this.activeGroupId = activeTabGroupId;
+        // Set the active tab group id. skip if no tabgroups are open
+        if (tabGroups.length > 0) {
+            const activeTabGroupId = assertIsDefined(tabGroups.find(group => group.isActive === true)?.groupId);
+            if (this.activeGroupId !== activeTabGroupId) {
+                this.activeGroupId = activeTabGroupId;
+            }
         }
         this.onDidChangeTabGroups.fire(Object.freeze({ opened, closed, changed }));
+        this.onDidChangeTabs.fire({ opened: tabsOpened, changed: [], closed: [] });
     }
 
     $acceptTabGroupUpdate(groupDto: TabGroupDto): void {

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 {