@codingame/monaco-vscode-api 2.2.2 → 3.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/editActions.js

@@ -1,32 +1,37 @@
 import { Mimes } from '../../../../../base/common/mime.js';
 import { URI } from '../../../../../base/common/uri.js';
 import { EditorContextKeys } from '../../../../../editor/common/editorContextKeys.js';
+import { ILanguageService } from '../../../../../editor/common/languages/language.js';
 import { getIconClasses } from '../../../../../editor/common/services/getIconClasses.js';
 import { IModelService } from '../../../../../editor/common/services/model.js';
-import { ILanguageService } from '../../../../../editor/common/languages/language.js';
-import { localizeWithPath } from '../../../../../nls.js';
+import { localizeWithPath, localize2WithPath } from '../../../../../nls.js';
 import { registerAction2, MenuId } from '../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
 import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
 import { InputFocusedContextKey, InputFocusedContext } from '../../../../../platform/contextkey/common/contextkeys.js';
+import '../../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
+import { INotificationService } from '../../../../../platform/notification/common/notification.js';
 import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.js';
+import { InlineChatController } from '../../../inlineChat/browser/inlineChatController.js';
+import { CTX_INLINE_CHAT_FOCUSED } from '../../../inlineChat/common/inlineChat.js';
 import { runDeleteAction, changeCellToKind } from './cellOperations.js';
 import { NotebookCellAction, CELL_TITLE_CELL_GROUP_ID, findTargetCellEditor, NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT, executeNotebookCondition, CELL_TITLE_OUTPUT_GROUP_ID, NotebookAction } from './coreActions.js';
-import { NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_TYPE, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_EDITABLE, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON, NOTEBOOK_HAS_OUTPUTS, NOTEBOOK_IS_ACTIVE_EDITOR } from '../../common/notebookContextKeys.js';
-import { QUIT_EDIT_CELL_COMMAND_ID, CellEditState, CHANGE_CELL_LANGUAGE, DETECT_CELL_LANGUAGE } from '../notebookBrowser.js';
-import { editIcon, stopEditIcon, deleteCellIcon, clearIcon } from '../notebookIcons.js';
+import { NotebookIndentUsingTabs, NotebookIndentUsingSpaces, NotebookChangeTabDisplaySize, NotebookIndentationToTabsAction, NotebookIndentationToSpacesAction } from './notebookIndentationActions.js';
+import { QUIT_EDIT_CELL_COMMAND_ID, CellEditState, CHANGE_CELL_LANGUAGE, DETECT_CELL_LANGUAGE, getNotebookEditorFromEditorPane } from '../notebookBrowser.js';
 import { CellKind, NotebookCellExecutionState, NotebookSetting } from '../../common/notebookCommon.js';
-import { ILanguageDetectionService } from '../../../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_TYPE, NOTEBOOK_CELL_MARKDOWN_EDIT_MODE, NOTEBOOK_CELL_EDITABLE, NOTEBOOK_EDITOR_FOCUSED, NOTEBOOK_OUTPUT_FOCUSED, NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_USE_CONSOLIDATED_OUTPUT_BUTTON, NOTEBOOK_HAS_OUTPUTS, NOTEBOOK_IS_ACTIVE_EDITOR } from '../../common/notebookContextKeys.js';
 import { INotebookExecutionStateService } from '../../common/notebookExecutionStateService.js';
-import { INotificationService } from '../../../../../platform/notification/common/notification.js';
 import { INotebookKernelService } from '../../common/notebookKernelService.js';
-import '../../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
-import { InlineChatController } from '../../../inlineChat/browser/inlineChatController.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+import { ILanguageDetectionService } from '../../../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { editIcon, stopEditIcon, deleteCellIcon, clearIcon } from '../notebookIcons.js';
 import { IDialogService } from '../../../../../platform/dialogs/common/dialogs.js';
 const CLEAR_ALL_CELLS_OUTPUTS_COMMAND_ID = 'notebook.clearAllCellsOutputs';
 const EDIT_CELL_COMMAND_ID = 'notebook.cell.edit';
 const DELETE_CELL_COMMAND_ID = 'notebook.cell.delete';
 const CLEAR_CELL_OUTPUTS_COMMAND_ID = 'notebook.cell.clearOutputs';
