@theia/plugin-ext 1.34.0-next.34 → 1.34.0-next.39

package/src/plugin/terminal-ext.ts

@@ -52,9 +52,9 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
 
     private readonly _pseudoTerminals = new Map<string, PseudoTerminal>();
 
-    private static nextTerminalLinkProviderId = 0;
+    private static nextProviderId = 0;
     private readonly terminalLinkProviders = new Map<string, theia.TerminalLinkProvider>();
-
+    private readonly terminalProfileProviders = new Map<string, theia.TerminalProfileProvider>();
     private readonly onDidCloseTerminalEmitter = new Emitter<Terminal>();
     readonly onDidCloseTerminal: theia.Event<Terminal> = this.onDidCloseTerminalEmitter.event;
 
@@ -81,9 +81,9 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         nameOrOptions: TerminalOptions | PseudoTerminalOptions | ExtensionTerminalOptions | (string | undefined),
         shellPath?: string, shellArgs?: string[] | string
     ): Terminal {
-        let options: TerminalOptions | ExtensionTerminalOptions;
-        let pseudoTerminal: theia.Pseudoterminal | undefined = undefined;
         const id = `plugin-terminal-${UUID.uuid4()}`;
+        let options: TerminalOptions;
+        let pseudoTerminal: theia.Pseudoterminal | undefined = undefined;
         if (typeof nameOrOptions === 'object') {
             if ('pty' in nameOrOptions) {
                 pseudoTerminal = nameOrOptions.pty;
@@ -220,7 +220,7 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
     }
 
     registerTerminalLinkProvider(provider: theia.TerminalLinkProvider): theia.Disposable {
-        const providerId = (TerminalServiceExtImpl.nextTerminalLinkProviderId++).toString();
+        const providerId = (TerminalServiceExtImpl.nextProviderId++).toString();
         this.terminalLinkProviders.set(providerId, provider);
         this.proxy.$registerTerminalLinkProvider(providerId);
         return Disposable.create(() => {
@@ -229,6 +229,36 @@ export class TerminalServiceExtImpl implements TerminalServiceExt {
         });
     }
 
+    registerTerminalProfileProvider(id: string, provider: theia.TerminalProfileProvider): theia.Disposable {
+        this.terminalProfileProviders.set(id, provider);
+        return Disposable.create(() => {
+            this.terminalProfileProviders.delete(id);
+        });
+    }
+
+    protected isExtensionTerminalOptions(options: theia.TerminalOptions | theia.ExtensionTerminalOptions): options is theia.ExtensionTerminalOptions {
+        return 'pty' in options;
+    }
+
+    async $startProfile(profileId: string, cancellationToken: theia.CancellationToken): Promise<string> {
+        const provider = this.terminalProfileProviders.get(profileId);
+        if (!provider) {
+            throw new Error(`No terminal profile provider with id '${profileId}'`);
+        }
+        const profile = await provider.provideTerminalProfile(cancellationToken);
+        if (!profile) {
+            throw new Error(`Profile with id ${profileId} could not be created`);
+        }
+        const id = `plugin-terminal-${UUID.uuid4()}`;
+        const options = profile.options;
+        if (this.isExtensionTerminalOptions(options)) {
+            this._pseudoTerminals.set(id, new PseudoTerminal(id, this.proxy, options.pty));
+            return this.proxy.$createTerminal(id, { name: options.name }, undefined, true);
+        } else {
+            return this.proxy.$createTerminal(id, profile.options);
+        }
+    }
+
     async $provideTerminalLinks(line: string, terminalId: string, token: theia.CancellationToken): Promise<ProvidedTerminalLink[]> {
         const links: ProvidedTerminalLink[] = [];
         const terminal = this._terminals.get(terminalId);

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

@@ -18,18 +18,20 @@
 
 import {
     TreeDataProvider, TreeView, TreeViewExpansionEvent, TreeItem, TreeItemLabel,
-    TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, CancellationToken
+    TreeViewSelectionChangeEvent, TreeViewVisibilityChangeEvent, CancellationToken, TreeDragAndDropController, DataTransferFile
 } 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 { 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 {
 
@@ -50,6 +52,13 @@ export class TreeViewsExtImpl implements TreeViewsExt {
             }
         });
     }
+    $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);
+    }
 
     registerTreeDataProvider<T>(plugin: Plugin, treeViewId: string, treeDataProvider: TreeDataProvider<T>): PluginDisposable {
         const treeView = this.createTreeView(plugin, treeViewId, { treeDataProvider });
@@ -60,12 +69,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: { treeDataProvider: TreeDataProvider<T>, dragAndDropController?: TreeDragAndDropController<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(plugin, treeViewId, options.treeDataProvider, options.dragAndDropController, this.proxy, this.commandRegistry.converter);
         this.treeViews.set(treeViewId, treeView);
 
         return {
@@ -187,6 +196,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,
@@ -199,10 +210,15 @@ class TreeViewExtImpl<T> implements Disposable {
         private plugin: Plugin,
         private treeViewId: string,
         private treeDataProvider: TreeDataProvider<T>,
+        private dragAndDropController: TreeDragAndDropController<T> | undefined,
         private proxy: TreeViewsMain,
         readonly commandsConverter: CommandsConverter) {
 
-        proxy.$registerTreeDataProvider(treeViewId);
+        const dragTypes = dragAndDropController?.dragMimeTypes ? [...dragAndDropController.dragMimeTypes] : undefined;
+        const dropTypes = dragAndDropController?.dropMimeTypes ? [...dragAndDropController.dropMimeTypes] : undefined;
+
+        proxy.$registerTreeDataProvider(treeViewId, dragTypes, dropTypes);
+
         this.toDispose.push(Disposable.create(() => this.proxy.$unregisterTreeDataProvider(treeViewId)));
 
         if (treeDataProvider.onDidChangeTreeData) {
@@ -535,4 +551,56 @@ 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.dragAndDropController && this.dragAndDropController.handleDrag) {
+            this.localDataTransfer.clear();
+            await this.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.dragAndDropController && this.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 Promise.resolve(this.dragAndDropController.handleDrop(treeItem, dropTransfer, token));
+        }
+    }
 }

package/src/plugin/types-impl.ts

@@ -1814,6 +1814,55 @@ export class WorkspaceEdit implements theia.WorkspaceEdit {
     }
 }
 
+export class DataTransferItem {
+    asString(): Thenable<string> {
+        return Promise.resolve(typeof this.value === 'string' ? this.value : JSON.stringify(this.value));
+    }
+
+    asFile(): theia.DataTransferFile | undefined {
+        return undefined;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(readonly value: any) {
+    }
+}
+
+/**
+ * A map containing a mapping of the mime type of the corresponding transferred data.
+ *
+ * Drag and drop controllers that implement {@link TreeDragAndDropController.handleDrag `handleDrag`} can add additional mime types to the
+ * data transfer. These additional mime types will only be included in the `handleDrop` when the the drag was initiated from
+ * an element in the same drag and drop controller.
+ */
+@es5ClassCompat
+export class DataTransfer implements Iterable<[mimeType: string, item: DataTransferItem]> {
+    private items = new Map<string, DataTransferItem>();
+    get(mimeType: string): DataTransferItem | undefined {
+        return this.items.get(mimeType);
+    }
+    set(mimeType: string, value: DataTransferItem): void {
+        this.items.set(mimeType, value);
+    }
+
+    has(mimeType: string): boolean {
+        return this.items.has(mimeType);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    forEach(callbackfn: (item: DataTransferItem, mimeType: string, dataTransfer: DataTransfer) => void, thisArg?: any): void {
+        this.items.forEach((item, mimetype) => {
+            callbackfn.call(thisArg, item, mimetype, this);
+        });
+    }
+    [Symbol.iterator](): IterableIterator<[mimeType: string, item: DataTransferItem]> {
+        return this.items[Symbol.iterator]();
+    }
+
+    clear(): void {
+        this.items.clear();
+    }
+}
 @es5ClassCompat
 export class TreeItem {
 
@@ -1974,6 +2023,14 @@ export enum TerminalLocation {
     Panel = 1,
     Editor = 2
 }
+export class TerminalProfile {
+    /**
+     * Creates a new terminal profile.
+     * @param options The options that the terminal will launch with.
+     */
+    constructor(readonly options: theia.TerminalOptions | theia.ExtensionTerminalOptions) {
+    }
+}
 
 @es5ClassCompat
 export class FileDecoration {