deploy: current vibn theia state

Made-with: Cursor

packages/monaco/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/common/editor-preferences';
+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);
+    }
+}