@theia/monaco 1.61.0 → 1.62.0

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

@@ -18,26 +18,23 @@
 import URI from '@theia/core/lib/common/uri';
 import { EditorPreferenceChange, EditorPreferences, TextEditor, DiffNavigator } from '@theia/editor/lib/browser';
 import { DiffUris } from '@theia/core/lib/browser/diff-uris';
-import { inject, injectable, named } from '@theia/core/shared/inversify';
-import { DisposableCollection, deepClone, Disposable } from '@theia/core/lib/common';
-import { TextDocumentSaveReason } from '@theia/core/shared/vscode-languageserver-protocol';
+import { inject, injectable, named, postConstruct } from '@theia/core/shared/inversify';
+import { DisposableCollection, deepClone, Disposable, CancellationToken } from '@theia/core/lib/common';
 import { MonacoDiffEditor } from './monaco-diff-editor';
 import { MonacoDiffNavigatorFactory } from './monaco-diff-navigator-factory';
 import { EditorServiceOverrides, MonacoEditor, MonacoEditorServices } from './monaco-editor';
-import { MonacoEditorModel, WillSaveMonacoModelEvent } from './monaco-editor-model';
+import { MonacoEditorModel, TextDocumentSaveReason } from './monaco-editor-model';
 import { MonacoWorkspace } from './monaco-workspace';
 import { ContributionProvider } from '@theia/core';
-import { KeybindingRegistry, OpenerService, open, WidgetOpenerOptions, FormatType } from '@theia/core/lib/browser';
+import { KeybindingRegistry, OpenerService, open, WidgetOpenerOptions, SaveOptions, FormatType } from '@theia/core/lib/browser';
 import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
 import { HttpOpenHandlerOptions } from '@theia/core/lib/browser/http-open-handler';
 import { MonacoToProtocolConverter } from './monaco-to-protocol-converter';
 import { ProtocolToMonacoConverter } from './protocol-to-monaco-converter';
-import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
 import * as monaco from '@theia/monaco-editor-core';
 import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
 import { IOpenerService, OpenExternalOptions, OpenInternalOptions } from '@theia/monaco-editor-core/esm/vs/platform/opener/common/opener';
 import { IKeybindingService } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding';
-import { timeoutReject } from '@theia/core/lib/common/promise-util';
 import { IContextMenuService } from '@theia/monaco-editor-core/esm/vs/platform/contextview/browser/contextView';
 import { KeyCodeChord } from '@theia/monaco-editor-core/esm/vs/base/common/keybindings';
 import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
@@ -46,6 +43,8 @@ import { IReference } from '@theia/monaco-editor-core/esm/vs/base/common/lifecyc
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 import { SimpleMonacoEditor } from './simple-monaco-editor';
 import { ICodeEditorWidgetOptions } from '@theia/monaco-editor-core/esm/vs/editor/browser/widget/codeEditor/codeEditorWidget';