+const SELECT_NOTEBOOK_INDENTATION_ID = 'notebook.selectIndentation';
 registerAction2(class EditCellAction extends NotebookCellAction {
     constructor() {
         super({
@@ -66,7 +71,7 @@ registerAction2(class EditCellAction extends NotebookCellAction {
         }
     }
 });
-const quitEditCondition = ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, InputFocusedContext));
+const quitEditCondition = ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, InputFocusedContext, ( CTX_INLINE_CHAT_FOCUSED.toNegated())));
 registerAction2(class QuitEditCellAction extends NotebookCellAction {
     constructor() {
         super({
@@ -489,11 +494,11 @@ registerAction2(class DetectCellLanguageAction extends NotebookCellAction {
     constructor() {
         super({
             id: DETECT_CELL_LANGUAGE,
-            title: { value: ( localizeWithPath(
+            title: ( localize2WithPath(
                 'vs/workbench/contrib/notebook/browser/controller/editActions',
                 'detectLanguage',
-                'Accept Detected Language for Cell'
-            )), original: 'Accept Detected Language for Cell' },
+                "Accept Detected Language for Cell"
+            )),
             f1: true,
             precondition: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_EDITABLE, NOTEBOOK_CELL_EDITABLE)),
             keybinding: { primary: 34  | 512  | 1024 , weight: 200  }
@@ -536,4 +541,86 @@ async function setCellToLanguage(languageId, context) {
         context.notebookEditor.textModel.applyEdits([{ editType: 4 , index, language: languageId }], true, undefined, () => undefined, undefined, !context.notebookEditor.isReadOnly);
     }
 }
-export { CLEAR_CELL_OUTPUTS_COMMAND_ID };
+registerAction2(class SelectNotebookIndentation extends NotebookAction {
+    constructor() {
+        super({
+            id: SELECT_NOTEBOOK_INDENTATION_ID,
+            title: ( localize2WithPath(
+                'vs/workbench/contrib/notebook/browser/controller/editActions',
+                'selectNotebookIndentation',
+                'Select Indentation'
+            )),
+            f1: true,
+            precondition: ( ContextKeyExpr.and(
+                NOTEBOOK_IS_ACTIVE_EDITOR,
+                NOTEBOOK_EDITOR_EDITABLE,
+                NOTEBOOK_CELL_EDITABLE
+            )),
+        });
+    }
+    async runWithContext(accessor, context) {
+        await this.showNotebookIndentationPicker(accessor, context);
+    }
+    async showNotebookIndentationPicker(accessor, context) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorService = accessor.get(IEditorService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const activeNotebook = getNotebookEditorFromEditorPane(editorService.activeEditorPane);
+        if (!activeNotebook || activeNotebook.isDisposed) {
+            return quickInputService.pick([{ label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/editActions',
+                'noNotebookEditor',
+                "No notebook editor active at this time"
+            )) }]);
+        }
+        if (activeNotebook.isReadOnly) {
+            return quickInputService.pick([{ label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/editActions',
+                'noWritableCodeEditor',
+                "The active notebook editor is read-only."
+            )) }]);
+        }
+        const picks = ( [
+            (
+            new NotebookIndentUsingTabs()),
+            (
+            new NotebookIndentUsingSpaces()),
+            (
+            new NotebookChangeTabDisplaySize()),
+            (
+            new NotebookIndentationToTabsAction()),
+            (
+            new NotebookIndentationToSpacesAction())
+        ].map(item => {
+            return {
+                id: item.desc.id,
+                label: ( item.desc.title.toString()),
+                run: () => {
+                    instantiationService.invokeFunction(item.run);
+                }
+            };
+        }));
+        picks.splice(3, 0, { type: 'separator', label: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/editActions',
+            'indentConvert',
+            "convert file"
+        )) });
+        picks.unshift({ type: 'separator', label: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/editActions',
+            'indentView',
+            "change view"
+        )) });
+        const action = await quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/editActions',
+            'pickAction',
+            "Select Action"
+        )), matchOnDetail: true });
+        if (!action) {
+            return;
+        }
+        action.run();
+        context.notebookEditor.focus();
+        return;
+    }
+});
+export { CLEAR_CELL_OUTPUTS_COMMAND_ID, SELECT_NOTEBOOK_INDENTATION_ID };

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/foldingController.js

