@theia/plugin-ext 1.34.0 → 1.35.0

package/src/main/browser/tabs/tabs-main.ts

@@ -15,16 +15,275 @@
 // *****************************************************************************
 
 import { interfaces } from '@theia/core/shared/inversify';
-
-import { TabsMain } from '../../../common/plugin-api-rpc';
+import { ApplicationShell, PINNED_CLASS, Saveable, TabBar, Title, ViewContainer, Widget } from '@theia/core/lib/browser';
+import { AnyInputDto, MAIN_RPC_CONTEXT, TabDto, TabGroupDto, TabInputKind, TabModelOperationKind, TabsExt, TabsMain } from '../../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../../common/rpc-protocol';
+import { EditorPreviewWidget } from '@theia/editor-preview/lib/browser/editor-preview-widget';
+import { Disposable } from '@theia/core/shared/vscode-languageserver-protocol';
+import { MonacoDiffEditor } from '@theia/monaco/lib/browser/monaco-diff-editor';
+import { toUriComponents } from '../hierarchy/hierarchy-types-converters';
+import { TerminalWidget } from '@theia/terminal/lib/browser/base/terminal-widget';
+import { DisposableCollection } from '@theia/core';
+
+interface TabInfo {
+    tab: TabDto;
+    tabIndex: number;
+    group: TabGroupDto;
+}
+
+export class TabsMainImpl implements TabsMain, Disposable {
+
+    private readonly proxy: TabsExt;
+    private tabGroupModel = new Map<TabBar<Widget>, TabGroupDto>();
+    private tabInfoLookup = new Map<Title<Widget>, TabInfo>();
+
+    private applicationShell: ApplicationShell;
+
+    private disposableTabBarListeners: DisposableCollection = new DisposableCollection();
+    private toDisposeOnDestroy: DisposableCollection = new DisposableCollection();
 
-export class TabsMainImp implements TabsMain {
+    private groupIdCounter = 0;
+    private currentActiveGroup: TabGroupDto;
+
+    private tabGroupChanged: boolean = false;
 
     constructor(
         rpc: RPCProtocol,
         container: interfaces.Container
-    ) {}
+    ) {
+        this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.TABS_EXT);
+
+        this.applicationShell = container.get(ApplicationShell);
+        this.createTabsModel();
+
+        const tabBars = this.applicationShell.mainPanel.tabBars();
+        for (let tabBar; tabBar = tabBars.next();) {
+            this.attachListenersToTabBar(tabBar);
+        }
+
+        this.toDisposeOnDestroy.push(
+            this.applicationShell.mainPanelRenderer.onDidCreateTabBar(tabBar => {
+                this.attachListenersToTabBar(tabBar);
+                this.onTabGroupCreated(tabBar);
+            })
+        );
+
+        this.connectToSignal(this.toDisposeOnDestroy, this.applicationShell.mainPanel.widgetAdded, (mainPanel, widget) => {
+            if (this.tabGroupChanged || this.tabGroupModel.size === 0) {
+                this.tabGroupChanged = false;
+                this.createTabsModel();
+                // tab Open event is done in backend
+            } else {
+                const tabBar = mainPanel.findTabBar(widget.title)!;
+                const oldTabInfo = this.tabInfoLookup.get(widget.title);
+                const group = this.tabGroupModel.get(tabBar);
+                if (group !== oldTabInfo?.group) {
+                    if (oldTabInfo) {
+                        this.onTabClosed(oldTabInfo, widget.title);
+                    }
+
+                    this.onTabCreated(tabBar, { index: tabBar.titles.indexOf(widget.title), title: widget.title });
+                }
+            }
+        });
+
+        this.connectToSignal(this.toDisposeOnDestroy, this.applicationShell.mainPanel.widgetRemoved, (mainPanel, widget) => {
+            if (!(widget instanceof TabBar)) {
+                const tabInfo = this.getOrRebuildModel(this.tabInfoLookup, widget.title)!;
+                this.onTabClosed(tabInfo, widget.title);
+                if (this.tabGroupChanged) {
+                    this.tabGroupChanged = false;
+                    this.createTabsModel();
+                }
+            }
+        });
+    }
+
+    protected createTabsModel(): void {
+        const newTabGroupModel = new Map<TabBar<Widget>, TabGroupDto>();
+        this.tabInfoLookup.clear();
+        this.disposableTabBarListeners.dispose();
+        this.applicationShell.mainAreaTabBars.forEach(tabBar => {
+            this.attachListenersToTabBar(tabBar);
+            const groupDto = this.createTabGroupDto(tabBar);
+            tabBar.titles.forEach((title, index) => this.tabInfoLookup.set(title, { group: groupDto, tab: groupDto.tabs[index], tabIndex: index }));
+            newTabGroupModel.set(tabBar, groupDto);
+        });
+        if (newTabGroupModel.size > 0 && Array.from(newTabGroupModel.values()).indexOf(this.currentActiveGroup) < 0) {
+            this.currentActiveGroup = this.tabInfoLookup.get(this.applicationShell.mainPanel.currentTitle!)?.group ?? newTabGroupModel.values().next().value;
+            this.currentActiveGroup.isActive = true;
+        }
+        this.tabGroupModel = newTabGroupModel;
+        this.proxy.$acceptEditorTabModel(Array.from(this.tabGroupModel.values()));
+    }
+
+    protected createTabDto(tabTitle: Title<Widget>, groupId: number): TabDto {
+        const widget = tabTitle.owner;
+        return {
+            id: this.createTabId(tabTitle, groupId),
+            label: tabTitle.label,
+            input: this.evaluateTabDtoInput(widget),
+            isActive: tabTitle.owner.isVisible,
+            isPinned: tabTitle.className.includes(PINNED_CLASS),
+            isDirty: Saveable.isDirty(widget),
+            isPreview: widget instanceof EditorPreviewWidget && widget.isPreview
+        };
+    }
+
+    protected createTabId(tabTitle: Title<Widget>, groupId: number): string {
+        return `${groupId}~${tabTitle.owner.id}`;
+    }
+
+    protected createTabGroupDto(tabBar: TabBar<Widget>): TabGroupDto {
+        const oldDto = this.tabGroupModel.get(tabBar);
+        const groupId = oldDto?.groupId ?? this.groupIdCounter++;
+        const tabs = tabBar.titles.map(title => this.createTabDto(title, groupId));
+        return {
+            groupId,
+            tabs,
+            isActive: false,
+            viewColumn: 1
+        };
+    }
+
+    protected attachListenersToTabBar(tabBar: TabBar<Widget> | undefined): void {
+        if (!tabBar) {
+            return;
+        }
+        tabBar.titles.forEach(title => {
+            this.connectToSignal(this.disposableTabBarListeners, title.changed, this.onTabTitleChanged);
+        });
+
+        this.connectToSignal(this.disposableTabBarListeners, tabBar.tabMoved, this.onTabMoved);
+        this.connectToSignal(this.disposableTabBarListeners, tabBar.disposed, this.onTabGroupClosed);
+    }
+
+    protected evaluateTabDtoInput(widget: Widget): AnyInputDto {
+        if (widget instanceof EditorPreviewWidget) {
+            if (widget.editor instanceof MonacoDiffEditor) {
+                return {
+                    kind: TabInputKind.TextDiffInput,
+                    original: toUriComponents(widget.editor.originalModel.uri),
+                    modified: toUriComponents(widget.editor.modifiedModel.uri)
+                };
+            } else {
+                return {
+                    kind: TabInputKind.TextInput,
+                    uri: toUriComponents(widget.editor.uri.toString())
+                };
+            }
+            // TODO notebook support when implemented
+        } else if (widget instanceof ViewContainer) {
+            return {
+                kind: TabInputKind.WebviewEditorInput,
+                viewType: widget.id
+            };
+        } else if (widget instanceof TerminalWidget) {
+            return {
+                kind: TabInputKind.TerminalEditorInput
+            };
+        }
+
+        return { kind: TabInputKind.UnknownInput };
+    }
+
+    protected connectToSignal<T>(disposableList: DisposableCollection, signal: { connect(listener: T, context: unknown): void, disconnect(listener: T): void }, listener: T): void {
+        signal.connect(listener, this);
+        disposableList.push(Disposable.create(() => signal.disconnect(listener)));
+    }
+
+    protected tabDtosEqual(a: TabDto, b: TabDto): boolean {
+        return a.isActive === b.isActive &&
+            a.isDirty === b.isDirty &&
+            a.isPinned === b.isPinned &&
+            a.isPreview === b.isPreview &&
+            a.id === b.id;
+    }
+
+    protected getOrRebuildModel<T, R>(map: Map<T, R>, key: T): R {
+        // something broke so we rebuild the model
+        let item = map.get(key);
+        if (!item) {
+            this.createTabsModel();
+            item = map.get(key)!;
+        }
+        return item;
+    }
+
+    // #region event listeners
+    private onTabCreated(tabBar: TabBar<Widget>, args: TabBar.ITabActivateRequestedArgs<Widget>): void {
+        const group = this.getOrRebuildModel(this.tabGroupModel, tabBar);
+        this.connectToSignal(this.disposableTabBarListeners, args.title.changed, this.onTabTitleChanged);
+        const tabDto = this.createTabDto(args.title, group.groupId);
+        this.tabInfoLookup.set(args.title, { group, tab: tabDto, tabIndex: args.index });
+        group.tabs.splice(args.index, 0, tabDto);
+        this.proxy.$acceptTabOperation({
+            kind: TabModelOperationKind.TAB_OPEN,
+            index: args.index,
+            tabDto,
+            groupId: group.groupId
+        });
+    }
+
+    private onTabTitleChanged(title: Title<Widget>): void {
+        const tabInfo = this.getOrRebuildModel(this.tabInfoLookup, title);
+        if (!tabInfo) {
+            return;
+        }
+        const oldTabDto = tabInfo.tab;
+        const newTabDto = this.createTabDto(title, tabInfo.group.groupId);
+        if (newTabDto.isActive && !tabInfo.group.isActive) {
+            tabInfo.group.isActive = true;
+            this.currentActiveGroup.isActive = false;
+            this.currentActiveGroup = tabInfo.group;
+            this.proxy.$acceptTabGroupUpdate(tabInfo.group);
+        }
+        if (!this.tabDtosEqual(oldTabDto, newTabDto)) {
+            tabInfo.group.tabs[tabInfo.tabIndex] = newTabDto;
+            tabInfo.tab = newTabDto;
+            this.proxy.$acceptTabOperation({
+                kind: TabModelOperationKind.TAB_UPDATE,
+                index: tabInfo.tabIndex,
+                tabDto: newTabDto,
+                groupId: tabInfo.group.groupId
+            });
+        }
+    }
+
+    private onTabClosed(tabInfo: TabInfo, title: Title<Widget>): void {
+        tabInfo.group.tabs.splice(tabInfo.tabIndex, 1);
+        this.tabInfoLookup.delete(title);
+        this.proxy.$acceptTabOperation({
+            kind: TabModelOperationKind.TAB_CLOSE,
+            index: tabInfo.tabIndex,
+            tabDto: this.createTabDto(title, tabInfo.group.groupId),
+            groupId: tabInfo.group.groupId
+        });
+    }
+
+    private onTabMoved(tabBar: TabBar<Widget>, args: TabBar.ITabMovedArgs<Widget>): void {
+        const tabInfo = this.getOrRebuildModel(this.tabInfoLookup, args.title)!;
+        tabInfo.tabIndex = args.toIndex;
+        const tabDto = this.createTabDto(args.title, tabInfo.group.groupId);
+        tabInfo.group.tabs.splice(args.fromIndex, 1);
+        tabInfo.group.tabs.splice(args.toIndex, 0, tabDto);
+        this.proxy.$acceptTabOperation({
+            kind: TabModelOperationKind.TAB_MOVE,
+            index: args.toIndex,
+            tabDto,
+            groupId: tabInfo.group.groupId,
+            oldIndex: args.fromIndex
+        });
+    }
+
+    private onTabGroupCreated(tabBar: TabBar<Widget>): void {
+        this.tabGroupChanged = true;
+    }
+
+    private onTabGroupClosed(tabBar: TabBar<Widget>): void {
+        this.tabGroupChanged = true;
+    }
+    // #endregion
 
     // #region Messages received from Ext Host
     $moveTab(tabId: string, index: number, viewColumn: number, preserveFocus?: boolean): void {
@@ -32,11 +291,33 @@ export class TabsMainImp implements TabsMain {
     }
 
     async $closeTab(tabIds: string[], preserveFocus?: boolean): Promise<boolean> {
-        return false;
+        const widgets: Widget[] = [];
+        for (const tabId of tabIds) {
+            const cleanedId = tabId.substring(tabId.indexOf('~') + 1);
+            const widget = this.applicationShell.getWidgetById(cleanedId);
+            if (widget) {
+                widgets.push(widget);
+            }
+        }
+        await this.applicationShell.closeMany(widgets);
+        return true;
     }
 
     async $closeGroup(groupIds: number[], preserveFocus?: boolean): Promise<boolean> {
-        return false;
+        for (const groupId of groupIds) {
+            tabGroupModel: for (const [bar, groupDto] of this.tabGroupModel) {
+                if (groupDto.groupId === groupId) {
+                    this.applicationShell.closeTabs(bar);
+                    break tabGroupModel;
+                }
+            }
+        }
+        return true;
     }
     // #endregion
+
+    dispose(): void {
+        this.toDisposeOnDestroy.dispose();
+        this.disposableTabBarListeners.dispose();
+    }
 }

