@theia/plugin-ext 1.34.0-next.7 → 1.34.0

package/src/plugin/tree/tree-views.ts

@@ -18,18 +18,20 @@
 
 import {
     TreeDataProvider, TreeView, TreeViewExpansionEvent, TreeItem, TreeItemLabel,
-    TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, CancellationToken
+    TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, CancellationToken, DataTransferFile, TreeViewOptions
 } from '@theia/plugin';
 // TODO: extract `@theia/util` for event, disposable, cancellation and common types
 // don't use @theia/core directly from plugin host
 import { Emitter } from '@theia/core/lib/common/event';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
-import { Disposable as PluginDisposable, ThemeIcon } from '../types-impl';
-import { Plugin, PLUGIN_RPC_CONTEXT, TreeViewsExt, TreeViewsMain, TreeViewItem, TreeViewRevealOptions } from '../../common/plugin-api-rpc';
+import { DataTransfer, DataTransferItem, Disposable as PluginDisposable, ThemeIcon } from '../types-impl';
+import { Plugin, PLUGIN_RPC_CONTEXT, TreeViewsExt, TreeViewsMain, TreeViewItem, TreeViewRevealOptions, DataTransferFileDTO } from '../../common/plugin-api-rpc';
 import { RPCProtocol } from '../../common/rpc-protocol';
 import { CommandRegistryImpl, CommandsConverter } from '../command-registry';
-import { TreeViewSelection } from '../../common';
+import { TreeViewItemReference } from '../../common';
 import { PluginIconPath } from '../plugin-icon-path';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { UriComponents } from '@theia/core/lib/common/uri';
 
 export class TreeViewsExtImpl implements TreeViewsExt {
 
@@ -39,17 +41,30 @@ export class TreeViewsExtImpl implements TreeViewsExt {
 
     constructor(rpc: RPCProtocol, readonly commandRegistry: CommandRegistryImpl) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.TREE_VIEWS_MAIN);
+
         commandRegistry.registerArgumentProcessor({
             processArgument: arg => {
-                if (!TreeViewSelection.is(arg)) {
+                if (TreeViewItemReference.is(arg)) {
+                    return this.toTreeItem(arg);
+                } else if (Array.isArray(arg)) {
+                    return arg.map(param => TreeViewItemReference.is(param) ? this.toTreeItem(param) : param);
+                } else {
                     return arg;
                 }
-                const { treeViewId, treeItemId } = arg;
-                const treeView = this.treeViews.get(treeViewId);
-                return treeView && treeView.getTreeItem(treeItemId);
             }
         });
     }
+    $dragStarted(treeViewId: string, treeItemIds: string[], token: CancellationToken): Promise<UriComponents[] | undefined> {
+        return this.getTreeView(treeViewId).onDragStarted(treeItemIds, token);
+    }
+
+    $drop(treeViewId: string, treeItemId: string | undefined, dataTransferItems: [string, string | DataTransferFileDTO][], token: CancellationToken): Promise<void> {
+        return this.getTreeView(treeViewId).handleDrop!(treeItemId, dataTransferItems, token);
+    }
+
+    protected toTreeItem(treeViewItemRef: TreeViewItemReference): any {
+        return this.treeViews.get(treeViewItemRef.viewId)?.getTreeItem(treeViewItemRef.itemId);
+    }
 
     registerTreeDataProvider<T>(plugin: Plugin, treeViewId: string, treeDataProvider: TreeDataProvider<T>): PluginDisposable {
         const treeView = this.createTreeView(plugin, treeViewId, { treeDataProvider });
@@ -60,12 +75,12 @@ export class TreeViewsExtImpl implements TreeViewsExt {
         });
     }
 