@@ -111,7 +111,7 @@ const NOTEBOOK_FOLD_COMMAND_LABEL = ( localizeWithPath(
     'fold.cell',
     "Fold Cell"
 ));
-const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localizeWithPath(
+const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2WithPath(
     'vs/workbench/contrib/notebook/browser/controller/foldingController',
     'unfold.cell',
     "Unfold Cell"
@@ -212,7 +212,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: 'notebook.unfold',
-            title: { value: NOTEBOOK_UNFOLD_COMMAND_LABEL, original: 'Unfold Cell' },
+            title: NOTEBOOK_UNFOLD_COMMAND_LABEL,
             category: NOTEBOOK_ACTIONS_CATEGORY,
             keybinding: {
                 when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions.js

@@ -0,0 +1,234 @@
+import { localizeWithPath } from '../../../../../nls.js';
+import { DisposableStore } from '../../../../../base/common/lifecycle.js';
+import { IBulkEditService, ResourceTextEdit } from '../../../../../editor/browser/services/bulkEditService.js';
+import { Range } from '../../../../../editor/common/core/range.js';
+import { ITextModelService } from '../../../../../editor/common/services/resolverService.js';
+import { registerAction2, Action2 } from '../../../../../platform/actions/common/actions.js';
+import { IConfigurationService } from '../../../../../platform/configuration/common/configuration.js';
+import { ILogService } from '../../../../../platform/log/common/log.js';
+import { IQuickInputService } from '../../../../../platform/quickinput/common/quickInput.js';
+import { INotebookEditorService } from '../services/notebookEditorService.js';
+import { NotebookSetting } from '../../common/notebookCommon.js';
+import { isNotebookEditorInput } from '../../common/notebookEditorInput.js';
+import { IEditorService } from '../../../../services/editor/common/editorService.js';
+class NotebookIndentUsingTabs extends Action2 {
+    static { this.ID = 'notebook.action.indentUsingTabs'; }
+    constructor() {
+        super({
+            id: NotebookIndentUsingTabs.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'indentUsingTabs',
+                "Indent Using Tabs"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        changeNotebookIndentation(accessor, false, false);
+    }
+}
+class NotebookIndentUsingSpaces extends Action2 {
+    static { this.ID = 'notebook.action.indentUsingSpaces'; }
+    constructor() {
+        super({
+            id: NotebookIndentUsingSpaces.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'indentUsingSpaces',
+                "Indent Using Spaces"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        changeNotebookIndentation(accessor, true, false);
+    }
+}
+class NotebookChangeTabDisplaySize extends Action2 {
+    static { this.ID = 'notebook.action.changeTabDisplaySize'; }
+    constructor() {
+        super({
+            id: NotebookChangeTabDisplaySize.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'changeTabDisplaySize',
+                "Change Tab Display Size"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        changeNotebookIndentation(accessor, true, true);
+    }
+}
+class NotebookIndentationToSpacesAction extends Action2 {
+    static { this.ID = 'notebook.action.convertIndentationToSpaces'; }
+    constructor() {
+        super({
+            id: NotebookIndentationToSpacesAction.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'convertIndentationToSpaces',
+                "Convert Indentation to Spaces"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        convertNotebookIndentation(accessor, true);
+    }
+}
+class NotebookIndentationToTabsAction extends Action2 {
+    static { this.ID = 'notebook.action.convertIndentationToTabs'; }
+    constructor() {
+        super({
+            id: NotebookIndentationToTabsAction.ID,
+            title: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'convertIndentationToTabs',
+                "Convert Indentation to Tabs"
+            )),
+            precondition: undefined,
+        });
+    }
+    run(accessor, ...args) {
+        convertNotebookIndentation(accessor, false);
+    }
+}
+function changeNotebookIndentation(accessor, insertSpaces, displaySizeOnly) {
+    const editorService = accessor.get(IEditorService);
+    const configurationService = accessor.get(IConfigurationService);
+    const notebookEditorService = accessor.get(INotebookEditorService);
+    const quickInputService = accessor.get(IQuickInputService);
+    const activeInput = editorService.activeEditorPane?.input;
+    const isNotebook = isNotebookEditorInput(activeInput);
+    if (!isNotebook) {
+        return;
+    }
+    const notebookEditor = notebookEditorService.retrieveExistingWidgetFromURI(activeInput.resource)?.value;
+    if (!notebookEditor) {
+        return;
+    }
+    const picks = ( [1, 2, 3, 4, 5, 6, 7, 8].map(n => ({
+        id: ( n.toString()),
+        label: ( n.toString()),
+    })));
+    const initialConfig = configurationService.getValue(NotebookSetting.cellEditorOptionsCustomizations);
+    const initialInsertSpaces = initialConfig['editor.insertSpaces'];
+    delete initialConfig['editor.indentSize'];
+    delete initialConfig['editor.tabSize'];
+    delete initialConfig['editor.insertSpaces'];
+    setTimeout(() => {
+        quickInputService.pick(picks, { placeHolder: ( localizeWithPath(
+            'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+            { key: 'selectTabWidth', comment: ['Tab corresponds to the tab key'] },
+            "Select Tab Size for Current File"
+        )) }).then(pick => {
+            if (pick) {
+                const pickedVal = parseInt(pick.label, 10);
+                if (displaySizeOnly) {
+                    configurationService.updateValue(NotebookSetting.cellEditorOptionsCustomizations, {
+                        ...initialConfig,
+                        'editor.tabSize': pickedVal,
+                        'editor.indentSize': pickedVal,
+                        'editor.insertSpaces': initialInsertSpaces
+                    });
+                }
+                else {
+                    configurationService.updateValue(NotebookSetting.cellEditorOptionsCustomizations, {
+                        ...initialConfig,
+                        'editor.tabSize': pickedVal,
+                        'editor.indentSize': pickedVal,
+                        'editor.insertSpaces': insertSpaces
+                    });
+                }
+            }
+        });
+    }, 50 );
+}
+function convertNotebookIndentation(accessor, tabsToSpaces) {
+    const editorService = accessor.get(IEditorService);
+    const configurationService = accessor.get(IConfigurationService);
+    const logService = accessor.get(ILogService);
+    const textModelService = accessor.get(ITextModelService);
+    const notebookEditorService = accessor.get(INotebookEditorService);
+    const bulkEditService = accessor.get(IBulkEditService);
+    const activeInput = editorService.activeEditorPane?.input;
+    const isNotebook = isNotebookEditorInput(activeInput);
+    if (!isNotebook) {
+        return;
+    }
+    const notebookTextModel = notebookEditorService.retrieveExistingWidgetFromURI(activeInput.resource)?.value?.textModel;
+    if (!notebookTextModel) {
+        return;
+    }
+    const disposable = ( new DisposableStore());
+    try {
+        Promise.all(( notebookTextModel.cells.map(async (cell) => {
+            const ref = await textModelService.createModelReference(cell.uri);
+            disposable.add(ref);
+            const textEditorModel = ref.object.textEditorModel;
+            const modelOpts = cell.textModel?.getOptions();
+            if (!modelOpts) {
+                return;
+            }
+            const edits = getIndentationEditOperations(textEditorModel, modelOpts.tabSize, tabsToSpaces);
+            bulkEditService.apply(edits, { label: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/notebookIndentationActions',
+                'convertIndentation',
+                "Convert Indentation"
+            )), code: 'undoredo.convertIndentation', });
+        }))).then(() => {
+            const initialConfig = configurationService.getValue(NotebookSetting.cellEditorOptionsCustomizations);
+            const initialIndentSize = initialConfig['editor.indentSize'];
+            const initialTabSize = initialConfig['editor.tabSize'];
+            delete initialConfig['editor.indentSize'];
+            delete initialConfig['editor.tabSize'];
+            delete initialConfig['editor.insertSpaces'];
+            configurationService.updateValue(NotebookSetting.cellEditorOptionsCustomizations, {
+                ...initialConfig,
+                'editor.tabSize': initialTabSize,
+                'editor.indentSize': initialIndentSize,
+                'editor.insertSpaces': tabsToSpaces
+            });
+            disposable.dispose();
+        });
+    }
+    catch {
+        logService.error('Failed to convert indentation to spaces for notebook cells.');
+    }
+}
+function getIndentationEditOperations(model, tabSize, tabsToSpaces) {
+    if (model.getLineCount() === 1 && model.getLineMaxColumn(1) === 1) {
+        return [];
+    }
+    let spaces = '';
+    for (let i = 0; i < tabSize; i++) {
+        spaces += ' ';
+    }
+    const spacesRegExp = ( new RegExp(spaces, 'gi'));
+    const edits = [];
+    for (let lineNumber = 1, lineCount = model.getLineCount(); lineNumber <= lineCount; lineNumber++) {
+        let lastIndentationColumn = model.getLineFirstNonWhitespaceColumn(lineNumber);
+        if (lastIndentationColumn === 0) {
+            lastIndentationColumn = model.getLineMaxColumn(lineNumber);
+        }
+        if (lastIndentationColumn === 1) {
+            continue;
+        }
+        const originalIndentationRange = ( new Range(lineNumber, 1, lineNumber, lastIndentationColumn));
+        const originalIndentation = model.getValueInRange(originalIndentationRange);
+        const newIndentation = (tabsToSpaces
+            ? originalIndentation.replace(/\t/ig, spaces)
+            : originalIndentation.replace(spacesRegExp, '\t'));
+        edits.push(( new ResourceTextEdit(model.uri, { range: originalIndentationRange, text: newIndentation })));
+    }
+    return edits;
+}
+registerAction2(NotebookIndentUsingSpaces);
+registerAction2(NotebookIndentUsingTabs);
+registerAction2(NotebookChangeTabDisplaySize);
+registerAction2(NotebookIndentationToSpacesAction);
+registerAction2(NotebookIndentationToTabsAction);
+export { NotebookChangeTabDisplaySize, NotebookIndentUsingSpaces, NotebookIndentUsingTabs, NotebookIndentationToSpacesAction, NotebookIndentationToTabsAction };

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

@@ -1,6 +1,5 @@
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
 import { append, $, isAncestorOfActiveElement, getWindowById, setParentFlowTo } from '../../../../base/browser/dom.js';
-import { mainWindow } from '../../../../base/browser/window.js';
 import { toAction } from '../../../../base/common/actions.js';
 import { timeout } from '../../../../base/common/async.js';
 import { Emitter } from '../../../../base/common/event.js';
@@ -155,7 +154,7 @@ let NotebookEditor = class NotebookEditor extends EditorPane {
             this._inputListener.value = input.onDidChangeCapabilities(() => this._onDidChangeInputCapabilities(input));
             this._widgetDisposableStore.clear();
             this._widget.value?.onWillHide();
-            this._widget = this._instantiationService.invokeFunction(this._notebookWidgetService.retrieveWidget, group, input, undefined, this._pagePosition?.dimension, getWindowById(group.windowId)?.window ?? mainWindow);
+            this._widget = this._instantiationService.invokeFunction(this._notebookWidgetService.retrieveWidget, group, input, undefined, this._pagePosition?.dimension, getWindowById(group.windowId, true).window);
             if (this._rootElement && this._widget.value.getDomNode()) {
                 this._rootElement.setAttribute('aria-flowto', this._widget.value.getDomNode().id || '');
                 setParentFlowTo(this._widget.value.getDomNode(), this._rootElement);