+import { timeoutReject } from '@theia/core/lib/common/promise-util';
+import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
 
 export const MonacoEditorFactory = Symbol('MonacoEditorFactory');
 export interface MonacoEditorFactory {
@@ -53,6 +52,17 @@ export interface MonacoEditorFactory {
     create(model: MonacoEditorModel, defaultOptions: MonacoEditor.IOptions, defaultOverrides: EditorServiceOverrides): Promise<MonacoEditor>;
 }
 
+export const SaveParticipant = Symbol('SaveParticipant');
+
+export interface SaveParticipant {
+    readonly order: number;
+    applyChangesOnSave(
+        editor: MonacoEditor,
+        cancellationToken: CancellationToken,
+        options?: SaveOptions): Promise<void>;
+}
+export const SAVE_PARTICIPANT_DEFAULT_ORDER = 0;
+
 @injectable()
 export class MonacoEditorProvider {
 
@@ -68,9 +78,13 @@ export class MonacoEditorProvider {
 
     @inject(OpenerService)
     protected readonly openerService: OpenerService;
+    @inject(ContributionProvider)
+    @named(SaveParticipant)
+    protected readonly saveProviderContributions: ContributionProvider<SaveParticipant>;
 
     @inject(FileSystemPreferences)
     protected readonly filePreferences: FileSystemPreferences;
+    protected saveParticipants: SaveParticipant[];
 
     protected _current: MonacoEditor | undefined;
     /**
@@ -210,7 +224,7 @@ export class MonacoEditorProvider {
         }));
         toDispose.push(editor.onLanguageChanged(() => this.updateMonacoEditorOptions(editor)));
         toDispose.push(editor.onDidChangeReadOnly(() => this.updateReadOnlyMessage(options, model.readOnly)));
-        editor.document.onWillSaveModel(event => event.waitUntil(this.formatOnSave(editor, event)));
+        toDispose.push(editor.document.registerWillSaveModelListener((_, token, o) => this.runSaveParticipants(editor, token, o)));
         return editor;
     }
 
@@ -239,46 +253,6 @@ export class MonacoEditorProvider {
         }
     }
 
-    protected shouldFormat(editor: MonacoEditor, event: WillSaveMonacoModelEvent): boolean {
-        if (event.reason !== TextDocumentSaveReason.Manual) {
-            return false;
-        }
-        if (event.options?.formatType) {
-            switch (event.options.formatType) {
-                case FormatType.ON: return true;
-                case FormatType.OFF: return false;
-                case FormatType.DIRTY: return editor.document.dirty;
-            }
-        }
-        return true;
-    }
-
-    protected async formatOnSave(editor: MonacoEditor, event: WillSaveMonacoModelEvent): Promise<monaco.editor.IIdentifiedSingleEditOperation[]> {
-        if (!this.shouldFormat(editor, event)) {
-            return [];
-        }
-        const edits: monaco.editor.IIdentifiedSingleEditOperation[] = [];
-        const overrideIdentifier = editor.document.languageId;
-        const uri = editor.uri.toString();
-        const formatOnSave = this.editorPreferences.get({ preferenceName: 'editor.formatOnSave', overrideIdentifier }, undefined, uri);
-        if (formatOnSave) {
-            const formatOnSaveTimeout = this.editorPreferences.get({ preferenceName: 'editor.formatOnSaveTimeout', overrideIdentifier }, undefined, uri)!;
-            await Promise.race([
-                timeoutReject(formatOnSaveTimeout, `Aborted format on save after ${formatOnSaveTimeout}ms`),
-                editor.runAction('editor.action.formatDocument')
-            ]);
-        }
-        const shouldRemoveWhiteSpace = this.filePreferences.get({ preferenceName: 'files.trimTrailingWhitespace', overrideIdentifier }, undefined, uri);
-        if (shouldRemoveWhiteSpace) {
-            await editor.runAction('editor.action.trimTrailingWhitespace');
-        }
-        const insertFinalNewline = this.filePreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier }, undefined, uri);
-        if (insertFinalNewline) {
-            edits.push(...this.insertFinalNewline(editor));
-        }
-        return edits;
-    }
-
     protected get diffPreferencePrefixes(): string[] {
         return [...this.preferencePrefixes, 'diffEditor.'];
     }
@@ -497,20 +471,106 @@ export class MonacoEditorProvider {
         );
     }
 
-    protected insertFinalNewline(editor: MonacoEditor): monaco.editor.IIdentifiedSingleEditOperation[] {
-        const model = editor.document && editor.document.textEditorModel;
+    @postConstruct()
+    init(): void {
+        this.saveParticipants = this.saveProviderContributions.getContributions().slice().sort((left, right) => left.order - right.order);
+        this.registerSaveParticipant({
+            order: 1000,
+            applyChangesOnSave: (
+                editor: MonacoEditor,
+                cancellationToken: monaco.CancellationToken,
+                options: SaveOptions): Promise<void> => this.formatOnSave(editor, editor.document, cancellationToken, options)
+        });
+    }
+
+    registerSaveParticipant(saveParticipant: SaveParticipant): Disposable {
+        if (this.saveParticipants.find(value => value === saveParticipant)) {
+            throw new Error('Save participant already registered');
+        }
+        this.saveParticipants.push(saveParticipant);
+        this.saveParticipants.sort((left, right) => left.order - right.order);
+        return Disposable.create(() => {
+            const index = this.saveParticipants.indexOf(saveParticipant);
+            if (index >= 0) {
+                this.saveParticipants.splice(index, 1);
+            }
+        });
+    }
+
+    protected shouldFormat(model: MonacoEditorModel, options: SaveOptions): boolean {
+        if (options.saveReason !== TextDocumentSaveReason.Manual) {
+            return false;
+        }
+        switch (options.formatType) {
+            case FormatType.ON: return true;
+            case FormatType.OFF: return false;
+            case FormatType.DIRTY: return model.dirty;
+        }
+        return true;
+    }
+
+    async runSaveParticipants(editor: MonacoEditor, cancellationToken: CancellationToken, options?: SaveOptions): Promise<void> {
+        const initialState = editor.document.createSnapshot();
+        for (const participant of this.saveParticipants) {
+            if (cancellationToken.isCancellationRequested) {
+                break;
+            }
+            const snapshot = editor.document.createSnapshot();
+            try {
+                await participant.applyChangesOnSave(editor, cancellationToken, options);
+            } catch (e) {
+                console.error(e);
+                editor.document.applySnapshot(snapshot);
+            }
+        }
+        if (cancellationToken.isCancellationRequested) {
+            editor.document.applySnapshot(initialState);
+        }
+    }
+
+    protected async formatOnSave(
+        editor: MonacoEditor,
+        model: MonacoEditorModel,
+        cancellationToken: CancellationToken,
+        options: SaveOptions): Promise<void> {
+        if (!this.shouldFormat(model, options)) {
+            return;
+        }
+
+        const overrideIdentifier = model.languageId;
+        const uri = model.uri.toString();
+        const formatOnSave = this.editorPreferences.get({ preferenceName: 'editor.formatOnSave', overrideIdentifier }, undefined, uri);
+        if (formatOnSave) {
+            const formatOnSaveTimeout = this.editorPreferences.get({ preferenceName: 'editor.formatOnSaveTimeout', overrideIdentifier }, undefined, uri)!;
+            await Promise.race([
+                timeoutReject(formatOnSaveTimeout, `Aborted format on save after ${formatOnSaveTimeout}ms`),
+                await editor.runAction('editor.action.formatDocument')
+            ]);
+        }
+        const shouldRemoveWhiteSpace = this.filePreferences.get({ preferenceName: 'files.trimTrailingWhitespace', overrideIdentifier }, undefined, uri);
+        if (shouldRemoveWhiteSpace) {
+            await editor.runAction('editor.action.trimTrailingWhitespace');
+        }
+        const insertFinalNewline = this.filePreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier }, undefined, uri);
+        if (insertFinalNewline) {
+            this.insertFinalNewline(model);
+        }
+    }
+
+    protected insertFinalNewline(editorModel: MonacoEditorModel): void {
+        const model = editorModel.textEditorModel;
         if (!model) {
-            return [];
+            return;
         }
 
         const lines = model?.getLineCount();
         if (lines === 0) {
-            return [];
+            return;
         }
 
         const lastLine = model?.getLineContent(lines);
         if (lastLine.trim() === '') {
-            return [];
+            return;
         }
 
         const lastLineMaxColumn = model?.getLineMaxColumn(lines);
@@ -520,9 +580,9 @@ export class MonacoEditorProvider {
             endLineNumber: lines,
             endColumn: lastLineMaxColumn
         };
-        return [{
+        model.applyEdits([{
             range,
             text: model?.getEOL()
-        }];
+        }]);
     }
 }

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

@@ -14,7 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { injectable, inject, decorate } from '@theia/core/shared/inversify';
+import { injectable, inject, decorate, named } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { OpenerService, open, WidgetOpenMode, ApplicationShell, PreferenceService } from '@theia/core/lib/browser';
 import { EditorWidget, EditorOpenerOptions, EditorManager, CustomEditorWidget } from '@theia/editor/lib/browser';
@@ -27,6 +27,7 @@ import { StandaloneCodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/st
 import { ICodeEditor } from '@theia/monaco-editor-core/esm/vs/editor/browser/editorBrowser';
 import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
 import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { ContributionProvider } from '@theia/core';
 
 decorate(injectable(), StandaloneCodeEditorService);
 
@@ -36,6 +37,14 @@ export const VSCodeThemeService = Symbol('VSCodeThemeService');
 export const MonacoEditorServiceFactory = Symbol('MonacoEditorServiceFactory');
 export type MonacoEditorServiceFactoryType = (contextKeyService: IContextKeyService, themeService: IThemeService) => MonacoEditorService;
 
+/**
+ * contribution provider to extend the active editor handling to other editor types than just standalone editor widgets.
+ */
+export const ActiveMonacoEditorContribution = Symbol('ActiveMonacoEditorContribution');
+export interface ActiveMonacoEditorContribution {
+    getActiveEditor(): ICodeEditor | undefined;
+}
+
 @injectable()
 export class MonacoEditorService extends StandaloneCodeEditorService {
 
@@ -56,6 +65,9 @@ export class MonacoEditorService extends StandaloneCodeEditorService {
     @inject(PreferenceService)
     protected readonly preferencesService: PreferenceService;
 
+    @inject(ContributionProvider) @named(ActiveMonacoEditorContribution)
+    protected readonly activeMonacoEditorContribution: ContributionProvider<ActiveMonacoEditorContribution>;
+
     constructor(@inject(VSCodeContextKeyService) contextKeyService: IContextKeyService, @inject(VSCodeThemeService) themeService: IThemeService) {
         super(contextKeyService, themeService);
     }
@@ -63,7 +75,7 @@ export class MonacoEditorService extends StandaloneCodeEditorService {
     /**
      * Monaco active editor is either focused or last focused editor.
      */
-    override getActiveCodeEditor(): StandaloneCodeEditor | null {
+    override getActiveCodeEditor(): ICodeEditor | null {
         let editor = MonacoEditor.getCurrent(this.editors);
         if (!editor && CustomEditorWidget.is(this.shell.activeWidget)) {
             const model = this.shell.activeWidget.modelRef.object;
@@ -73,8 +85,17 @@ export class MonacoEditorService extends StandaloneCodeEditorService {
         }
         const candidate = editor?.getControl();
         // Since we extend a private super class, we have to check that the thing that matches the public interface also matches the private expectations the superclass.
+        if (candidate instanceof StandaloneCodeEditor) {
+            return candidate;
+        }
+        for (const activeEditorProvider of this.activeMonacoEditorContribution.getContributions()) {
+            const activeEditor = activeEditorProvider.getActiveEditor();
+            if (activeEditor) {
+                return activeEditor;
+            }
+        }
         /* eslint-disable-next-line no-null/no-null */
-        return candidate instanceof StandaloneCodeEditor ? candidate : null;
+        return null;
     }
 
     override async openCodeEditor(input: IResourceEditorInput, source: ICodeEditor | null, sideBySide?: boolean): Promise<ICodeEditor | null> {

package/src/browser/monaco-frontend-module.ts

@@ -25,13 +25,13 @@ import {
     WidgetStatusBarContribution
 } from '@theia/core/lib/browser';
 import { TextEditorProvider, DiffNavigatorProvider, TextEditor } from '@theia/editor/lib/browser';
-import { MonacoEditorProvider, MonacoEditorFactory } from './monaco-editor-provider';
+import { MonacoEditorProvider, MonacoEditorFactory, SaveParticipant } from './monaco-editor-provider';
 import { MonacoEditorMenuContribution } from './monaco-menu';
 import { MonacoEditorCommandHandlers } from './monaco-command';
 import { MonacoKeybindingContribution } from './monaco-keybinding';
 import { MonacoLanguages } from './monaco-languages';
 import { MonacoWorkspace } from './monaco-workspace';
-import { MonacoEditorService, MonacoEditorServiceFactory, VSCodeContextKeyService, VSCodeThemeService } from './monaco-editor-service';
+import { ActiveMonacoEditorContribution, MonacoEditorService, MonacoEditorServiceFactory, VSCodeContextKeyService, VSCodeThemeService } from './monaco-editor-service';
 import { MonacoTextModelService, MonacoEditorModelFactory, MonacoEditorModelFilter } from './monaco-text-model-service';
 import { MonacoContextMenuService } from './monaco-context-menu';
 import { MonacoOutlineContribution } from './monaco-outline-contribution';
@@ -79,6 +79,7 @@ import { ActiveMonacoUndoRedoHandler, FocusedMonacoUndoRedoHandler } from './mon
 import { ILogService } from '@theia/monaco-editor-core/esm/vs/platform/log/common/log';
 import { DefaultContentHoverWidgetPatcher } from './default-content-hover-widget-patcher';
 import { MonacoWorkspaceContextService } from './monaco-workspace-context-service';
+import { MonacoCodeActionSaveParticipant } from './monaco-code-action-save-participant';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoThemingService).toSelf().inSingletonScope();
@@ -91,6 +92,9 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(FrontendApplicationContribution).toService(MonacoFrontendApplicationContribution);
     bind(StylingParticipant).toService(MonacoFrontendApplicationContribution);
 
+    bind(MonacoCodeActionSaveParticipant).toSelf().inSingletonScope();
+    bind(SaveParticipant).toService(MonacoCodeActionSaveParticipant);
+
     bind(MonacoToProtocolConverter).toSelf().inSingletonScope();
     bind(ProtocolToMonacoConverter).toSelf().inSingletonScope();
 
@@ -107,6 +111,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoConfigurationService).toDynamicValue(({ container }) => createMonacoConfigurationService(container)).inSingletonScope();
 
     bind(MonacoBulkEditService).toSelf().inSingletonScope();
+    bindContributionProvider(bind, ActiveMonacoEditorContribution);
     bind(MonacoEditorServiceFactory).toFactory((context: interfaces.Context) => (contextKeyService: IContextKeyService, themeService: IThemeService) => {
         const child = context.container.createChild();
         child.bind(VSCodeContextKeyService).toConstantValue(contextKeyService);
@@ -121,6 +126,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bindContributionProvider(bind, MonacoEditorFactory);
     bindContributionProvider(bind, MonacoEditorModelFactory);
     bindContributionProvider(bind, MonacoEditorModelFilter);
+    bindContributionProvider(bind, SaveParticipant);
     bind(MonacoCommandService).toSelf().inTransientScope();
 
     bind(TextEditorProvider).toProvider(context =>

package/src/browser/monaco-menu.ts

@@ -40,16 +40,17 @@ export class MonacoEditorMenuContribution implements MenuContribution {
     ) { }
 
     registerMenus(registry: MenuModelRegistry): void {
+        registry.registerSubmenu(EDITOR_CONTEXT_MENU, 'Editor Context Menu');
         for (const item of MenuRegistry.getMenuItems(MenuId.EditorContext)) {
             if (!isIMenuItem(item)) {
                 continue;
             }
             const commandId = this.commands.validate(item.command.id);
             if (commandId) {
-                const menuPath = [...EDITOR_CONTEXT_MENU, (item.group || '')];
-                const coreId = MonacoCommands.COMMON_ACTIONS.get(commandId);
-                if (!(coreId && registry.getMenu(menuPath).children.some(it => it.id === coreId))) {
-                    // Don't add additional actions if the item is already registered with a core ID.
+                const nodeId = MonacoCommands.COMMON_ACTIONS.get(commandId) || commandId;
+                const menuPath = item.group ? [...EDITOR_CONTEXT_MENU, item.group] : EDITOR_CONTEXT_MENU;
+                if (registry.getMenuNode([...menuPath, nodeId])) {
+                    // Don't add additional actions if the item is already registered.
                     registry.registerMenuAction(menuPath, this.buildMenuAction(commandId, item));
                 }
             }

package/src/browser/monaco-workspace.ts

@@ -23,7 +23,7 @@ import { Emitter } from '@theia/core/lib/common/event';
 import { FileSystemPreferences } from '@theia/filesystem/lib/browser';
 import { EditorManager, EditorPreferences } from '@theia/editor/lib/browser';
 import { MonacoTextModelService } from './monaco-text-model-service';
-import { WillSaveMonacoModelEvent, MonacoEditorModel, MonacoModelContentChangedEvent } from './monaco-editor-model';
+import { MonacoEditorModel, MonacoModelContentChangedEvent } from './monaco-editor-model';
 import { MonacoEditor } from './monaco-editor';
 import { ProblemManager } from '@theia/markers/lib/browser';
 import { ArrayUtils } from '@theia/core/lib/common/types';
@@ -101,9 +101,6 @@ export class MonacoWorkspace {
     protected readonly onDidChangeTextDocumentEmitter = new Emitter<MonacoModelContentChangedEvent>();
     readonly onDidChangeTextDocument = this.onDidChangeTextDocumentEmitter.event;
 
-    protected readonly onWillSaveTextDocumentEmitter = new Emitter<WillSaveMonacoModelEvent>();
-    readonly onWillSaveTextDocument = this.onWillSaveTextDocumentEmitter.event;
-
     protected readonly onDidSaveTextDocumentEmitter = new Emitter<MonacoEditorModel>();
     readonly onDidSaveTextDocument = this.onDidSaveTextDocumentEmitter.event;
 
@@ -160,7 +157,6 @@ export class MonacoWorkspace {
         });
         model.onDidChangeContent(event => this.fireDidChangeContent(event));
         model.onDidSaveModel(() => this.fireDidSave(model));
-        model.onWillSaveModel(event => this.fireWillSave(event));
         model.onDirtyChanged(() => this.openEditorIfDirty(model));
         model.onDispose(() => this.fireDidClose(model));
     }
@@ -177,10 +173,6 @@ export class MonacoWorkspace {
         this.onDidChangeTextDocumentEmitter.fire(event);
     }
 
-    protected fireWillSave(event: WillSaveMonacoModelEvent): void {
-        this.onWillSaveTextDocumentEmitter.fire(event);
-    }
-
     protected fireDidSave(model: MonacoEditorModel): void {
         this.onDidSaveTextDocumentEmitter.fire(model);
     }