@theia/plugin-ext 1.76.0-next.0 → 1.76.0-next.14

package/src/main/browser/editors-and-documents-main.spec.ts

@@ -0,0 +1,140 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+
+import { expect } from 'chai';
+import { Emitter, URI } from '@theia/core';
+import { BaseWidget, Navigatable, Saveable, SaveableSource, Widget } from '@theia/core/lib/browser';
+import { SaveableService } from '@theia/core/lib/browser/saveable-service';
+import { EditorManager, EditorWidget } from '@theia/editor/lib/browser';
+import { EditorsAndDocumentsMain } from './editors-and-documents-main';
+
+disableJSDOM();
+
+class TestSaveable implements Saveable {
+    dirty = true;
+    readonly onDirtyChanged = new Emitter<void>().event;
+    readonly onContentChanged = new Emitter<void>().event;
+    saveCount = 0;
+
+    async save(): Promise<void> {
+        this.saveCount++;
+        this.dirty = false;
+    }
+}
+
+/** Navigatable to the resource, but with nothing to save. */
+class TestNavigatableWidget extends BaseWidget implements Navigatable {
+    constructor(private readonly uri: URI) {
+        super();
+    }
+
+    getResourceUri(): URI {
+        return this.uri;
+    }
+
+    createMoveToUri(): URI {
+        return this.uri;
+    }
+}
+
+/** Stands in for a `CustomEditorWidget`: saveable and navigatable, but not an `EditorWidget`. */
+class TestSaveableWidget extends TestNavigatableWidget implements SaveableSource {
+    readonly saveable = new TestSaveable();
+}
+
+function createEditorsAndDocumentsMain(
+    editor: EditorWidget | undefined,
+    widgets: Widget[]
+): EditorsAndDocumentsMain {
+    // Bypass the constructor's RPC/container wiring: `save` and `saveAs` only touch the
+    // editor manager, the shell and the saveable service.
+    const main = Object.create(EditorsAndDocumentsMain.prototype) as EditorsAndDocumentsMain;
+    const fields = main as unknown as Record<string, unknown>;
+    fields.editorManager = { getByUri: async () => editor } as unknown as EditorManager;
+    fields.shell = { widgets };
+    fields.saveResourceService = new SaveableService();
+    return main;
+}
+
+describe('EditorsAndDocumentsMain#save', () => {
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    const uri = new URI('custom-editor:/some/resource?viewType=test');
+
+    it('saves a saveable widget that the editor manager does not know', async () => {
+        const widget = new TestSaveableWidget(uri);
+        const main = createEditorsAndDocumentsMain(undefined, [widget]);
+
+        const saved = await main.save(uri);
+
+        expect(widget.saveable.saveCount).to.equal(1);
+        expect(saved?.toString()).to.equal(uri.toString());
+    });
+
+    it('prefers the text editor when the editor manager has one', async () => {
+        const editor = new TestSaveableWidget(uri);
+        const custom = new TestSaveableWidget(uri);
+        const main = createEditorsAndDocumentsMain(editor as unknown as EditorWidget, [custom]);
+
+        await main.save(uri);
+
+        expect(editor.saveable.saveCount).to.equal(1);
+        expect(custom.saveable.saveCount).to.equal(0);
+    });
+
+    it('leaves widgets bound to another resource alone', async () => {
+        const other = new TestSaveableWidget(new URI('custom-editor:/other/resource'));
+        const main = createEditorsAndDocumentsMain(undefined, [other]);
+
+        const saved = await main.save(uri);
+
+        expect(other.saveable.saveCount).to.equal(0);
+        expect(saved).to.be.undefined;
+    });
+
+    it('ignores a widget that is navigatable to the resource but not saveable', async () => {
+        const main = createEditorsAndDocumentsMain(undefined, [new TestNavigatableWidget(uri)]);
+
+        expect(await main.save(uri)).to.be.undefined;
+    });
+
+    it('resolves saveAs through the same fallback', async () => {
+        const widget = new TestSaveableWidget(uri);
+        const main = createEditorsAndDocumentsMain(undefined, [widget]);
+        const saveAsTargets: Widget[] = [];
+        // `SaveableService.canSaveAs` is unconditionally false on the base class, so the
+        // service is stubbed to reach the `saveAs` branch at all.
+        (main as unknown as Record<string, unknown>).saveResourceService = {
+            canSaveAs: (candidate: Widget) => candidate === widget,
+            saveAs: async (target: Widget) => { saveAsTargets.push(target); return uri; }
+        };
+
+        const saved = await main.saveAs(uri);
+
+        expect(saveAsTargets).to.deep.equal([widget]);
+        expect(saved?.toString()).to.equal(uri.toString());
+    });
+});

