@theia/plugin-ext 1.24.0-next.4 → 1.24.0-next.40

package/src/main/browser/editor/untitled-resource.ts

@@ -15,21 +15,16 @@
 // *****************************************************************************
 
 import { Emitter, Event } from '@theia/core/lib/common/event';
-import { injectable, inject } from '@theia/core/shared/inversify';
-import { Resource, ResourceResolver, ResourceVersion, ResourceSaveOptions } from '@theia/core/lib/common/resource';
+import { injectable } from '@theia/core/shared/inversify';
+import { Resource, ResourceResolver, ResourceVersion } from '@theia/core/lib/common/resource';
 import URI from '@theia/core/lib/common/uri';
 import { Schemes } from '../../../common/uri-components';
-import { FileResource, FileResourceResolver } from '@theia/filesystem/lib/browser';
-import { TextDocumentContentChangeEvent } from '@theia/core/shared/vscode-languageserver-protocol';
 
 let index = 0;
 
 @injectable()
 export class UntitledResourceResolver implements ResourceResolver {
 
-    @inject(FileResourceResolver)
-    protected readonly fileResourceResolver: FileResourceResolver;
-
     protected readonly resources = new Map<string, UntitledResource>();
 
     async resolve(uri: URI): Promise<UntitledResource> {
@@ -38,14 +33,14 @@ export class UntitledResourceResolver implements ResourceResolver {
         } else {
             const untitledResource = this.resources.get(uri.toString());
             if (!untitledResource) {
-                return this.createUntitledResource(this.fileResourceResolver, '', '', uri);
+                return this.createUntitledResource('', '', uri);
             } else {
                 return untitledResource;
             }
         }
     }
 
-    async createUntitledResource(fileResourceResolver: FileResourceResolver, content?: string, language?: string, uri?: URI): Promise<UntitledResource> {
+    async createUntitledResource(content?: string, language?: string, uri?: URI): Promise<UntitledResource> {
         let extension;
         if (language) {
             for (const lang of monaco.languages.getLanguages()) {
@@ -58,33 +53,26 @@ export class UntitledResourceResolver implements ResourceResolver {
             }
         }
         return new UntitledResource(this.resources, uri ? uri : new URI().withScheme(Schemes.untitled).withPath(`/Untitled-${index++}${extension ? extension : ''}`),
-            fileResourceResolver, content);
+            content);
     }
 }
 
 export class UntitledResource implements Resource {
 
-    private fileResource?: FileResource;
-
     protected readonly onDidChangeContentsEmitter = new Emitter<void>();
     readonly onDidChangeContents: Event<void> = this.onDidChangeContentsEmitter.event;
 
-    constructor(private resources: Map<string, UntitledResource>, public uri: URI, private fileResourceResolver: FileResourceResolver, private content?: string) {
+    constructor(private resources: Map<string, UntitledResource>, public uri: URI, private content?: string) {
         this.resources.set(this.uri.toString(), this);
     }
 
     dispose(): void {
         this.resources.delete(this.uri.toString());
         this.onDidChangeContentsEmitter.dispose();
-        if (this.fileResource) {
-            this.fileResource.dispose();
-        }
     }
 
     async readContents(options?: { encoding?: string | undefined; } | undefined): Promise<string> {
-        if (this.fileResource) {
-            return this.fileResource.readContents(options);
-        } else if (this.content) {
+        if (this.content) {
             return this.content;
         } else {
             return '';
@@ -92,26 +80,9 @@ export class UntitledResource implements Resource {
     }
 
     async saveContents(content: string, options?: { encoding?: string, overwriteEncoding?: boolean }): Promise<void> {
-        if (!this.fileResource) {
-            this.fileResource = await this.fileResourceResolver.resolve(new URI(this.uri.path.toString()));
-            if (this.fileResource.onDidChangeContents) {
-                this.fileResource.onDidChangeContents(() => this.fireDidChangeContents());
-            }
-        }
-        await this.fileResource.saveContents(content, options);
-    }
-
-    async saveContentChanges(changes: TextDocumentContentChangeEvent[], options?: ResourceSaveOptions): Promise<void> {
-        if (!this.fileResource || !this.fileResource.saveContentChanges) {
-            throw new Error('FileResource is not available for: ' + this.uri.path.toString());
-        }
-        await this.fileResource.saveContentChanges(changes, options);
-    }
-
-    async guessEncoding(): Promise<string | undefined> {
-        if (this.fileResource) {
-            return this.fileResource.guessEncoding();
-        }
+        // This function must exist to ensure readOnly is false for the Monaco editor.
+        // However it should not be called because saving 'untitled' is always processed as 'Save As'.
+        throw Error('never');
     }
 
     protected fireDidChangeContents(): void {
@@ -119,16 +90,10 @@ export class UntitledResource implements Resource {
     }
 
     get version(): ResourceVersion | undefined {
-        if (this.fileResource) {
-            return this.fileResource.version;
-        }
         return undefined;
     }
 
     get encoding(): string | undefined {
-        if (this.fileResource) {
-            return this.fileResource.encoding;
-        }
         return undefined;
     }
 }

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

@@ -459,14 +459,15 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         }
     }
 
-    $registerOutlineSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[]): void {
+    $registerOutlineSupport(handle: number, pluginInfo: PluginInfo, selector: SerializedDocumentFilter[], displayName?: string): void {
         const languageSelector = this.toLanguageSelector(selector);
-        const symbolProvider = this.createDocumentSymbolProvider(handle);
+        const symbolProvider = this.createDocumentSymbolProvider(handle, displayName);
         this.register(handle, monaco.modes.DocumentSymbolProviderRegistry.register(languageSelector, symbolProvider));
     }
 
-    protected createDocumentSymbolProvider(handle: number): monaco.languages.DocumentSymbolProvider {
+    protected createDocumentSymbolProvider(handle: number, displayName?: string): monaco.languages.DocumentSymbolProvider {
         return {
+            displayName,
             provideDocumentSymbols: (model, token) => this.provideDocumentSymbols(handle, model, token)
         };
     }

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

@@ -47,7 +47,6 @@ import { ApplicationShell } from '@theia/core/lib/browser/shell/application-shel
 import { MonacoBulkEditService } from '@theia/monaco/lib/browser/monaco-bulk-edit-service';
 import { MonacoEditorService } from '@theia/monaco/lib/browser/monaco-editor-service';
 import { UntitledResourceResolver } from './editor/untitled-resource';
-import { FileResourceResolver } from '@theia/filesystem/lib/browser';
 import { MainFileSystemEventService } from './main-file-system-event-service';
 import { LabelServiceMainImpl } from './label-service-main';
 import { TimelineMainImpl } from './timeline-main';
@@ -87,8 +86,7 @@ export function setUpPluginApi(rpc: RPCProtocol, container: interfaces.Container
     const openerService = container.get<OpenerService>(OpenerService);
     const shell = container.get(ApplicationShell);
     const untitledResourceResolver = container.get(UntitledResourceResolver);
-    const fileResourceResolver = container.get(FileResourceResolver);
-    const documentsMain = new DocumentsMainImpl(editorsAndDocuments, modelService, rpc, editorManager, openerService, shell, untitledResourceResolver, fileResourceResolver);
+    const documentsMain = new DocumentsMainImpl(editorsAndDocuments, modelService, rpc, editorManager, openerService, shell, untitledResourceResolver);
     rpc.set(PLUGIN_RPC_CONTEXT.DOCUMENTS_MAIN, documentsMain);
 
     const bulkEditService = container.get(MonacoBulkEditService);

package/src/main/browser/menus/menus-contribution-handler.ts

@@ -518,13 +518,26 @@ export class MenusContributionPointHandler {
         }
         const toDispose = new DisposableCollection();
         const commandId = this.createSyntheticCommandId(menu.command, { prefix: '__plugin.menu.action.' });
+        const altId = menu.alt && this.createSyntheticCommandId(menu.alt, { prefix: '__plugin.menu.action.' });
+
+        const inline = Boolean(menu.group && /^inline/.test(menu.group));
+        const [group, order = undefined] = (menu.group || '_').split('@');
+
         const command: Command = { id: commandId };
+        const action: MenuAction = { commandId, alt: altId, order, when: menu.when };
+
         toDispose.push(this.commands.registerCommand(command, handler(menu.command)));
         toDispose.push(this.quickCommandService?.pushCommandContext(commandId, 'false'));
+        toDispose.push(this.menuRegistry.registerMenuAction(inline ? menuPath : [...menuPath, ...group.split('/')], action));
+        toDispose.push(this.onDidRegisterCommand(menu.command, pluginCommand => {
+            command.category = pluginCommand.category;
+            command.label = pluginCommand.label;
+            if (inline) {
+                command.iconClass = pluginCommand.iconClass;
+            }
+        }));
 
-        let altId: string | undefined;
-        if (menu.alt) {
-            altId = this.createSyntheticCommandId(menu.alt, { prefix: '__plugin.menu.action.' });
+        if (menu.alt && altId) {
             const alt: Command = { id: altId };
             toDispose.push(this.commands.registerCommand(alt, handler(menu.alt)));
             toDispose.push(this.quickCommandService?.pushCommandContext(altId, 'false'));
@@ -537,13 +550,9 @@ export class MenusContributionPointHandler {
             }));
         }
 
-        const { when } = menu;
-        const [group, order = undefined] = (menu.group || '_').split('@');
-        const action: MenuAction = { commandId, alt: altId, order, when };
-
         // Register a submenu if the group is in format `<submenu group>/<submenu name>/<submenu order>.../<menu group>`
-        if (group!.indexOf('/') !== -1) {
-            const groupSplit = group!.split('/');
+        if (group.includes('/')) {
+            const groupSplit = group.split('/');
             const orderSplit = (menu.submenusOrder || '').split('/');
             const paths: string[] = [];
             for (let i = 0, j = 0; i < groupSplit.length - 1; i += 2, j += 1) {
@@ -554,17 +563,7 @@ export class MenusContributionPointHandler {
                 toDispose.push(this.menuRegistry.registerSubmenu([...menuPath, ...paths], submenuLabel, { order: submenuOrder }));
             }
         }
-        const inline = /^inline/.test(group);
-        menuPath = inline ? menuPath : [...menuPath, ...group.split('/')];
-        toDispose.push(this.menuRegistry.registerMenuAction(menuPath, action));
 
-        toDispose.push(this.onDidRegisterCommand(menu.command, pluginCommand => {
-            command.category = pluginCommand.category;
-            command.label = pluginCommand.label;
-            if (inline) {
-                command.iconClass = pluginCommand.iconClass;
-            }
-        }));
         return toDispose;
     }
 

package/src/main/browser/webview/webview-environment.ts

@@ -60,8 +60,14 @@ export class WebviewEnvironment {
         return (await this.externalEndpointUrl()).toString(true);
     }
 
-    async resourceRoot(): Promise<string> {
-        return (await this.externalEndpointUrl()).resolve('theia-resource/{{resource}}').toString(true);
+    async resourceRoot(host: string): Promise<string> {
+        if (host === 'frontend') {
+            return (await this.externalEndpointUrl()).withPath('{{path}}').toString(true);
+        }
+
+        // Make sure we preserve the scheme of the resource but convert it into a normal path segment
+        // The scheme is important as we need to know if we are requesting a local or a remote resource.
+        return (await this.externalEndpointUrl()).resolve('theia-resource/{{scheme}}//{{authority}}/{{path}}').toString(true);
     }
 
     async cspSource(): Promise<string> {

package/src/main/browser/webview/webview.ts

@@ -44,6 +44,7 @@ import { OutputChannelManager } from '@theia/output/lib/browser/output-channel';
 import { WebviewPreferences } from './webview-preferences';
 import { WebviewResourceCache } from './webview-resource-cache';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
+import { isFirefox } from '@theia/core/lib/browser/browser';
 import { FileService } from '@theia/filesystem/lib/browser/file-service';
 import { FileOperationError, FileOperationResult } from '@theia/filesystem/lib/common/files';
 import { BinaryBufferReadableStream } from '@theia/core/lib/common/buffer';
@@ -250,6 +251,9 @@ export class WebviewWidget extends BaseWidget implements StatefulWidget {
         const element = document.createElement('iframe');
         element.className = 'webview';
         element.sandbox.add('allow-scripts', 'allow-forms', 'allow-same-origin', 'allow-downloads');
+        if (!isFirefox) {
+            element.setAttribute('allow', 'clipboard-read; clipboard-write; usb; serial; hid;');
+        }
         element.setAttribute('src', `${this.externalEndpoint}/index.html?id=${this.identifier.id}`);
         element.style.border = 'none';
         element.style.width = '100%';

package/src/plugin/languages.ts

@@ -531,9 +531,11 @@ export class LanguagesExtImpl implements LanguagesExt {
     // ### Code Reference Provider end
 
     // ### Document Symbol Provider begin
-    registerDocumentSymbolProvider(selector: theia.DocumentSelector, provider: theia.DocumentSymbolProvider, pluginInfo: PluginInfo): theia.Disposable {
+    registerDocumentSymbolProvider(selector: theia.DocumentSelector, provider: theia.DocumentSymbolProvider, pluginInfo: PluginInfo,
+        metadata?: theia.DocumentSymbolProviderMetadata): theia.Disposable {
         const callId = this.addNewAdapter(new OutlineAdapter(this.documents, provider));
-        this.proxy.$registerOutlineSupport(callId, pluginInfo, this.transformDocumentSelector(selector));
+        const displayName = (metadata && metadata.label) || getPluginLabel(pluginInfo);
+        this.proxy.$registerOutlineSupport(callId, pluginInfo, this.transformDocumentSelector(selector), displayName);
         return this.createDisposable(callId);
     }
 
@@ -700,3 +702,7 @@ function serializeIndentation(indentationRules?: theia.IndentationRule): Seriali
         unIndentedLinePattern: serializeRegExp(indentationRules.unIndentedLinePattern)
     };
 }
+
+function getPluginLabel(pluginInfo: PluginInfo): string {
+    return pluginInfo.displayName || pluginInfo.name;
+}

package/src/plugin/plugin-context.ts

@@ -752,8 +752,9 @@ export function createAPIFactory(
             registerReferenceProvider(selector: theia.DocumentSelector, provider: theia.ReferenceProvider): theia.Disposable {
                 return languagesExt.registerReferenceProvider(selector, provider, pluginToPluginInfo(plugin));
             },
-            registerDocumentSymbolProvider(selector: theia.DocumentSelector, provider: theia.DocumentSymbolProvider): theia.Disposable {
-                return languagesExt.registerDocumentSymbolProvider(selector, provider, pluginToPluginInfo(plugin));
+            registerDocumentSymbolProvider(selector: theia.DocumentSelector, provider: theia.DocumentSymbolProvider,
+                metadata?: theia.DocumentSymbolProviderMetadata): theia.Disposable {
+                return languagesExt.registerDocumentSymbolProvider(selector, provider, pluginToPluginInfo(plugin), metadata);
             },
             registerColorProvider(selector: theia.DocumentSelector, provider: theia.DocumentColorProvider): theia.Disposable {
                 return languagesExt.registerColorProvider(selector, provider, pluginToPluginInfo(plugin));

package/src/plugin/type-converters.ts

@@ -1217,6 +1217,7 @@ export function pathOrURIToURI(value: string | URI): URI {
 export function pluginToPluginInfo(plugin: Plugin): rpc.PluginInfo {
     return {
         id: plugin.model.id,
-        name: plugin.model.name
+        name: plugin.model.name,
+        displayName: plugin.model.displayName
     };
 }

package/src/plugin/webviews.ts

@@ -216,9 +216,9 @@ export class WebviewImpl implements theia.Webview {
 
     asWebviewUri(resource: theia.Uri): theia.Uri {
         const uri = this.initData.webviewResourceRoot
-            // Make sure we preserve the scheme of the resource but convert it into a normal path segment
-            // The scheme is important as we need to know if we are requesting a local or a remote resource.
-            .replace('{{resource}}', resource.scheme + resource.toString().replace(/^\S+?:/, ''))
+            .replace('{{scheme}}', resource.scheme)
+            .replace('{{authority}}', resource.authority)
+            .replace('{{path}}', resource.path.replace(/^\//, ''))
             .replace('{{uuid}}', this.viewId);
         return URI.parse(uri);
     }