package/src/main/browser/text-editors-main.ts

@@ -30,6 +30,7 @@ import {
     DecorationOptions,
     WorkspaceEditDto,
     DocumentsMain,
+    WorkspaceEditMetadataDto,
 } from '../../common/plugin-api-rpc';
 import { Range, TextDocumentShowOptions } from '../../common/plugin-api-rpc-model';
 import { EditorsAndDocumentsMain } from './editors-and-documents-main';
@@ -126,11 +127,11 @@ export class TextEditorsMainImpl implements TextEditorsMain, Disposable {
         return Promise.resolve(this.editorsAndDocuments.getEditor(id)!.applyEdits(modelVersionId, edits, opts));
     }
 
-    async $tryApplyWorkspaceEdit(dto: WorkspaceEditDto): Promise<boolean> {
+    async $tryApplyWorkspaceEdit(dto: WorkspaceEditDto, metadata?: WorkspaceEditMetadataDto): Promise<boolean> {
         const workspaceEdit = toMonacoWorkspaceEdit(dto);
         try {
             const edits = ResourceEdit.convert(workspaceEdit);
-            const { success } = await this.bulkEditService.apply(edits);
+            const { success } = await this.bulkEditService.apply(edits, { respectAutoSaveConfig: metadata?.isRefactoring });
             return success;
         } catch {
             return false;

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 {