@theia/monaco 1.77.0-next.49 → 1.77.0-next.56

package/src/browser/monaco-diff-editor.ts

@@ -126,7 +126,7 @@ export class MonacoDiffEditor extends MonacoEditor {
     }
 
     override handleVisibilityChanged(nowVisible: boolean): void {
-        const isFirstShow = nowVisible && !this.savedViewState;
+        const isFirstShow = nowVisible && this.detachModelOnHide && !this.savedViewState;
         super.handleVisibilityChanged(nowVisible);
         if (isFirstShow) {
             this._diffEditor.revealFirstDiff();

package/src/browser/monaco-editor-provider.ts

@@ -311,7 +311,7 @@ export class MonacoEditorProvider {
     protected createOptions(prefixes: string[], uri: string, overrideIdentifier?: string): Record<string, any> {
         const flat: Record<string, any> = {};
         for (const preferenceName of Object.keys(this.editorPreferences)) {
-            flat[preferenceName] = (<any>this.editorPreferences).get({ preferenceName, overrideIdentifier }, undefined, uri);
+            flat[preferenceName] = (this.editorPreferences as any).get({ preferenceName, overrideIdentifier }, undefined, uri);
         }
         return Object.entries(flat).reduce((tree, [preferenceName, value]) => this.setOption(preferenceName, deepClone(value), prefixes, tree), {});
     }

package/src/browser/monaco-editor.spec.ts

@@ -0,0 +1,201 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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 * as sinon from 'sinon';
+import { Disposable, Event } from '@theia/core/lib/common';
+import URI from '@theia/core/lib/common/uri';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+import type { MonacoEditor as MonacoEditorType, MonacoEditorServices } from './monaco-editor';
+import type { MonacoEditorModel } from './monaco-editor-model';
+import type { MonacoDiffEditor as MonacoDiffEditorType } from './monaco-diff-editor';
+
+disableJSDOM();
+
+describe('MonacoEditor visibility', () => {
+    let MonacoEditor: typeof MonacoEditorType;
+    let MonacoDiffEditor: typeof MonacoDiffEditorType;
+
+    before(async () => {
+        disableJSDOM = enableJSDOM();
+        // Initialize baseline services before editor imports register additional services requiring browser CSS globals.
+        StandaloneServices.get(IInstantiationService);
+        ({ MonacoEditor } = await import('./monaco-editor'));
+        ({ MonacoDiffEditor } = await import('./monaco-diff-editor'));
+    });
+    after(() => disableJSDOM());
+
+    const model = {};
+    const viewState = {};
+    let editor: MonacoEditorType;
+    let control: ReturnType<typeof createControl>;
+
+    const createControl = (initiallyAttached = true) => {
+        let currentModel: object | undefined = initiallyAttached ? model : undefined;
+        return {
+            createContextKey: sinon.spy(),
+            setModel: sinon.spy((value: object | undefined) => currentModel = value),
+            getModel: () => currentModel,
+            saveViewState: sinon.stub().returns(viewState),
+            restoreViewState: sinon.spy(),
+            focus: sinon.spy(),
+            render: sinon.spy()
+        };
+    };
+
+    beforeEach(() => {
+        control = createControl();
+        editor = new class extends MonacoEditor {
+            constructor() {
+                super(new URI('file:///test.ts'), {
+                    textEditorModel: model,
+                    onDidChangeReadOnly: Event.None,
+                    onDidChangeEncoding: Event.None
+                } as unknown as MonacoEditorModel, document.createElement('div'), {} as MonacoEditorServices);
+            }
+
+            protected override create(): Disposable {
+                this.editor = control as unknown as typeof this.editor;
+                return Disposable.NULL;
+            }
+
+            protected override addHandlers(): void { }
+        }();
+    });
+    afterEach(() => editor.dispose());
+
+    it('should detach on hide and restore the model and view state without focusing on show', () => {
+        expect(editor.detachModelOnHide).to.be.true;
+        editor.handleVisibilityChanged(false);
+        expect(control.saveViewState.calledOnce).to.be.true;
+        expect(control.setModel.calledOnce).to.be.true;
+        expect(control.getModel()).to.not.exist;
+        expect(control.focus.called).to.be.false;
+
+        editor.handleVisibilityChanged(true);
+        expect(control.setModel.secondCall.calledWithExactly(model)).to.be.true;
+        expect(control.restoreViewState.calledOnceWithExactly(viewState)).to.be.true;
+        expect(control.focus.called).to.be.false;
+        expect(control.setModel.secondCall.calledBefore(control.restoreViewState.firstCall)).to.be.true;
+    });
+
+    it('should retain the model and view state without focusing when opting out', () => {
+        editor.detachModelOnHide = false;
+        for (let index = 0; index < 2; index++) {
+            editor.handleVisibilityChanged(false);
+            expect(control.getModel()).to.equal(model);
+            editor.handleVisibilityChanged(true);
+        }
+        expect(control.setModel.called).to.be.false;
+        expect(control.saveViewState.called).to.be.false;
+        expect(control.restoreViewState.called).to.be.false;
+        expect(control.focus.called).to.be.false;
+    });
+
+    it('should stage and unstage a hidden editor for preview without focusing it', () => {
+        editor.handleVisibilityChanged(false);
+        editor.stageForPreview();
+        expect(control.getModel()).to.equal(model);
+        expect(control.restoreViewState.calledOnceWithExactly(viewState)).to.be.true;
+        expect(control.render.calledOnceWithExactly(true)).to.be.true;
+        editor.unstagePreview();
+        expect(control.getModel()).to.not.exist;
+        expect(control.saveViewState.calledTwice).to.be.true;
+        expect(control.focus.called).to.be.false;
+    });
+
+    it('should keep the model attached when showing an editor staged for preview', () => {
+        editor.handleVisibilityChanged(false);
+        editor.stageForPreview();
+        editor.handleVisibilityChanged(true);
+        editor.unstagePreview();
+        expect(control.getModel()).to.equal(model);
+        expect(control.setModel.callCount).to.equal(3);
+        expect(control.focus.called).to.be.false;
+    });
+
+    it('should not stage or unstage an attached model when opting out', () => {
+        editor.detachModelOnHide = false;
+        editor.handleVisibilityChanged(false);
+        editor.stageForPreview();
+        editor.unstagePreview();
+        expect(control.getModel()).to.equal(model);
+        expect(control.setModel.called).to.be.false;
+        expect(control.saveViewState.called).to.be.false;
+        expect(control.restoreViewState.called).to.be.false;
+        expect(control.render.called).to.be.false;
+    });
+
+    it('should reveal the first diff only on the initial show by default', () => {
+        const diffControl = { ...control, revealFirstDiff: sinon.spy() };
+        const diffEditor = Object.assign(Object.create(MonacoDiffEditor.prototype) as MonacoDiffEditorType, {
+            _diffEditor: diffControl,
+            diffEditorModel: model,
+            detachModelOnHide: true
+        });
+        diffEditor.handleVisibilityChanged(true);
+        expect(diffControl.revealFirstDiff.calledOnce).to.be.true;
+        diffEditor.handleVisibilityChanged(false);
+        diffEditor.handleVisibilityChanged(true);
+        expect(diffControl.revealFirstDiff.calledOnce).to.be.true;
+        expect(control.setModel.callCount).to.equal(3);
+        expect(control.restoreViewState.secondCall.calledWithExactly(viewState)).to.be.true;
+    });
+
+    it('should initially attach a model-less diff editor without focusing when opting out', () => {
+        const diffControl = { ...createControl(false), revealFirstDiff: sinon.spy() };
+        const diffEditor = Object.assign(Object.create(MonacoDiffEditor.prototype) as MonacoDiffEditorType, {
+            _diffEditor: diffControl,
+            diffEditorModel: model,
+            detachModelOnHide: false
+        });
+        expect(diffControl.getModel()).to.be.undefined;
+        diffEditor.handleVisibilityChanged(true);
+        expect(diffControl.getModel()).to.equal(model);
+        expect(diffControl.setModel.calledOnceWithExactly(model)).to.be.true;
+
+        for (let index = 0; index < 2; index++) {
+            diffEditor.handleVisibilityChanged(false);
+            expect(diffControl.getModel()).to.equal(model);
+            diffEditor.handleVisibilityChanged(true);
+        }
+        expect(diffControl.setModel.calledOnceWithExactly(model)).to.be.true;
+        expect(diffControl.saveViewState.called).to.be.false;
+        expect(diffControl.restoreViewState.called).to.be.false;
+        expect(diffControl.revealFirstDiff.called).to.be.false;
+        expect(diffControl.focus.called).to.be.false;
+    });
+
+    it('should not reveal the first diff on each show when opting out', () => {
+        const diffControl = { ...control, revealFirstDiff: sinon.spy() };
+        const diffEditor = Object.assign(Object.create(MonacoDiffEditor.prototype) as MonacoDiffEditorType, {
+            _diffEditor: diffControl,
+            diffEditorModel: model,
+            detachModelOnHide: false
+        });
+        diffEditor.handleVisibilityChanged(false);
+        diffEditor.handleVisibilityChanged(true);
+        diffEditor.handleVisibilityChanged(false);
+        diffEditor.handleVisibilityChanged(true);
+        expect(diffControl.revealFirstDiff.called).to.be.false;
+        expect(control.setModel.called).to.be.false;
+        expect(control.restoreViewState.called).to.be.false;
+    });
+});

package/src/browser/monaco-editor.ts

@@ -106,6 +106,9 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
         return instance;
     }
 
+    /** Whether hiding the editor should detach its model and save its view state for restoration on show. */
+    detachModelOnHide = true;
+
     protected readonly toDispose = new DisposableCollection();
 
     protected readonly autoSizing: boolean;
@@ -265,12 +268,15 @@ export class MonacoEditor extends MonacoEditorServices implements TextEditor {
     }
 
     handleVisibilityChanged(nowVisible: boolean): void {
+        this._stagedForPreview = false;
         if (nowVisible) {
-            this._stagedForPreview = false;
-            this.baseEditor.setModel(this.baseModel);
-            this.baseEditor.restoreViewState(this.savedViewState);
-        } else {
-            this._stagedForPreview = false;
+            if (this.detachModelOnHide || !this.baseEditor.getModel()) {
+                this.baseEditor.setModel(this.baseModel);
+            }
+            if (this.detachModelOnHide) {
+                this.baseEditor.restoreViewState(this.savedViewState);
+            }
+        } else if (this.detachModelOnHide) {
             this.savedViewState = this.baseEditor.saveViewState();
 
             // eslint-disable-next-line no-null/no-null

package/src/browser/monaco-outline-contribution.ts

@@ -301,6 +301,7 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
             iconClass: monaco.languages.SymbolKind[symbol.kind].toString().toLowerCase(),
             name: this.getName(symbol),
             detail: this.getDetail(symbol),
+            deprecated: this.isDeprecated(symbol),
             parent,
             uri,
             range: this.getNameRange(symbol),
@@ -324,6 +325,10 @@ export class MonacoOutlineContribution implements FrontendApplicationContributio
         return symbol.detail;
     }
 
+    protected isDeprecated(symbol: monaco.languages.DocumentSymbol): boolean {
+        return !!symbol.tags?.includes(monaco.languages.SymbolTag.Deprecated);
+    }
+
     protected createId(name: string, ids: Map<string, number>): string {
         const counter = ids.get(name);
         const index = typeof counter === 'number' ? counter + 1 : 0;
@@ -370,6 +375,8 @@ export interface MonacoOutlineSymbolInformationNode extends OutlineSymbolInforma
     range: Range;
     fullRange: Range;
     detail?: string;
+    /** Whether the symbol is tagged as deprecated. */
+    deprecated?: boolean;
     parent: MonacoOutlineSymbolInformationNode | undefined;
     children: MonacoOutlineSymbolInformationNode[];
 }

package/src/browser/monaco-outline-decorator.spec.ts

@@ -0,0 +1,96 @@
+// *****************************************************************************
+// Copyright (C) 2026 Vinay Kaushal 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';
+import { expect } from 'chai';
+import URI from '@theia/core/lib/common/uri';
+import type { CompositeTreeNode, Tree } from '@theia/core/lib/browser/tree';
+import type { TreeDecoration } from '@theia/core/lib/browser/tree/tree-decorator';
+import type * as monaco from '@theia/monaco-editor-core';
+import type { MonacoOutlineSymbolInformationNode } from './monaco-outline-contribution';
+
+describe('MonacoOutlineDecorator', () => {
+
+    // The outline code uses the full monaco API at runtime. Load it only once this suite runs: loading it while
+    // the spec files are collected registers monaco's editor contributions before monaco-init.spec initializes
+    // the standalone services, which then need browser APIs that JSDOM does not provide.
+    let monacoApi: typeof monaco;
+    let outline: typeof import('./monaco-outline-contribution');
+    let decorator: typeof import('./monaco-outline-decorator');
+    let disableJSDOM: () => void;
+
+    before(async () => {
+        disableJSDOM = enableJSDOM();
+        // @lumino/dragdrop (pulled in transitively) extends the DragEvent DOM global at
+        // module load, which JSDOM does not provide; stub it so the import succeeds.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        if (!(global as any).DragEvent) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (global as any).DragEvent = class DragEvent extends (global as any).Event { };
+        }
+        monacoApi = await import('@theia/monaco-editor-core');
+        outline = await import('./monaco-outline-contribution');
+        decorator = await import('./monaco-outline-decorator');
+    });
+    after(() => disableJSDOM());
+
+    const range: monaco.IRange = { startLineNumber: 1, startColumn: 1, endLineNumber: 1, endColumn: 10 };
+
+    function symbol(name: string, detail: string, deprecated = false): monaco.languages.DocumentSymbol {
+        const tags = deprecated ? [monacoApi.languages.SymbolTag.Deprecated] : [];
+        return { name, detail, kind: monacoApi.languages.SymbolKind.Method, tags, range, selectionRange: range };
+    }
+
+    function createNode(documentSymbol: monaco.languages.DocumentSymbol): MonacoOutlineSymbolInformationNode {
+        return new outline.MonacoOutlineContribution()['createNode'](new URI('file:///test.ts'), documentSymbol, new Map());
+    }
+
+    function decorate(...nodes: MonacoOutlineSymbolInformationNode[]): Promise<Map<string, TreeDecoration.Data>> {
+        const root: CompositeTreeNode = { id: 'root', name: 'root', parent: undefined, children: nodes };
+        return new decorator.MonacoOutlineDecorator().decorations({ root } as unknown as Tree);
+    }
+
+    it('marks a symbol tagged as deprecated', () => {
+        expect(createNode(symbol('old', '', true)).deprecated).to.equal(true);
+        expect(createNode(symbol('current', '')).deprecated).to.equal(false);
+    });
+
+    it('strikes through a deprecated symbol', async () => {
+        const node = createNode(symbol('old', '', true));
+
+        const decorations = await decorate(node);
+
+        expect(decorations.get(node.id)?.fontData).to.deep.equal({ style: 'line-through' });
+        expect(decorations.get(node.id)?.captionSuffixes).to.equal(undefined);
+    });
+
+    it('keeps the detail suffix of a deprecated symbol', async () => {
+        const node = createNode(symbol('old', '(): void', true));
+
+        const decorations = await decorate(node);
+
+        expect(decorations.get(node.id)?.fontData).to.deep.equal({ style: 'line-through' });
+        expect(decorations.get(node.id)?.captionSuffixes?.map(suffix => suffix.data)).to.deep.equal(['(): void']);
+    });
+
+    it('does not decorate a symbol that is neither deprecated nor has a detail', async () => {
+        const node = createNode(symbol('current', ''));
+
+        const decorations = await decorate(node);
+
+        expect(decorations.has(node.id)).to.equal(false);
+    });
+});

package/src/browser/monaco-outline-decorator.ts

@@ -43,7 +43,7 @@ export class MonacoOutlineDecorator implements TreeDecorator {
         }
 
         for (const treeNode of new DepthFirstTreeIterator(tree.root)) {
-            if (MonacoOutlineSymbolInformationNode.is(treeNode) && treeNode.detail) {
+            if (MonacoOutlineSymbolInformationNode.is(treeNode) && (treeNode.detail || treeNode.deprecated)) {
                 result.set(treeNode.id, this.toDecoration(treeNode));
             }
         }
@@ -52,15 +52,18 @@ export class MonacoOutlineDecorator implements TreeDecorator {
     }
 
     protected toDecoration(node: MonacoOutlineSymbolInformationNode): TreeDecoration.Data {
-        const captionSuffixes: TreeDecoration.CaptionAffix[] = [{
-            data: (node.detail || ''),
+        const captionSuffixes: TreeDecoration.CaptionAffix[] | undefined = node.detail ? [{
+            data: node.detail,
             fontData: {
                 color: 'var(--theia-descriptionForeground)',
             }
-        }];
+        }] : undefined;
+        // Like VS Code, strike through the names of deprecated symbols.
+        const fontData: TreeDecoration.FontData | undefined = node.deprecated ? { style: 'line-through' } : undefined;
 
         return {
-            captionSuffixes
+            captionSuffixes,
+            fontData
         };
     }
 }

package/src/browser/monaco-quick-input-service.ts

@@ -114,6 +114,11 @@ export class MonacoQuickInputImplementation implements IQuickInputService {
 
     protected container: HTMLElement;
 
+    /**
+     * The element that had focus when the quick input was shown. Cleared when the quick input is hidden.
+     */
+    previousFocusElement: HTMLElement | undefined;
+
     protected inQuickOpen: IContextKey<boolean>;
 
     /**
@@ -144,11 +149,17 @@ export class MonacoQuickInputImplementation implements IQuickInputService {
         this.scopedInQuickOpen = this.scopedContextKeyService.createKey<boolean>('inQuickOpen', false);
 
         this.controller.onShow(() => {
+            // `onShow` fires before focus moves into the quick input, and again whenever it switches to another picker.
+            const activeElement = document.activeElement;
+            if (activeElement instanceof HTMLElement && !this.container.contains(activeElement)) {
+                this.previousFocusElement = activeElement;
+            }
             this.container.style.top = this.shell.mainPanel.node.getBoundingClientRect().top + 'px';
             this.inQuickOpen.set(true);
             this.scopedInQuickOpen.set(true);
         });
         this.controller.onHide(() => {
+            this.previousFocusElement = undefined;
             this.inQuickOpen.set(false);
             this.scopedInQuickOpen.set(false);
         });
@@ -407,6 +418,7 @@ export class MonacoQuickInputService implements QuickInputService {
 
     get onShow(): Event<void> { return this.monacoService.onShow; }
     get onHide(): Event<void> { return this.monacoService.onHide; }
+    get previousFocusElement(): HTMLElement | undefined { return this.monacoService.previousFocusElement; }
 
     open(filter: string): void {
         this.monacoService.open(filter);