@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile.js

@@ -0,0 +1,75 @@
+import { localizeWithPath } from '../../../../../../nls.js';
+import { registerAction2, Action2 } from '../../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { NotebookSetting } from '../../../common/notebookCommon.js';
+var NotebookProfileType;
+( (function(NotebookProfileType) {
+    NotebookProfileType["default"] = "default";
+    NotebookProfileType["jupyter"] = "jupyter";
+    NotebookProfileType["colab"] = "colab";
+})(NotebookProfileType || (NotebookProfileType = {})));
+const profiles = {
+    [NotebookProfileType.default]: {
+        [NotebookSetting.focusIndicator]: 'gutter',
+        [NotebookSetting.insertToolbarLocation]: 'both',
+        [NotebookSetting.globalToolbar]: true,
+        [NotebookSetting.cellToolbarLocation]: { default: 'right' },
+        [NotebookSetting.compactView]: true,
+        [NotebookSetting.showCellStatusBar]: 'visible',
+        [NotebookSetting.consolidatedRunButton]: true,
+        [NotebookSetting.undoRedoPerCell]: false
+    },
+    [NotebookProfileType.jupyter]: {
+        [NotebookSetting.focusIndicator]: 'gutter',
+        [NotebookSetting.insertToolbarLocation]: 'notebookToolbar',
+        [NotebookSetting.globalToolbar]: true,
+        [NotebookSetting.cellToolbarLocation]: { default: 'left' },
+        [NotebookSetting.compactView]: true,
+        [NotebookSetting.showCellStatusBar]: 'visible',
+        [NotebookSetting.consolidatedRunButton]: false,
+        [NotebookSetting.undoRedoPerCell]: true
+    },
+    [NotebookProfileType.colab]: {
+        [NotebookSetting.focusIndicator]: 'border',
+        [NotebookSetting.insertToolbarLocation]: 'betweenCells',
+        [NotebookSetting.globalToolbar]: false,
+        [NotebookSetting.cellToolbarLocation]: { default: 'right' },
+        [NotebookSetting.compactView]: false,
+        [NotebookSetting.showCellStatusBar]: 'hidden',
+        [NotebookSetting.consolidatedRunButton]: true,
+        [NotebookSetting.undoRedoPerCell]: false
+    }
+};
+async function applyProfile(configService, profile) {
+    const promises = [];
+    for (const settingKey in profile) {
+        promises.push(configService.updateValue(settingKey, profile[settingKey]));
+    }
+    await Promise.all(promises);
+}
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.setProfile',
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/profile/notebookProfile',
+                'setProfileTitle',
+                "Set Profile"
+            ))
+        });
+    }
+    async run(accessor, args) {
+        if (!isSetProfileArgs(args)) {
+            return;
+        }
+        const configService = accessor.get(IConfigurationService);
+        return applyProfile(configService, profiles[args.profile]);
+    }
+});
+function isSetProfileArgs(args) {
+    const setProfileArgs = args;
+    return setProfileArgs.profile === NotebookProfileType.colab ||
+        setProfileArgs.profile === NotebookProfileType.default ||
+        setProfileArgs.profile === NotebookProfileType.jupyter;
+}
+export { NotebookProfileType };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants.js

