@theia/plugin-ext 1.77.0-next.4 → 1.77.0-next.47

package/src/main/browser/view/plugin-view-registry.spec.ts

@@ -23,7 +23,7 @@ import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/front
 FrontendApplicationConfigProvider.set({});
 
 import { expect } from 'chai';
-import { Disposable } from '@theia/core/lib/common';
+import { Command, Disposable } from '@theia/core/lib/common';
 import { PluginViewRegistry, ViewContainerInfo, PLUGIN_VIEW_DATA_FACTORY_ID } from './plugin-view-registry';
 import type { ViewWelcome } from '../../../common';
 
@@ -54,7 +54,6 @@ describe('PluginViewRegistry - view menu labels', () => {
     let registry: PluginViewRegistry;
     let menus: RecordingMenuModelRegistry;
 
-    const toggleCommandId = (id: string): string => `plugin.view-container.${id}.toggle`;
     const internals = (): {
         viewContainers: Map<string, ViewContainerInfo>;
         registerViewMenuAction(containerId: string, label: string): Disposable;
@@ -76,21 +75,21 @@ describe('PluginViewRegistry - view menu labels', () => {
 
     it('uses the plain label for a single container', () => {
         registerContainer('a', 'Claude Code', 'left');
-        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Claude Code');
+        expect(menus.actions.get('a')?.label).to.equal('Claude Code');
     });
 
     it('leaves distinct labels unsuffixed', () => {
         registerContainer('a', 'Explorer', 'left');
         registerContainer('b', 'Claude Code', 'right');
-        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Explorer');
-        expect(menus.actions.get(toggleCommandId('b'))?.label).to.equal('Claude Code');
+        expect(menus.actions.get('a')?.label).to.equal('Explorer');
+        expect(menus.actions.get('b')?.label).to.equal('Claude Code');
     });
 
     it('suffixes the location when two containers share a label', () => {
         registerContainer('a', 'Claude Code', 'left');
         registerContainer('b', 'Claude Code', 'right');
-        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Claude Code (Side Bar)');
-        expect(menus.actions.get(toggleCommandId('b'))?.label).to.equal('Claude Code (Secondary Side Bar)');
+        expect(menus.actions.get('a')?.label).to.equal('Claude Code (Side Bar)');
+        expect(menus.actions.get('b')?.label).to.equal('Claude Code (Secondary Side Bar)');
     });
 
     it('drops the suffix from the remaining container once the duplicate is removed', () => {
@@ -99,8 +98,8 @@ describe('PluginViewRegistry - view menu labels', () => {
 
         disposeB.dispose();
 
-        expect(menus.actions.get(toggleCommandId('a'))?.label).to.equal('Claude Code');
-        expect(menus.actions.has(toggleCommandId('b'))).to.equal(false);
+        expect(menus.actions.get('a')?.label).to.equal('Claude Code');
+        expect(menus.actions.has('b')).to.equal(false);
     });
 
 });
@@ -171,3 +170,46 @@ describe('PluginViewRegistry - welcome-only views', () => {
     });
 
 });
+
+describe('PluginViewRegistry - VS Code view commands', () => {
+
+    let registry: PluginViewRegistry;
+    let commands: Map<string, Command>;
+
+    const internals = (): {
+        doRegisterViewContainer(id: string, location: string, options: { label: string }): Disposable;
+    } => registry as unknown as {
+        doRegisterViewContainer(id: string, location: string, options: { label: string }): Disposable;
+    };
+
+    beforeEach(() => {
+        registry = new PluginViewRegistry();
+        commands = new Map();
+        (registry as unknown as { commands: unknown }).commands = {
+            registerCommand: (command: Command) => {
+                commands.set(command.id, command);
+                return Disposable.create(() => commands.delete(command.id));
+            }
+        };
+        (registry as unknown as { menus: unknown }).menus = new RecordingMenuModelRegistry();
+        (registry as unknown as { quickView: unknown }).quickView = { registerItem: () => Disposable.NULL };
+    });
+
+    it('registers the container id and the view focus and open commands once a view is added', () => {
+        const containerId = 'workbench.view.extension.sample';
+        internals().doRegisterViewContainer(containerId, 'left', { label: 'Sample' });
+        expect(commands.has(containerId)).to.equal(false);
+
+        const disposeView = registry.registerView('sample', { id: 'sample.view', name: 'Sample View' });
+
+        expect(commands.get(containerId)).to.include({ label: 'Toggle Sample', category: 'View' });
+        expect(commands.get('plugin.view-container.workbench.view.extension.sample.toggle')?.label).to.equal(undefined);
+        expect(commands.get('sample.view.focus')).to.include({ label: 'Focus on Sample View View', category: 'Sample' });
+        expect(commands.has('sample.view.open')).to.equal(true);
+
+        disposeView.dispose();
+        expect(commands.has('sample.view.focus')).to.equal(false);
+        expect(commands.has('sample.view.open')).to.equal(false);
+    });
+
+});

package/src/main/browser/view/plugin-view-registry.ts

@@ -347,15 +347,30 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
         return toDispose;
     }
 
+    /**
+     * Toggles the view container the same way as {@link AbstractViewContribution.toggleView}:
+     * collapses its panel if it is the visible tab, otherwise opens and activates it.
+     */
     protected async toggleViewContainer(id: string): Promise<void> {
-        let widget = await this.getPluginViewContainer(id);
-        if (widget && widget.isAttached) {
-            widget.dispose();
-        } else {
-            widget = await this.openViewContainer(id);
-            if (widget) {
-                this.shell.activateWidget(widget.id);
+        const existing = await this.getPluginViewContainer(id);
+        const tabBar = existing && this.shell.getTabBarFor(existing);
+        const area = existing && this.shell.getAreaFor(existing);
+        if (existing && tabBar && area && this.shell.isExpanded(area) && tabBar.currentTitle === existing.title) {
+            if (area === 'left' || area === 'right') {
+                await this.shell.collapsePanel(area);
+            } else if (area === 'bottom') {
+                // Don't collapse the bottom panel if it's currently split
+                if (this.shell.bottomAreaTabBars.length === 1) {
+                    await this.shell.collapsePanel('bottom');
+                }
+            } else {
+                existing.dispose();
             }
+            return;
+        }
+        const widget = await this.openViewContainer(id);
+        if (widget) {
+            await this.shell.activateWidget(widget.id);
         }
     }
 
@@ -369,18 +384,22 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 toDispose.push(Disposable.create(() => this.viewContainerClauseContexts.delete(id)));
             }
         }
-        const toggleCommandId = `plugin.view-container.${id}.toggle`;
         // Some plugins may register empty view containers.
         // We should not register commands for them immediately, as that leads to bad UX.
         // Instead, we register commands the first time we add a view to them.
         let activate = () => {
+            // Like VS Code, use the container's id, e.g. `workbench.view.extension.${id}`, as the command id
             toDispose.push(this.commands.registerCommand({
-                id: toggleCommandId,
+                id,
                 category: nls.localizeByDefault('View'),
                 label: nls.localizeByDefault('Toggle {0}', options.label)
             }, {
                 execute: () => this.toggleViewContainer(id)
             }));
+            // Kept for backward compatibility with keybindings that use the former command id
+            toDispose.push(this.commands.registerCommand({ id: `plugin.view-container.${id}.toggle` }, {
+                execute: () => this.toggleViewContainer(id)
+            }));
             toDispose.push(this.registerViewMenuAction(id, options.label));
             toDispose.push(this.quickView?.registerItem({
                 label: options.label,
@@ -486,7 +505,7 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
                 }
             }
             const disposable = this.menus.registerMenuAction(CommonMenus.VIEW_VIEWS, {
-                commandId: `plugin.view-container.${id}.toggle`,
+                commandId: id,
                 label: menuLabel,
                 when: containerInfo.when
             });
@@ -561,15 +580,24 @@ export class PluginViewRegistry implements FrontendApplicationContribution {
             when: view.when,
             open: () => this.openView(view.id, { activate: true })
         }));
-        toDispose.push(this.commands.registerCommand({ id: `${view.id}.focus` }, {
-            execute: async () => { await this.openView(view.id, { activate: true }); }
+        toDispose.push(this.commands.registerCommand({
+            id: `${view.id}.focus`,
+            category: this.viewContainers.get(viewContainerId)?.options.label,
+            label: nls.localizeByDefault('Focus on {0} View', view.name)
+        }, {
+            execute: async (options?: { preserveFocus?: boolean }) => { await this.openView(view.id, this.toOpenViewOptions(options)); },
+            isVisible: () => this.isViewVisible(view.id)
         }));
         toDispose.push(this.commands.registerCommand({ id: `${view.id}.open` }, {
-            execute: async () => { await this.openView(view.id, { activate: true }); }
+            execute: async (options?: { preserveFocus?: boolean }) => { await this.openView(view.id, this.toOpenViewOptions(options)); }
         }));
         return toDispose;
     }
 
+    protected toOpenViewOptions(options?: { preserveFocus?: boolean }): { activate?: boolean, reveal?: boolean } {
+        return options?.preserveFocus ? { reveal: true } : { activate: true };
+    }
+
     async resolveWebviewView(viewId: string, webview: WebviewView, cancellation: CancellationToken): Promise<void> {
         const resolver = this.webviewViewResolvers.get(viewId);
         if (resolver) {

package/src/plugin/plugin-context.ts

@@ -504,7 +504,7 @@ export function createAPIFactory(
                 preserveFocus?: boolean
             ): Promise<theia.TextEditor> {
                 let documentOptions: theia.TextDocumentShowOptions | undefined;
-                const uri: URI = documentArg instanceof URI ? documentArg : documentArg.uri;
+                const uri: URI = URI.isUri(documentArg) ? URI.revive(documentArg) : documentArg.uri;
                 if (typeof columnOrOptions === 'number') {
                     documentOptions = {
                         viewColumn: columnOrOptions

package/src/plugin/types-impl.spec.ts

@@ -65,6 +65,31 @@ describe('API Type Implementations:', () => {
                 types.URI.joinPath(types.URI.from({ scheme: 'myScheme', authority: 'authority', path: '/path', query: 'query', fragment: 'fragment' }), '/file.js').toString(),
                 'myScheme://authority/path/file.js?query#fragment');
         });
+
+        // Issue: #14976
+        it('should return an instance of the API URI class from every factory', () => {
+            const components = { scheme: 'file', authority: '', path: '/foo/bar.js', query: '', fragment: '' };
+            assert.ok(types.URI.parse('file:///foo/bar.js') instanceof types.URI, 'parse');
+            assert.ok(types.URI.file('/foo/bar.js') instanceof types.URI, 'file');
+            assert.ok(types.URI.revive(components) instanceof types.URI, 'revive');
+            assert.ok(types.URI.from(components) instanceof types.URI, 'from');
+            assert.ok(types.URI.joinPath(types.URI.file('/foo'), 'bar.js') instanceof types.URI, 'joinPath');
+            assert.ok(types.URI.file('/foo/bar.js').with({ fragment: 'baz' }) instanceof types.URI, 'with');
+        });
+
+        it('should build an equivalent URI with from()', () => {
+            const uriString = 'scheme://authority.com/foo/bar/zoz?query#fragment';
+            const uri = types.URI.parse(uriString);
+            const from = types.URI.from({
+                scheme: uri.scheme,
+                authority: uri.authority,
+                path: uri.path,
+                query: uri.query,
+                fragment: uri.fragment
+            });
+
+            assert.strictEqual(from.toString(), uriString);
+        });
     });
 
     describe('RelativePattern:', () => {

package/src/plugin/types-impl.ts

@@ -95,6 +95,13 @@ export class URI extends CodeURI implements theia.Uri {
         return new URI(CodeURI.file(path));
     }
 
+    /**
+     * Override to create the correct class.
+     */
+    static override from(components: { scheme: string; authority?: string; path?: string; query?: string; fragment?: string }): URI {
+        return new URI(CodeURI.from(components));
+    }
+
     /**
      * There is quite some magic in to vscode URI class related to
      * transferring via JSON.stringify(). Making the CodeURI instance