@theia/monaco 1.63.0-next.52 → 1.63.0

package/src/browser/monaco-code-action-service.ts

@@ -0,0 +1,187 @@
+// *****************************************************************************
+// Copyright (C) 2025 STMicroelectronics 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 { CancellationToken } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { ILanguageFeaturesService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/languageFeatures';
+import { CodeActionKind, CodeActionSet, CodeActionTriggerSource } from '@theia/monaco-editor-core/esm/vs/editor/contrib/codeAction/common/types';
+import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from '@theia/monaco-editor-core/esm/vs/editor/contrib/codeAction/browser/codeAction';
+import { HierarchicalKind } from '@theia/monaco-editor-core/esm/vs/base/common/hierarchicalKind';
+import { EditorPreferences } from '@theia/editor/lib/browser';
+import { ITextModel } from '@theia/monaco-editor-core/esm/vs/editor/common/model';
+import { CodeActionProvider, CodeActionTriggerType } from '@theia/monaco-editor-core/esm/vs/editor/common/languages';
+import { IProgress } from '@theia/monaco-editor-core/esm/vs/platform/progress/common/progress';
+import { IInstantiationService } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/instantiation';
+
+export const MonacoCodeActionService = Symbol('MonacoCodeActionService');
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// Partially copied from https://github.com/microsoft/vscode/blob/f66e839a38dfe39ee66a86619a790f9c2336d698/src/vs/workbench/contrib/codeEditor/browser/saveParticipants.ts#L272
+
+export interface MonacoCodeActionService {
+    /**
+     * Gets all code actions that should be applied on save for the given model and language identifier.
+     * @param model The text model to get code actions for
+     * @param languageId The language identifier for preference lookup
+     * @param uri The URI string for preference scoping
+     * @param token Cancellation token
+     * @returns Array of code action sets to apply, or undefined if no actions should be applied
+     */
+    getAllCodeActionsOnSave(model: ITextModel, languageId: string, uri: string, token: CancellationToken): Promise<CodeActionSet[] | undefined>;
+
+    /**
+     * Applies the provided code actions for the given model.
+     * @param model The text model to apply code actions to
+     * @param codeActionSets Array of code action sets to apply
+     * @param token Cancellation token
+     */
+    applyCodeActions(model: ITextModel, codeActionSets: CodeActionSet[], token: CancellationToken): Promise<void>;
+
+    /**
+     * Applies all code actions that should be run on save for the given model and language identifier.
+     * This is a convenience method that retrieves all on-save code actions and applies them.
+     * @param model The text model to apply code actions to
+     * @param languageId The language identifier for preference lookup
+     * @param uri The URI string for preference scoping
+     * @param token Cancellation token
+     */
+    applyOnSaveCodeActions(model: ITextModel, languageId: string, uri: string, token: CancellationToken): Promise<void>;
+}
+
+@injectable()
+export class MonacoCodeActionServiceImpl implements MonacoCodeActionService {
+    @inject(EditorPreferences)
+    protected readonly editorPreferences: EditorPreferences;
+
+    async applyOnSaveCodeActions(model: ITextModel, languageId: string, uri: string, token: CancellationToken): Promise<void> {
+        const codeActionSets = await this.getAllCodeActionsOnSave(model, languageId, uri, token);
+
+        if (!codeActionSets || token.isCancellationRequested) {
+            return;
+        }
+
+        await this.applyCodeActions(model, codeActionSets, token);
+    }
+
+    async getAllCodeActionsOnSave(model: ITextModel, languageId: string, uri: string, token: CancellationToken): Promise<CodeActionSet[] | undefined> {
+        const setting = this.editorPreferences.get({
+            preferenceName: 'editor.codeActionsOnSave',
+            overrideIdentifier: languageId
+        }, undefined, uri);
+
+        if (!setting) {
+            return undefined;
+        }
+
+        const settingItems: string[] = Array.isArray(setting)
+            ? setting
+            : Object.keys(setting).filter(x => setting[x]);
+
+        const codeActionsOnSave = this.createCodeActionsOnSave(settingItems);
+
+        if (!codeActionsOnSave.length) {
+            return undefined;
+        }
+
+        if (!Array.isArray(setting)) {
+            codeActionsOnSave.sort((a, b) => {
+                if (CodeActionKind.SourceFixAll.contains(a)) {
+                    if (CodeActionKind.SourceFixAll.contains(b)) {
+                        return 0;
+                    }
+                    return -1;
+                }
+                if (CodeActionKind.SourceFixAll.contains(b)) {
+                    return 1;
+                }
+                return 0;
+            });
+        }
+
+        const excludedActions = Array.isArray(setting)
+            ? []
+            : Object.keys(setting)
+                .filter(x => setting[x] === false)
+                .map(x => new HierarchicalKind(x));
+
+        const codeActionSets: CodeActionSet[] = [];
+
+        for (const codeActionKind of codeActionsOnSave) {
+            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludedActions, token);
+
+            if (token.isCancellationRequested) {
+                actionsToRun.dispose();
+                break;
+            }
+
+            codeActionSets.push(actionsToRun);
+        }
+
+        return codeActionSets;
+    }
+
+    async applyCodeActions(model: ITextModel, codeActionSets: CodeActionSet[], token: CancellationToken): Promise<void> {
+
+        const instantiationService = StandaloneServices.get(IInstantiationService);
+
+        for (const codeActionSet of codeActionSets) {
+            if (token.isCancellationRequested) {
+                codeActionSet.dispose();
+                return;
+            }
+
+            try {
+                for (const action of codeActionSet.validActions) {
+                    await instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                }
+            } catch {
+                // Failure to apply a code action should not block other on save actions
+            } finally {
+                codeActionSet.dispose();
+            }
+        }
+    }
+
+    private createCodeActionsOnSave(settingItems: readonly string[]): HierarchicalKind[] {
+        const kinds = settingItems.map(x => new HierarchicalKind(x));
+
+        // Remove subsets
+        return kinds.filter(kind => kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind)));
+    }
+
+    private getActionsToRun(model: ITextModel, codeActionKind: HierarchicalKind, excludes: readonly HierarchicalKind[], token: CancellationToken): Promise<CodeActionSet> {
+        const { codeActionProvider } = StandaloneServices.get(ILanguageFeaturesService);
+
+        const progress: IProgress<CodeActionProvider> = {
+            report(item): void {
+                // empty
+            },
+        };
+
+        return getCodeActions(codeActionProvider, model, model.getFullModelRange(), {
+            type: CodeActionTriggerType.Auto,
+            triggerAction: CodeActionTriggerSource.OnSave,
+            filter: { include: codeActionKind, excludes: excludes, includeSourceActions: true },
+        }, progress, token);
+    }
+}

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