@@ -0,0 +1,515 @@
+import { __decorate, __param } from '../../../../../../../../../external/tslib/tslib.es6.js';
+import { HierarchicalKind } from '../../../../../../base/common/hierarchicalKind.js';
+import { Disposable, DisposableStore } from '../../../../../../base/common/lifecycle.js';
+import { isEqual } from '../../../../../../base/common/resources.js';
+import { ResourceTextEdit, IBulkEditService } from '../../../../../../editor/browser/services/bulkEditService.js';
+import { trimTrailingWhitespace } from '../../../../../../editor/common/commands/trimTrailingWhitespaceCommand.js';
+import { Position } from '../../../../../../editor/common/core/position.js';
+import { Range } from '../../../../../../editor/common/core/range.js';
+import { IEditorWorkerService } from '../../../../../../editor/common/services/editorWorker.js';
+import { ILanguageFeaturesService } from '../../../../../../editor/common/services/languageFeatures.js';
+import { ITextModelService } from '../../../../../../editor/common/services/resolverService.js';
+import { applyCodeAction, ApplyCodeActionReason, getCodeActions } from '../../../../../../editor/contrib/codeAction/browser/codeAction.js';
+import { CodeActionKind, CodeActionTriggerSource } from '../../../../../../editor/contrib/codeAction/common/types.js';
+import { getDocumentFormattingEditsUntilResult } from '../../../../../../editor/contrib/format/browser/format.js';
+import { SnippetController2 } from '../../../../../../editor/contrib/snippet/browser/snippetController2.js';
+import { localizeWithPath } from '../../../../../../nls.js';
+import { IConfigurationService } from '../../../../../../platform/configuration/common/configuration.js';
+import { IInstantiationService } from '../../../../../../platform/instantiation/common/instantiation.js';
+import { ILogService } from '../../../../../../platform/log/common/log.js';
+import { Registry } from '../../../../../../platform/registry/common/platform.js';
+import { IWorkspaceTrustManagementService } from '../../../../../../platform/workspace/common/workspaceTrust.js';
+import { Extensions } from '../../../../../common/contributions.js';
+import { getNotebookEditorFromEditorPane } from '../../notebookBrowser.js';
+import { NotebookSetting, CellKind } from '../../../common/notebookCommon.js';
+import { NotebookFileWorkingCopyModel } from '../../../common/notebookEditorModel.js';
+import { IEditorService } from '../../../../../services/editor/common/editorService.js';
+import { IWorkingCopyFileService } from '../../../../../services/workingCopy/common/workingCopyFileService.js';
+let FormatOnSaveParticipant = class FormatOnSaveParticipant {
+    constructor(editorWorkerService, languageFeaturesService, textModelService, bulkEditService, configurationService) {
+        this.editorWorkerService = editorWorkerService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.textModelService = textModelService;
+        this.bulkEditService = bulkEditService;
+        this.configurationService = configurationService;
+    }
+    async participate(workingCopy, context, progress, token) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        if (context.reason === 2 ) {
+            return undefined;
+        }
+        const enabled = this.configurationService.getValue(NotebookSetting.formatOnSave);
+        if (!enabled) {
+            return undefined;
+        }
+        const notebook = workingCopy.model.notebookModel;
+        progress.report({ message: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+            'notebookFormatSave.formatting',
+            "Formatting"
+        )) });
+        const disposable = ( new DisposableStore());
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                const ref = await this.textModelService.createModelReference(cell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const formatEdits = await getDocumentFormattingEditsUntilResult(this.editorWorkerService, this.languageFeaturesService, model, model.getOptions(), token);
+                const edits = [];
+                if (formatEdits) {
+                    edits.push(...( formatEdits.map(edit => ( new ResourceTextEdit(model.uri, edit, model.getVersionId())))));
+                    return edits;
+                }
+                return [];
+            })));
+            await this.bulkEditService.apply( allCellEdits.flat(), { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'formatNotebook',
+                "Format Notebook"
+            )), code: 'undoredo.formatNotebook', });
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+FormatOnSaveParticipant = ( __decorate([
+    ( __param(0, IEditorWorkerService)),
+    ( __param(1, ILanguageFeaturesService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService)),
+    ( __param(4, IConfigurationService))
+], FormatOnSaveParticipant));
+let TrimWhitespaceParticipant = class TrimWhitespaceParticipant {
+    constructor(configurationService, editorService, textModelService, bulkEditService) {
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.textModelService = textModelService;
+        this.bulkEditService = bulkEditService;
+    }
+    async participate(workingCopy, context, progress, _token) {
+        const trimTrailingWhitespaceOption = this.configurationService.getValue('files.trimTrailingWhitespace');
+        const trimInRegexAndStrings = this.configurationService.getValue('files.trimTrailingWhitespaceInRegexAndStrings');
+        if (trimTrailingWhitespaceOption) {
+            await this.doTrimTrailingWhitespace(workingCopy, context.reason === 2 , trimInRegexAndStrings, progress);
+        }
+    }
+    async doTrimTrailingWhitespace(workingCopy, isAutoSaved, trimInRegexesAndStrings, progress) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        const notebook = workingCopy.model.notebookModel;
+        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
+        let cursors = [];
+        let prevSelection = [];
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                if (cell.cellKind !== CellKind.Code) {
+                    return [];
+                }
+                const ref = await this.textModelService.createModelReference(cell.uri);
+                disposable.add(ref);
+                const model = ref.object.textEditorModel;
+                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
+                if (isActiveCell) {
+                    prevSelection = activeCellEditor.getSelections() ?? [];
+                    if (isAutoSaved) {
+                        cursors = ( prevSelection.map(s => s.getPosition()));
+                        const snippetsRange = SnippetController2.get(activeCellEditor)?.getSessionEnclosingRange();
+                        if (snippetsRange) {
+                            for (let lineNumber = snippetsRange.startLineNumber; lineNumber <= snippetsRange.endLineNumber; lineNumber++) {
+                                cursors.push(( new Position(lineNumber, model.getLineMaxColumn(lineNumber))));
+                            }
+                        }
+                    }
+                }
+                const ops = trimTrailingWhitespace(model, cursors, trimInRegexesAndStrings);
+                if (!ops.length) {
+                    return [];
+                }
+                return ( ops.map(op => ( new ResourceTextEdit(model.uri, { ...op, text: op.text || '' }, model.getVersionId()))));
+            })));
+            const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'trimNotebookWhitespace',
+                "Notebook Trim Trailing Whitespace"
+            )), code: 'undoredo.notebookTrimTrailingWhitespace' });
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+TrimWhitespaceParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITextModelService)),
+    ( __param(3, IBulkEditService))
+], TrimWhitespaceParticipant));
+let TrimFinalNewLinesParticipant = class TrimFinalNewLinesParticipant {
+    constructor(configurationService, editorService, bulkEditService) {
+        this.configurationService = configurationService;
+        this.editorService = editorService;
+        this.bulkEditService = bulkEditService;
+    }
+    async participate(workingCopy, context, progress, _token) {
+        if (this.configurationService.getValue('files.trimFinalNewlines')) {
+            await this.doTrimFinalNewLines(workingCopy, context.reason === 2 , progress);
+        }
+    }
+    findLastNonEmptyLine(textBuffer) {
+        for (let lineNumber = textBuffer.getLineCount(); lineNumber >= 1; lineNumber--) {
+            const lineLength = textBuffer.getLineLength(lineNumber);
+            if (lineLength) {
+                return lineNumber;
+            }
+        }
+        return 0;
+    }
+    async doTrimFinalNewLines(workingCopy, isAutoSaved, progress) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        const notebook = workingCopy.model.notebookModel;
+        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                if (cell.cellKind !== CellKind.Code) {
+                    return;
+                }
+                let cannotTouchLineNumber = 0;
+                const isActiveCell = (activeCellEditor && ( cell.uri.toString()) === activeCellEditor.getModel()?.uri.toString());
+                if (isAutoSaved && isActiveCell) {
+                    const selections = activeCellEditor.getSelections() ?? [];
+                    for (const sel of selections) {
+                        cannotTouchLineNumber = Math.max(cannotTouchLineNumber, sel.selectionStartLineNumber);
+                    }
+                }
+                const textBuffer = cell.textBuffer;
+                const lastNonEmptyLine = this.findLastNonEmptyLine(textBuffer);
+                const deleteFromLineNumber = Math.max(lastNonEmptyLine + 1, cannotTouchLineNumber + 1);
+                if (deleteFromLineNumber > textBuffer.getLineCount()) {
+                    return;
+                }
+                const deletionRange = ( new Range(
+                    deleteFromLineNumber,
+                    1,
+                    textBuffer.getLineCount(),
+                    textBuffer.getLineLastNonWhitespaceColumn(textBuffer.getLineCount())
+                ));
+                if (deletionRange.isEmpty()) {
+                    return;
+                }
+                return ( new ResourceTextEdit(
+                    cell.uri,
+                    { range: deletionRange, text: '' },
+                    cell.textModel?.getVersionId()
+                ));
+            })));
+            const filteredEdits = allCellEdits.flat().filter(edit => edit !== undefined);
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'trimNotebookNewlines',
+                "Trim Final New Lines"
+            )), code: 'undoredo.trimFinalNewLines' });
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+TrimFinalNewLinesParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IBulkEditService))
+], TrimFinalNewLinesParticipant));
+let InsertFinalNewLineParticipant = class InsertFinalNewLineParticipant {
+    constructor(configurationService, bulkEditService, editorService) {
+        this.configurationService = configurationService;
+        this.bulkEditService = bulkEditService;
+        this.editorService = editorService;
+    }
+    async participate(workingCopy, context, progress, _token) {
+        if (this.configurationService.getValue(NotebookSetting.insertFinalNewline)) {
+            await this.doInsertFinalNewLine(workingCopy, context.reason === 2 , progress);
+        }
+    }
+    async doInsertFinalNewLine(workingCopy, isAutoSaved, progress) {
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        const disposable = ( new DisposableStore());
+        const notebook = workingCopy.model.notebookModel;
+        const activeCellEditor = getActiveCellCodeEditor(this.editorService);
+        let selections;
+        if (activeCellEditor) {
+            selections = activeCellEditor.getSelections() ?? [];
+        }
+        try {
+            const allCellEdits = await Promise.all(( notebook.cells.map(async (cell) => {
+                if (cell.cellKind !== CellKind.Code) {
+                    return;
+                }
+                const lineCount = cell.textBuffer.getLineCount();
+                const lastLineIsEmptyOrWhitespace = cell.textBuffer.getLineFirstNonWhitespaceColumn(lineCount) === 0;
+                if (!lineCount || lastLineIsEmptyOrWhitespace) {
+                    return;
+                }
+                return ( new ResourceTextEdit(cell.uri, { range: ( new Range(
+                    lineCount + 1,
+                    cell.textBuffer.getLineLength(lineCount),
+                    lineCount + 1,
+                    cell.textBuffer.getLineLength(lineCount)
+                )), text: cell.textBuffer.getEOL() }, cell.textModel?.getVersionId()));
+            })));
+            const filteredEdits = allCellEdits.filter(edit => edit !== undefined);
+            await this.bulkEditService.apply(filteredEdits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                'insertFinalNewLine',
+                "Insert Final New Line"
+            )), code: 'undoredo.insertFinalNewLine' });
+            if (activeCellEditor && selections) {
+                activeCellEditor.setSelections(selections);
+            }
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+};
+InsertFinalNewLineParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IBulkEditService)),
+    ( __param(2, IEditorService))
+], InsertFinalNewLineParticipant));
+let CodeActionOnSaveParticipant = class CodeActionOnSaveParticipant {
+    constructor(configurationService, logService, workspaceTrustManagementService, languageFeaturesService, textModelService, instantiationService) {
+        this.configurationService = configurationService;
+        this.logService = logService;
+        this.workspaceTrustManagementService = workspaceTrustManagementService;
+        this.languageFeaturesService = languageFeaturesService;
+        this.textModelService = textModelService;
+        this.instantiationService = instantiationService;
+    }
+    async participate(workingCopy, context, progress, token) {
+        const nbDisposable = ( new DisposableStore());
+        const isTrusted = this.workspaceTrustManagementService.isWorkspaceTrusted();
+        if (!isTrusted) {
+            return;
+        }
+        if (!workingCopy.model || !(workingCopy.model instanceof NotebookFileWorkingCopyModel)) {
+            return;
+        }
+        let saveTrigger = '';
+        if (context.reason === 2 ) {
+            return undefined;
+        }
+        else if (context.reason === 1 ) {
+            saveTrigger = 'explicit';
+        }
+        else {
+            return undefined;
+        }
+        const notebookModel = workingCopy.model.notebookModel;
+        const setting = this.configurationService.getValue(NotebookSetting.codeActionsOnSave);
+        if (!setting) {
+            return undefined;
+        }
+        const settingItems = Array.isArray(setting)
+            ? setting
+            : ( Object.keys(setting)).filter(x => setting[x]);
+        if (!settingItems.length) {
+            return undefined;
+        }
+        const allCodeActions = this.createCodeActionsOnSave(settingItems);
+        const excludedActions = allCodeActions
+            .filter(x => setting[x.value] === 'never' || setting[x.value] === false);
+        const includedActions = allCodeActions
+            .filter(x => setting[x.value] === saveTrigger || setting[x.value] === true);
+        const editorCodeActionsOnSave = includedActions.filter(x => !CodeActionKind.Notebook.contains(x));
+        const notebookCodeActionsOnSave = includedActions.filter(x => CodeActionKind.Notebook.contains(x));
+        if (!editorCodeActionsOnSave.length && !notebookCodeActionsOnSave.length) {
+            return undefined;
+        }
+        if (!Array.isArray(setting)) {
+            editorCodeActionsOnSave.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;
+            });
+        }
+        progress.report({ message: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+            'notebookSaveParticipants.notebookCodeActions',
+            "Running 'Notebook' code actions"
+        )) });
+        try {
+            const cell = notebookModel.cells[0];
+            const ref = await this.textModelService.createModelReference(cell.uri);
+            nbDisposable.add(ref);
+            const textEditorModel = ref.object.textEditorModel;
+            await this.applyOnSaveActions(textEditorModel, notebookCodeActionsOnSave, excludedActions, progress, token);
+        }
+        catch {
+            this.logService.error('Failed to apply notebook code action on save');
+        }
+        finally {
+            progress.report({ increment: 100 });
+            nbDisposable.dispose();
+        }
+        const disposable = ( new DisposableStore());
+        progress.report({ message: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+            'notebookSaveParticipants.cellCodeActions',
+            "Running 'Cell' code actions"
+        )) });
+        try {
+            await Promise.all(( notebookModel.cells.map(async (cell) => {
+                const ref = await this.textModelService.createModelReference(cell.uri);
+                disposable.add(ref);
+                const textEditorModel = ref.object.textEditorModel;
+                await this.applyOnSaveActions(textEditorModel, editorCodeActionsOnSave, excludedActions, progress, token);
+            })));
+        }
+        catch {
+            this.logService.error('Failed to apply code action on save');
+        }
+        finally {
+            progress.report({ increment: 100 });
+            disposable.dispose();
+        }
+    }
+    createCodeActionsOnSave(settingItems) {
+        const kinds = ( settingItems.map(x => ( new HierarchicalKind(x))));
+        return kinds.filter(kind => {
+            return kinds.every(otherKind => otherKind.equals(kind) || !otherKind.contains(kind));
+        });
+    }
+    async applyOnSaveActions(model, codeActionsOnSave, excludes, progress, token) {
+        const getActionProgress = new (class {
+            constructor() {
+                this._names = ( new Set());
+            }
+            _report() {
+                progress.report({
+                    message: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                        { key: 'codeaction.get2', comment: ['[configure]({1}) is a link. Only translate `configure`. Do not change brackets and parentheses or {1}'] },
+                        "Getting code actions from '{0}' ([configure]({1})).",
+                        ( [...this._names].map(name => `'${name}'`)).join(', '),
+                        'command:workbench.action.openSettings?%5B%22editor.codeActionsOnSave%22%5D'
+                    ))
+                });
+            }
+            report(provider) {
+                if (provider.displayName && !( this._names.has(provider.displayName))) {
+                    this._names.add(provider.displayName);
+                    this._report();
+                }
+            }
+        });
+        for (const codeActionKind of codeActionsOnSave) {
+            const actionsToRun = await this.getActionsToRun(model, codeActionKind, excludes, getActionProgress, token);
+            if (token.isCancellationRequested) {
+                actionsToRun.dispose();
+                return;
+            }
+            try {
+                for (const action of actionsToRun.validActions) {
+                    const codeActionEdits = action.action.edit?.edits;
+                    let breakFlag = false;
+                    if (!action.action.kind?.startsWith('notebook')) {
+                        for (const edit of codeActionEdits ?? []) {
+                            const workspaceTextEdit = edit;
+                            if (workspaceTextEdit.resource && isEqual(workspaceTextEdit.resource, model.uri)) {
+                                continue;
+                            }
+                            else {
+                                breakFlag = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (breakFlag) {
+                        this.logService.warn('Failed to apply code action on save, applied to multiple resources.');
+                        continue;
+                    }
+                    progress.report({ message: ( localizeWithPath(
+                        'vs/workbench/contrib/notebook/browser/contrib/saveParticipants/saveParticipants',
+                        'codeAction.apply',
+                        "Applying code action '{0}'.",
+                        action.action.title
+                    )) });
+                    await this.instantiationService.invokeFunction(applyCodeAction, action, ApplyCodeActionReason.OnSave, {}, token);
+                    if (token.isCancellationRequested) {
+                        return;
+                    }
+                }
+            }
+            catch {
+            }
+            finally {
+                actionsToRun.dispose();
+            }
+        }
+    }
+    getActionsToRun(model, codeActionKind, excludes, progress, token) {
+        return getCodeActions(this.languageFeaturesService.codeActionProvider, model, model.getFullModelRange(), {
+            type: 1 ,
+            triggerAction: CodeActionTriggerSource.OnSave,
+            filter: { include: codeActionKind, excludes: excludes, includeSourceActions: true },
+        }, progress, token);
+    }
+};
+CodeActionOnSaveParticipant = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, ILogService)),
+    ( __param(2, IWorkspaceTrustManagementService)),
+    ( __param(3, ILanguageFeaturesService)),
+    ( __param(4, ITextModelService)),
+    ( __param(5, IInstantiationService))
+], CodeActionOnSaveParticipant));
+function getActiveCellCodeEditor(editorService) {
+    const activePane = editorService.activeEditorPane;
+    const notebookEditor = getNotebookEditorFromEditorPane(activePane);
+    const activeCodeEditor = notebookEditor?.activeCodeEditor;
+    return activeCodeEditor;
+}
+let SaveParticipantsContribution = class SaveParticipantsContribution extends Disposable {
+    constructor(instantiationService, workingCopyFileService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.registerSaveParticipants();
+    }
+    registerSaveParticipants() {
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimWhitespaceParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(CodeActionOnSaveParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(FormatOnSaveParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(InsertFinalNewLineParticipant)));
+        this._register(this.workingCopyFileService.addSaveParticipant(this.instantiationService.createInstance(TrimFinalNewLinesParticipant)));
+    }
+};
+SaveParticipantsContribution = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IWorkingCopyFileService))
+], SaveParticipantsContribution));
+const workbenchContributionsRegistry = ( Registry.as(Extensions.Workbench));
+workbenchContributionsRegistry.registerWorkbenchContribution(SaveParticipantsContribution, 3 );
+export { SaveParticipantsContribution };