-    createTreeView<T>(plugin: Plugin, treeViewId: string, options: { treeDataProvider: TreeDataProvider<T> }): TreeView<T> {
+    createTreeView<T>(plugin: Plugin, treeViewId: string, options: TreeViewOptions<T>): TreeView<T> {
         if (!options || !options.treeDataProvider) {
             throw new Error('Options with treeDataProvider is mandatory');
         }
 
-        const treeView = new TreeViewExtImpl(plugin, treeViewId, options.treeDataProvider, this.proxy, this.commandRegistry.converter);
+        const treeView = new TreeViewExtImpl<T>(plugin, treeViewId, options, this.proxy, this.commandRegistry.converter);
         this.treeViews.set(treeViewId, treeView);
 
         return {
@@ -187,6 +202,8 @@ class TreeViewExtImpl<T> implements Disposable {
     private readonly nodes = new Map<string, TreeExtNode<T>>();
     private pendingRefresh = Promise.resolve();
 
+    private localDataTransfer = new DataTransfer();
+
     private readonly toDispose = new DisposableCollection(
         Disposable.create(() => this.clearAll()),
         this.onDidExpandElementEmitter,
@@ -198,18 +215,18 @@ class TreeViewExtImpl<T> implements Disposable {
     constructor(
         private plugin: Plugin,
         private treeViewId: string,
-        private treeDataProvider: TreeDataProvider<T>,
+        private options: TreeViewOptions<T>,
         private proxy: TreeViewsMain,
-        readonly commandsConverter: CommandsConverter) {
-
-        proxy.$registerTreeDataProvider(treeViewId);
+        readonly commandsConverter: CommandsConverter
+    ) {
+        // make copies of optionally provided MIME types:
+        const dragMimeTypes = options.dragAndDropController?.dragMimeTypes?.slice();
+        const dropMimeTypes = options.dragAndDropController?.dropMimeTypes?.slice();
+        proxy.$registerTreeDataProvider(treeViewId, { canSelectMany: options.canSelectMany, dragMimeTypes, dropMimeTypes });
         this.toDispose.push(Disposable.create(() => this.proxy.$unregisterTreeDataProvider(treeViewId)));
-
-        if (treeDataProvider.onDidChangeTreeData) {
-            treeDataProvider.onDidChangeTreeData(() => {
-                this.pendingRefresh = proxy.$refresh(treeViewId);
-            });
-        }
+        options.treeDataProvider.onDidChangeTreeData?.(() => {
+            this.pendingRefresh = proxy.$refresh(treeViewId);
+        });
     }
 
     dispose(): void {
@@ -258,8 +275,7 @@ class TreeViewExtImpl<T> implements Disposable {
     }
 
     getTreeItem(treeItemId: string): T | undefined {
-        const element = this.nodes.get(treeItemId);
-        return element && element.value;
+        return this.nodes.get(treeItemId)?.value;
     }
 
     /**
@@ -276,15 +292,14 @@ class TreeViewExtImpl<T> implements Disposable {
             // root
             return [];
         }
-        const result = this.treeDataProvider.getParent && await this.treeDataProvider.getParent(element);
-        const parent = result ? result : undefined;
+        const parent = await this.options.treeDataProvider.getParent?.(element) ?? undefined;
         const chain = await this.calculateRevealParentChain(parent);
         if (!chain) {
             // parents are inconsistent
             return undefined;
         }
         const parentId = chain.length ? chain[chain.length - 1] : '';
-        const treeItem = await this.treeDataProvider.getTreeItem(element);
+        const treeItem = await this.options.treeDataProvider.getTreeItem(element);
         if (treeItem.id) {
             return chain.concat(treeItem.id);
         }
@@ -294,7 +309,8 @@ class TreeViewExtImpl<T> implements Disposable {
         // If not in cache, getChildren fills this.nodes and generate ids for them which are needed later
         const children = cachedParentNode?.children || await this.getChildren(parentId);
         if (!children) {
-            return undefined; // parent is inconsistent
+            // parent is inconsistent
+            return undefined;
         }
         const idLabel = this.getTreeItemIdLabel(treeItem);
         let possibleIndex = children.length;
@@ -351,13 +367,13 @@ class TreeViewExtImpl<T> implements Disposable {
             this.nodes.set(parentId, { id: '', disposables: rootNodeDisposables, dispose: () => { rootNodeDisposables.dispose(); } });
         }
         // ask data provider for children for cached element
-        const result = await this.treeDataProvider.getChildren(parent);
+        const result = await this.options.treeDataProvider.getChildren(parent);
         if (result) {
             const treeItemPromises = result.map(async (value, index) => {
 
                 // Ask data provider for a tree item for the value
                 // Data provider must return theia.TreeItem
-                const treeItem = await this.treeDataProvider.getTreeItem(value);
+                const treeItem = await this.options.treeDataProvider.getTreeItem(value);
                 // Convert theia.TreeItem to the TreeViewItem
 
                 const label = this.getTreeItemLabel(treeItem);
@@ -474,13 +490,13 @@ class TreeViewExtImpl<T> implements Disposable {
     }
 
     async resolveTreeItem(treeItemId: string, token: CancellationToken): Promise<TreeViewItem | undefined> {
-        if (!this.treeDataProvider.resolveTreeItem) {
+        if (!this.options.treeDataProvider.resolveTreeItem) {
             return undefined;
         }
 
         const node = this.nodes.get(treeItemId);
         if (node && node.treeViewItem && node.pluginTreeItem && node.value) {
-            const resolved = await this.treeDataProvider.resolveTreeItem(node.pluginTreeItem, node.value, token) ?? node.pluginTreeItem;
+            const resolved = await this.options.treeDataProvider.resolveTreeItem(node.pluginTreeItem, node.value, token) ?? node.pluginTreeItem;
             node.treeViewItem.command = this.commandsConverter.toSafeCommand(resolved.command, node.disposables);
             node.treeViewItem.tooltip = resolved.tooltip;
             return node.treeViewItem;
@@ -490,7 +506,7 @@ class TreeViewExtImpl<T> implements Disposable {
     }
 
     hasResolveTreeItem(): boolean {
-        return !!this.treeDataProvider.resolveTreeItem;
+        return !!this.options.treeDataProvider.resolveTreeItem;
     }
 
     private selectedItemIds = new Set<string>();
@@ -535,4 +551,55 @@ class TreeViewExtImpl<T> implements Disposable {
         }
     }
 
+    async onDragStarted(treeItemIds: string[], token: CancellationToken): Promise<UriComponents[] | undefined> {
+        const treeItems: T[] = [];
+        for (const id of treeItemIds) {
+            const item = this.getTreeItem(id);
+            if (item) {
+                treeItems.push(item);
+            }
+        }
+        if (this.options.dragAndDropController?.handleDrag) {
+            this.localDataTransfer.clear();
+            await this.options.dragAndDropController.handleDrag(treeItems, this.localDataTransfer, token);
+            const uriList = await this.localDataTransfer.get('text/uri-list')?.asString();
+            if (uriList) {
+                return uriList.split('\n').map(str => URI.parse(str));
+            }
+        }
+        return undefined;
+    }
+
+    async handleDrop(treeItemId: string | undefined, dataTransferItems: [string, string | DataTransferFileDTO][], token: CancellationToken): Promise<void> {
+        const treeItem = treeItemId ? this.getTreeItem(treeItemId) : undefined;
+        const dropTransfer = new DataTransfer();
+        if (this.options.dragAndDropController?.handleDrop) {
+            this.localDataTransfer.forEach((item, type) => {
+                dropTransfer.set(type, item);
+            });
+            for (const [type, item] of dataTransferItems) {
+                // prefer the item the plugin has set in `onDragStarted`;
+                if (!dropTransfer.has(type)) {
+                    if (typeof item === 'string') {
+                        dropTransfer.set(type, new DataTransferItem(item));
+                    } else {
+                        const file: DataTransferFile = {
+                            name: item.name,
+                            data: () => this.proxy.$readDroppedFile(item.contentId).then(buffer => buffer.buffer),
+                            uri: item.uri ? URI.revive(item.uri) : undefined
+                        };
+
+                        const fileItem = new class extends DataTransferItem {
+                            override asFile(): DataTransferFile | undefined {
+                                return file;
+                            }
+                        }(file);
+
+                        dropTransfer.set(type, fileItem);
+                    }
+                }
+            }
+            return this.options.dragAndDropController.handleDrop(treeItem, dropTransfer, token);
+        }
+    }
 }

package/src/plugin/type-converters.spec.ts

@@ -453,4 +453,24 @@ describe('Type converters:', () => {
             assert.deepStrictEqual(result, showOptions);
         });
     });
+
+    describe('#convertCode', () => {
+        it('should convert a "code" of type "string"', () => {
+            assert.strictEqual(Converter.convertCode('string'), 'string');
+        });
+        it('should convert a "code" of type "number"', () => {
+            assert.strictEqual(Converter.convertCode(4), '4');
+        });
+        it('should convert an undefined "code"', () => {
+            assert.strictEqual(Converter.convertCode(undefined), undefined);
+        });
+        it('should convert a "code" of type "{ value: number, target: Uri }"', () => {
+            const uri = types.URI.parse('foo://example.com:8042/over/there?name=ferret#nose');
+            assert.strictEqual(Converter.convertCode({ value: 4, target: uri }), '4');
+        });
+        it('should convert a "code" of type "{ value: number, target: Uri }"', () => {
+            const uri = types.URI.parse('foo://example.com:8042/over/there?name=ferret#nose');
+            assert.strictEqual(Converter.convertCode({ value: 'string', target: uri }), 'string');
+        });
+    });
 });

package/src/plugin/type-converters.ts

@@ -28,6 +28,7 @@ import * as types from './types-impl';
 import { UriComponents } from '../common/uri-components';
 import { isReadonlyArray } from '../common/arrays';
 import { MarkdownString as MarkdownStringDTO } from '@theia/core/lib/common/markdown-rendering';
+import { isObject } from '@theia/core/lib/common';
 
 const SIDE_GROUP = -2;
 const ACTIVE_GROUP = -1;
@@ -136,7 +137,7 @@ export function toPosition(position: Position): types.Position {
 }
 
 function isDecorationOptions(arg: unknown): arg is theia.DecorationOptions {
-    return !!arg && typeof arg === 'object' && typeof (arg as theia.DecorationOptions).range !== 'undefined';
+    return isObject<theia.DecorationOptions>(arg) && typeof arg.range !== 'undefined';
 }
 
 export function isDecorationOptionsArr(something: theia.Range[] | theia.DecorationOptions[]): something is theia.DecorationOptions[] {
@@ -180,9 +181,9 @@ interface Codeblock {
 }
 
 function isCodeblock(arg: unknown): arg is Codeblock {
-    return !!arg && typeof arg === 'object'
-        && typeof (arg as Codeblock).language === 'string'
-        && typeof (arg as Codeblock).value === 'string';
+    return isObject<Codeblock>(arg)
+        && typeof arg.language === 'string'
+        && typeof arg.value === 'string';
 }
 
 export function fromMarkdown(markup: theia.MarkdownString | theia.MarkedString): MarkdownStringDTO {
@@ -315,6 +316,14 @@ export function fromTextEdit(edit: theia.TextEdit): model.TextEdit {
     };
 }
 
+function fromSnippetTextEdit(edit: theia.SnippetTextEdit): model.TextEdit & { insertAsSnippet?: boolean } {
+    return {
+        text: edit.snippet.value,
+        range: fromRange(edit.range),
+        insertAsSnippet: true
+    };
+}
+
 export function convertDiagnosticToMarkerData(diagnostic: theia.Diagnostic): model.MarkerData {
     return {
         code: convertCode(diagnostic.code),
@@ -330,12 +339,15 @@ export function convertDiagnosticToMarkerData(diagnostic: theia.Diagnostic): mod
     };
 }
 
-function convertCode(code: string | number | undefined): string | undefined {
+export function convertCode(code: string | number | { value: string | number; target: theia.Uri } | undefined): string | undefined {
     if (typeof code === 'number') {
         return String(code);
-    } else {
-        return code;
     }
+    if (typeof code === 'string' || typeof code === 'undefined') {
+        return code;
+    } else {
+        return String(code.value);
+    };
 }
 
 function convertSeverity(severity: types.DiagnosticSeverity): types.MarkerSeverity {
@@ -566,7 +578,7 @@ export function fromWorkspaceEdit(value: theia.WorkspaceEdit, documents?: any):
             const workspaceTextEditDto: WorkspaceTextEditDto = {
                 resource: uri,
                 modelVersionId: doc?.version,
-                textEdit: uriOrEdits.map(fromTextEdit)[0],
+                textEdit: uriOrEdits.map(edit => (edit instanceof types.TextEdit) ? fromTextEdit(edit) : fromSnippetTextEdit(edit))[0],
                 metadata: entry[2] as types.WorkspaceEditMetadata
             };
             result.edits.push(workspaceTextEditDto);
@@ -677,57 +689,47 @@ export function toSymbolTag(kind: model.SymbolTag): types.SymbolTag {
 }
 
 export function isModelLocation(arg: unknown): arg is model.Location {
-    if (!arg) {
-        return false;
-    }
-    return !!arg &&
-        typeof arg === 'object' &&
-        isModelRange((arg as model.Location).range) &&
-        isUriComponents((arg as model.Location).uri);
+    return isObject<model.Location>(arg) &&
+        isModelRange(arg.range) &&
+        isUriComponents(arg.uri);
 }
 
 export function isModelRange(arg: unknown): arg is model.Range {
-    const range = arg as model.Range;
-    return !!arg && typeof arg === 'object' &&
-        typeof range.startLineNumber === 'number' &&
-        typeof range.startColumn === 'number' &&
-        typeof range.endLineNumber === 'number' &&
-        typeof range.endColumn === 'number';
+    return isObject<model.Range>(arg) &&
+        typeof arg.startLineNumber === 'number' &&
+        typeof arg.startColumn === 'number' &&
+        typeof arg.endLineNumber === 'number' &&
+        typeof arg.endColumn === 'number';
 }
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function isUriComponents(arg: unknown): arg is UriComponents {
-    const uriComponents = arg as UriComponents;
-    return !!arg && typeof arg === 'object' &&
-        typeof uriComponents.scheme === 'string' &&
-        typeof uriComponents.path === 'string' &&
-        typeof uriComponents.query === 'string' &&
-        typeof uriComponents.fragment === 'string';
+    return isObject<UriComponents>(arg) &&
+        typeof arg.scheme === 'string' &&
+        typeof arg.path === 'string' &&
+        typeof arg.query === 'string' &&
+        typeof arg.fragment === 'string';
 }
 
 export function isModelCallHierarchyItem(arg: unknown): arg is model.CallHierarchyItem {
-    const item = arg as model.CallHierarchyItem;
-    return !!item && typeof item === 'object'
-        && isModelRange(item.range)
-        && isModelRange(item.selectionRange)
-        && isUriComponents(item.uri)
-        && !!item.name;
+    return isObject<model.CallHierarchyItem>(arg)
+        && isModelRange(arg.range)
+        && isModelRange(arg.selectionRange)
+        && isUriComponents(arg.uri)
+        && !!arg.name;
 }
 
 export function isModelCallHierarchyIncomingCall(arg: unknown): arg is model.CallHierarchyIncomingCall {
-    const maybeIncomingCall = arg as model.CallHierarchyIncomingCall;
-    return !!arg && typeof arg === 'object' &&
-        'from' in maybeIncomingCall &&
-        'fromRanges' in maybeIncomingCall &&
-        isModelCallHierarchyItem(maybeIncomingCall.from);
+    return isObject<model.CallHierarchyIncomingCall>(arg) &&
+        'from' in arg &&
+        'fromRanges' in arg &&
+        isModelCallHierarchyItem(arg.from);
 }
 
 export function isModelCallHierarchyOutgoingCall(arg: unknown): arg is model.CallHierarchyOutgoingCall {
-    const maybeOutgoingCall = arg as model.CallHierarchyOutgoingCall;
-    return !!arg && typeof arg === 'object' &&
-        'to' in maybeOutgoingCall &&
-        'fromRanges' in maybeOutgoingCall &&
-        isModelCallHierarchyItem(maybeOutgoingCall.to);
+    return isObject<model.CallHierarchyOutgoingCall>(arg) &&
+        'to' in arg &&
+        'fromRanges' in arg &&
+        isModelCallHierarchyItem(arg.to);
 }
 
 export function toLocation(value: model.Location): types.Location {
@@ -781,12 +783,11 @@ export function toCallHierarchyOutgoingCall(value: model.CallHierarchyOutgoingCa
 }
 
 export function isModelTypeHierarchyItem(arg: unknown): arg is model.TypeHierarchyItem {
-    const item = arg as model.TypeHierarchyItem;
-    return !!item && typeof item === 'object'
-        && isModelRange(item.range)
-        && isModelRange(item.selectionRange)
-        && isUriComponents(item.uri)
-        && !!item.name;
+    return isObject<model.TypeHierarchyItem>(arg)
+        && isModelRange(arg.range)
+        && isModelRange(arg.selectionRange)
+        && isUriComponents(arg.uri)
+        && !!arg.name;
 }
 
 export function fromTypeHierarchyItem(item: types.TypeHierarchyItem): model.TypeHierarchyItem {