@@ -34,12 +34,17 @@ import { createTextBufferFactoryFromStream } from '@theia/monaco-editor-core/esm
 import { editorGeneratedPreferenceProperties } from '@theia/editor/lib/browser/editor-generated-preference-schema';
 import { MarkdownString } from '@theia/core/lib/common/markdown-rendering';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
+import { Listener, ListenerList } from '@theia/core';
 
 export {
     TextDocumentSaveReason
 };
 
-export type WillSaveMonacoModelListener = (model: MonacoEditorModel, token: CancellationToken, options?: SaveOptions) => Promise<void>;
+export interface WillSaveMonacoModelEvent {
+    model: MonacoEditorModel,
+    token: CancellationToken,
+    options?: SaveOptions
+}
 
 export interface MonacoModelContentChangedEvent {
     readonly model: MonacoEditorModel;
@@ -91,7 +96,8 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
 
     protected resourceVersion: ResourceVersion | undefined;
 
-    protected readonly willSaveModelListeners: WillSaveMonacoModelListener[] = [];
+    protected readonly onWillSaveModelListeners: ListenerList<WillSaveMonacoModelEvent, Promise<void>> = new ListenerList;
+    readonly onModelWillSaveModel = this.onWillSaveModelListeners.registration;
 
     constructor(
         protected readonly resource: Resource,
@@ -105,6 +111,7 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         this.toDispose.push(this.onDidChangeContentEmitter);
         this.toDispose.push(this.onDidSaveModelEmitter);
         this.toDispose.push(this.onDirtyChangedEmitter);
+        this.toDispose.push(this.onDidChangeEncodingEmitter);
         this.toDispose.push(this.onDidChangeValidEmitter);
         this.toDispose.push(Disposable.create(() => this.cancelSave()));
         this.toDispose.push(Disposable.create(() => this.cancelSync()));
@@ -582,20 +589,8 @@ export class MonacoEditorModel implements IResolvedTextEditorModel, TextEditorDo
         }
     }
 