package/src/main/browser/editors-and-documents-main.ts

@@ -33,6 +33,7 @@ import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import { TextEditorMain } from './text-editor-main';
 import { DisposableCollection, Emitter, URI } from '@theia/core';
 import { EditorManager, EditorWidget } from '@theia/editor/lib/browser';
+import { ApplicationShell, NavigatableWidget, Saveable, Widget } from '@theia/core/lib/browser';
 import { SaveableService } from '@theia/core/lib/browser/saveable-service';
 import { TabsMainImpl } from './tabs/tabs-main';
 import { NotebookCellEditorService, NotebookEditorWidgetService } from '@theia/notebook/lib/browser';
@@ -48,6 +49,7 @@ export class EditorsAndDocumentsMain implements Disposable {
 
     private readonly modelService: EditorModelService;
     private readonly editorManager: EditorManager;
+    private readonly shell: ApplicationShell;
     private readonly saveResourceService: SaveableService;
     private readonly encodingRegistry: EncodingRegistry;
 
@@ -69,6 +71,7 @@ export class EditorsAndDocumentsMain implements Disposable {
         this.proxy = rpc.getProxy(MAIN_RPC_CONTEXT.EDITORS_AND_DOCUMENTS_EXT);
 
         this.editorManager = container.get(EditorManager);
+        this.shell = container.get(ApplicationShell);
         this.modelService = container.get(EditorModelService);
         this.saveResourceService = container.get(SaveableService);
         this.encodingRegistry = container.get(EncodingRegistry);
@@ -183,22 +186,31 @@ export class EditorsAndDocumentsMain implements Disposable {
     }
 
     async save(uri: URI): Promise<URI | undefined> {
-        const editor = await this.editorManager.getByUri(uri);
-        if (!editor) {
+        const widget = await this.getSaveTarget(uri);
+        if (!widget) {
             return undefined;
         }
-        return this.saveResourceService.save(editor);
+        return this.saveResourceService.save(widget);
     }
 
     async saveAs(uri: URI): Promise<URI | undefined> {
-        const editor = await this.editorManager.getByUri(uri);
-        if (!editor) {
+        const widget = await this.getSaveTarget(uri);
+        if (!widget) {
             return undefined;
         }
-        if (!this.saveResourceService.canSaveAs(editor)) {
+        if (!this.saveResourceService.canSaveAs(widget)) {
             return undefined;
         }
-        return this.saveResourceService.saveAs(editor);
+        return this.saveResourceService.saveAs(widget);
+    }
+
+    /**
+     * Resolve the widget holding `uri`, preferring a text editor. Custom editors and notebooks
+     * are not opened by the `EditorManager`, so they are only reachable through the shell.
+     */
+    protected async getSaveTarget(uri: URI): Promise<Widget | undefined> {
+        return await this.editorManager.getByUri(uri)
+            ?? this.shell.widgets.find(widget => Saveable.get(widget) && NavigatableWidget.getUri(widget)?.isEqual(uri));
     }
 
     saveAll(includeUntitled?: boolean): Promise<boolean> {

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

@@ -0,0 +1,101 @@
+// *****************************************************************************
+// Copyright (C) 2026 JuliaHub, 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+// `languages-main` transitively pulls in Monaco and several frontend modules that touch `document`
+// at module-load time.
+const disableJSDOM = enableJSDOM();
+import { expect } from 'chai';
+import * as monaco from '@theia/monaco-editor-core';
+import { mainWindow } from '@theia/monaco-editor-core/esm/vs/base/browser/window';
+import { URI } from '@theia/core/lib/common/uri';
+import { expectThrowsAsync } from '@theia/core/lib/common/test/expect';
+import { CellEditType, CellUri } from '@theia/notebook/lib/common';
+import { CellEditOperation } from '@theia/notebook/lib/browser/notebook-types';
+import type { NotebookModel } from '@theia/notebook/lib/browser/view-model/notebook-model';
+import { LanguagesMainImpl } from './languages-main';
+
+after(() => disableJSDOM());
+
+const notebookUri = new URI('file:///notebook.ipynb');
+const cellHandle = 3;
+const cellComponents = CellUri.generate(notebookUri, cellHandle).toComponents();
+
+type FakeNotebookModel = Pick<NotebookModel, 'getCellIndexByHandle' | 'applyEdits'> & {
+    edits: CellEditOperation[][];
+};
+
+function createNotebookModel(handles: number[]): FakeNotebookModel {
+    const edits: CellEditOperation[][] = [];
+    return {
+        edits,
+        getCellIndexByHandle: handle => handles.indexOf(handle),
+        applyEdits: applied => { edits.push(applied); }
+    };
+}
+
+/**
+ * Bypasses the constructor's RPC/container wiring.
+ */
+function createLanguagesMain(notebook?: FakeNotebookModel): LanguagesMainImpl {
+    const languagesMain = Object.create(LanguagesMainImpl.prototype) as LanguagesMainImpl;
+    (languagesMain as unknown as Record<string, unknown>).notebookService = {
+        getNotebookEditorModel: (uri: URI) => uri.toString() === notebookUri.toString() ? notebook : undefined
+    };
+    return languagesMain;
+}
+
+describe('LanguagesMainImpl#$changeLanguage', () => {
+
+    before(() => {
+        // Resolving a language id boots Monaco's standalone services, whose theme service reaches for
+        // DOM APIs JSDOM does not provide. Monaco captures its window at module load.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (global as any).CSS ??= { escape: (value: string) => value };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (mainWindow as any).matchMedia ??= () => ({ matches: false, addEventListener: () => { }, removeEventListener: () => { } });
+        monaco.languages.register({ id: 'julia' });
+    });
+
+    it('applies a cell language edit for a notebook cell', async () => {
+        const notebook = createNotebookModel([1, 2, cellHandle]);
+        const languagesMain = createLanguagesMain(notebook);
+
+        await languagesMain.$changeLanguage(cellComponents, 'julia');
+
+        expect(notebook.edits).to.deep.equal([[{ editType: CellEditType.CellLanguage, index: 2, language: 'julia' }]]);
+    });
+
+    it('rejects for a cell of a notebook that is not open', async () => {
+        const languagesMain = createLanguagesMain();
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'julia'), 'Invalid uri');
+    });
+
+    it('rejects for a cell handle the notebook does not know', async () => {
+        const languagesMain = createLanguagesMain(createNotebookModel([1, 2]));
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'julia'), 'Invalid uri');
+    });
+
+    it('rejects an unknown language id before touching the notebook', async () => {
+        const notebook = createNotebookModel([cellHandle]);
+        const languagesMain = createLanguagesMain(notebook);
+
+        await expectThrowsAsync(languagesMain.$changeLanguage(cellComponents, 'no-such-language'), /Unknown language ID/);
+        expect(notebook.edits).to.be.empty;
+    });
+});

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

@@ -88,6 +88,8 @@ import { CodeActionTriggerKind } from '../../plugin/types-impl';
 import { IReadonlyVSDataTransfer } from '@theia/monaco-editor-core/esm/vs/base/common/dataTransfer';
 import { FileUploadService } from '@theia/filesystem/lib/common/upload/file-upload';
 import { ILogger } from '@theia/core';
+import { NotebookService } from '@theia/notebook/lib/browser';
+import { CellEditType, CellUri } from '@theia/notebook/lib/common';
 
 @injectable()
 export class LanguagesMainImpl implements LanguagesMain, Disposable {
@@ -110,6 +112,9 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
     @inject(FileUploadService)
     protected readonly fileUploadService: FileUploadService;
 
+    @inject(NotebookService)
+    protected readonly notebookService: NotebookService;
+
     @inject(ILogger) @named('plugin-ext:LanguagesMainImpl')
     protected readonly logger: ILogger;
 
@@ -129,18 +134,35 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         return Promise.resolve(monaco.languages.getLanguages().map(l => l.id));
     }
 
-    $changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
-        const uri = monaco.Uri.revive(resource);
-        const model = monaco.editor.getModel(uri);
-        if (!model) {
-            return Promise.reject(new Error('Invalid uri'));
+    async $changeLanguage(resource: UriComponents, languageId: string): Promise<void> {
+        if (!monaco.languages.getEncodedLanguageId(languageId)) {
+            throw new Error(`Unknown language ID: ${languageId}`);
         }
-        const langId = monaco.languages.getEncodedLanguageId(languageId);
-        if (!langId) {
-            return Promise.reject(new Error(`Unknown language ID: ${languageId}`));
+        const cell = CellUri.parse(URI.fromComponents(resource));
+        if (cell) {
+            this.changeCellLanguage(cell.notebook, cell.handle, languageId);
+            return;
+        }
+        const model = monaco.editor.getModel(monaco.Uri.revive(resource));
+        if (!model) {
+            throw new Error('Invalid uri');
         }
         monaco.editor.setModelLanguage(model, languageId);
-        return Promise.resolve(undefined);
+    }
+
+    /**
+     * The cell model owns a cell's language; kernel selection, serialization, and the cell editor all follow it.
+     */
+    protected changeCellLanguage(notebookUri: URI, handle: number, languageId: string): void {
+        const notebook = this.notebookService.getNotebookEditorModel(notebookUri);
+        if (!notebook) {
+            throw new Error('Invalid uri');
+        }
+        const index = notebook.getCellIndexByHandle(handle);
+        if (index < 0) {
+            throw new Error('Invalid uri');
+        }
+        notebook.applyEdits([{ editType: CellEditType.CellLanguage, index, language: languageId }], true);
     }
 
     protected register(handle: number, service: Disposable): void {

package/src/plugin/decorations.spec.ts

@@ -0,0 +1,87 @@
+// *****************************************************************************
+// Copyright (C) 2026 Safi Seid-Ahmad, K2view 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-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Emitter } from '@theia/core/lib/common/event';
+import * as chai from 'chai';
+import * as theia from '@theia/plugin';
+import { PLUGIN_RPC_CONTEXT } from '../common/plugin-api-rpc';
+import { ProxyIdentifier, RPCProtocol } from '../common/rpc-protocol';
+import { DecorationsExtImpl } from './decorations';
+import { URI } from './types-impl';
+
+const expect = chai.expect;
+
+describe('DecorationsExtImpl', () => {
+
+    let onDidChangeCalls: (URI[] | null)[];
+    let decorationsExt: DecorationsExtImpl;
+    let onDidChangeFileDecorationsEmitter: Emitter<theia.Uri | theia.Uri[] | undefined>;
+
+    beforeEach(() => {
+        onDidChangeCalls = [];
+        const decorationsMainMock = {
+            $registerDecorationProvider: async () => undefined,
+            $unregisterDecorationProvider: () => undefined,
+            $onDidChange: (handle: number, resources: URI[] | null) => {
+                onDidChangeCalls.push(resources);
+            }
+        };
+        const rpcMock = {
+            getProxy<T>(proxyId: ProxyIdentifier<T>): T {
+                return (proxyId.id === PLUGIN_RPC_CONTEXT.DECORATIONS_MAIN.id
+                    ? decorationsMainMock
+                    : new Proxy({}, { get: () => () => undefined })) as unknown as T;
+            },
+            set<T, R extends T>(_identifier: ProxyIdentifier<T>, instance: R): R {
+                return instance;
+            },
+            dispose(): void { }
+        } as RPCProtocol;
+
+        decorationsExt = new DecorationsExtImpl(rpcMock);
+        onDidChangeFileDecorationsEmitter = new Emitter<theia.Uri | theia.Uri[] | undefined>();
+        decorationsExt.registerFileDecorationProvider({
+            onDidChangeFileDecorations: onDidChangeFileDecorationsEmitter.event,
+            provideFileDecoration: () => undefined
+        }, { id: 'test.plugin', name: 'test' });
+    });
+
+    it('forwards small change events unchanged', () => {
+        const uris = [1, 2, 3].map(i => URI.parse(`file:///project/f${i}.ts`));
+        onDidChangeFileDecorationsEmitter.fire(uris);
+        expect(onDidChangeCalls).to.have.lengthOf(1);
+        expect(onDidChangeCalls[0]).to.have.lengthOf(3);
+    });
+
+    it('forwards undefined change events as a flush', () => {
+        onDidChangeFileDecorationsEmitter.fire(undefined);
+        expect(onDidChangeCalls).to.have.lengthOf(1);
+        // eslint-disable-next-line no-null/no-null
+        expect(onDidChangeCalls[0]).to.equal(null);
+    });
+
+    it('sends a flush instead of truncating events exceeding the max event size', () => {
+        const uris = [];
+        for (let i = 0; i < 300; i++) {
+            uris.push(URI.parse(`file:///project/folder${i % 30}/f${i}.ts`));
+        }
+        onDidChangeFileDecorationsEmitter.fire(uris);
+        expect(onDidChangeCalls).to.have.lengthOf(1);
+        // eslint-disable-next-line no-null/no-null
+        expect(onDidChangeCalls[0]).to.equal(null);
+    });
+
+});

package/src/plugin/decorations.ts

@@ -26,7 +26,6 @@ import {
 import { RPCProtocol } from '../common/rpc-protocol';
 import { Disposable, FileDecoration, URI } from './types-impl';
 import { CancellationToken } from '@theia/core/lib/common';
-import { dirname } from 'path';
 import { PluginLogger } from './logger';
 
 /*---------------------------------------------------------------------------------------------
@@ -70,24 +69,12 @@ export class DecorationsExtImpl implements DecorationsExt {
                 return;
             }
 
-            // too many resources per event. pick one resource per folder, starting
-            // with parent folders
-            const mapped = array.map(uri => ({ uri, rank: (uri.path.match(/\//g) || []).length }));
-            const groups = groupBy(mapped, (a, b) => a.rank - b.rank);
-            const picked: URI[] = [];
-            outer: for (const uris of groups) {
-                let lastDirname: string | undefined;
-                for (const obj of uris) {
-                    const myDirname = dirname(obj.uri.path);
-                    if (lastDirname !== myDirname) {
-                        lastDirname = myDirname;
-                        if (picked.push(obj.uri) >= DecorationsExtImpl.maxEventSize) {
-                            break outer;
-                        }
-                    }
-                }
-            }
-            this.proxy.$onDidChange(handle, picked);
+            // too many resources per event: send a flush instead, so that the renderer
+            // drops cached data for this provider and re-fetches the decorations it
+            // displays on demand. Truncating the event (as upstream VS Code does by
+            // picking one resource per folder) loses decorations for the dropped
+            // resources, see https://github.com/eclipse-theia/theia/issues/17507
+            this.proxy.$onDidChange(handle, null);
         });
 
         return new Disposable(() => {
@@ -95,20 +82,6 @@ export class DecorationsExtImpl implements DecorationsExt {
             this.proxy.$unregisterDecorationProvider(handle);
             this.providersMap.delete(handle);
         });
-
-        function groupBy<T>(data: ReadonlyArray<T>, compareFn: (a: T, b: T) => number): T[][] {
-            const result: T[][] = [];
-            let currentGroup: T[] | undefined = undefined;
-            for (const element of data.slice(0).sort(compareFn)) {
-                if (!currentGroup || compareFn(currentGroup[0], element) !== 0) {
-                    currentGroup = [element];
-                    result.push(currentGroup);
-                } else {
-                    currentGroup.push(element);
-                }
-            }
-            return result;
-        }
     }
 
     async $provideDecorations(handle: number, requests: DecorationRequest[], token: CancellationToken): Promise<DecorationReply> {