-    registerWillSaveModelListener(listener: WillSaveMonacoModelListener): Disposable {
-        this.willSaveModelListeners.push(listener);
-        return Disposable.create(() => {
-            const index = this.willSaveModelListeners.indexOf(listener);
-            if (index >= 0) {
-                this.willSaveModelListeners.splice(index, 1);
-            }
-        });
-    }
-
     protected async fireWillSaveModel(token: CancellationToken, options?: SaveOptions): Promise<void> {
-        for (const listener of this.willSaveModelListeners) {
-            await listener(this, token, options);
-        }
+        await Listener.await({ model: this, token, options }, this.onWillSaveModelListeners);
     }
 
     protected fireDidSaveModel(): void {

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

@@ -45,6 +45,7 @@ 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';
+import { insertFinalNewline } from './monaco-utilities';
 
 export const MonacoEditorFactory = Symbol('MonacoEditorFactory');
 export interface MonacoEditorFactory {
@@ -226,7 +227,7 @@ export class MonacoEditorProvider {
         }));
         toDispose.push(editor.onLanguageChanged(() => this.updateMonacoEditorOptions(editor)));
         toDispose.push(editor.onDidChangeReadOnly(() => this.updateReadOnlyMessage(options, model.readOnly)));
-        toDispose.push(editor.document.registerWillSaveModelListener((_, token, o) => this.runSaveParticipants(editor, token, o)));
+        toDispose.push(editor.document.onModelWillSaveModel(e => this.runSaveParticipants(editor, e.token, e.options)));
         return editor;
     }
 
@@ -552,38 +553,13 @@ export class MonacoEditorProvider {
         if (shouldRemoveWhiteSpace) {
             await editor.runAction('editor.action.trimTrailingWhitespace');
         }
-        const insertFinalNewline = this.filePreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier }, undefined, uri);
-        if (insertFinalNewline) {
+        const shouldInsertFinalNewline = this.filePreferences.get({ preferenceName: 'files.insertFinalNewline', overrideIdentifier }, undefined, uri);
+        if (shouldInsertFinalNewline) {
             this.insertFinalNewline(model);
         }
     }
 
     protected insertFinalNewline(editorModel: MonacoEditorModel): void {
-        const model = editorModel.textEditorModel;
-        if (!model) {
-            return;
-        }
-
-        const lines = model?.getLineCount();
-        if (lines === 0) {
-            return;
-        }
-
-        const lastLine = model?.getLineContent(lines);
-        if (lastLine.trim() === '') {
-            return;
-        }
-
-        const lastLineMaxColumn = model?.getLineMaxColumn(lines);
-        const range = {
-            startLineNumber: lines,
-            startColumn: lastLineMaxColumn,
-            endLineNumber: lines,
-            endColumn: lastLineMaxColumn
-        };
-        model.applyEdits([{
-            range,
-            text: model?.getEOL()
-        }]);
+        insertFinalNewline(editorModel);
     }
 }

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

@@ -80,6 +80,7 @@ import { ILogService } from '@theia/monaco-editor-core/esm/vs/platform/log/commo
 import { DefaultContentHoverWidgetPatcher } from './default-content-hover-widget-patcher';
 import { MonacoWorkspaceContextService } from './monaco-workspace-context-service';
 import { MonacoCodeActionSaveParticipant } from './monaco-code-action-save-participant';
+import { MonacoCodeActionService, MonacoCodeActionServiceImpl } from './monaco-code-action-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(MonacoThemingService).toSelf().inSingletonScope();
@@ -92,6 +93,8 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(FrontendApplicationContribution).toService(MonacoFrontendApplicationContribution);
     bind(StylingParticipant).toService(MonacoFrontendApplicationContribution);
 
+    bind(MonacoCodeActionServiceImpl).toSelf().inSingletonScope();
+    bind(MonacoCodeActionService).toService(MonacoCodeActionServiceImpl);
     bind(MonacoCodeActionSaveParticipant).toSelf().inSingletonScope();
     bind(SaveParticipant).toService(MonacoCodeActionSaveParticipant);
 

package/src/browser/monaco-utilities.ts

@@ -0,0 +1,46 @@
+// *****************************************************************************
+// Copyright (C) 2025 EclipseSource GmbH.
+//
+// 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 { MonacoEditorModel } from './monaco-editor-model';
+
+export function insertFinalNewline(editorModel: MonacoEditorModel): void {
+    const model = editorModel.textEditorModel;
+    if (!model) {
+        return;
+    }
+
+    const lines = model?.getLineCount();
+    if (lines === 0) {
+        return;
+    }
+
+    const lastLine = model?.getLineContent(lines);
+    if (lastLine.trim() === '') {
+        return;
+    }
+
+    const lastLineMaxColumn = model?.getLineMaxColumn(lines);
+    const range = {
+        startLineNumber: lines,
+        startColumn: lastLineMaxColumn,
+        endLineNumber: lines,
+        endColumn: lastLineMaxColumn
+    };
+    model.applyEdits([{
+        range,
+        text: model?.getEOL()
+    }]);
+}