@codingame/monaco-vscode-api 32.0.2 → 33.0.3

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

@@ -22,7 +22,7 @@ registerAction2(class ShowAllOutputsAction extends Action2 {
     constructor() {
         super({
             id: "notebook.cellOuput.showEmptyOutputs",
-            title: ( localize(11545, "Show Empty Outputs")),
+            title: ( localize(11672, "Show Empty Outputs")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( ContextKeyExpr.and(NOTEBOOK_CELL_HAS_OUTPUTS, NOTEBOOK_CELL_HAS_HIDDEN_OUTPUTS))
@@ -47,7 +47,7 @@ registerAction2(class CopyCellOutputAction extends Action2 {
     constructor() {
         super({
             id: COPY_OUTPUT_COMMAND_ID,
-            title: ( localize(11546, "Copy Cell Output")),
+            title: ( localize(11673, "Copy Cell Output")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: NOTEBOOK_CELL_HAS_OUTPUTS
@@ -130,7 +130,7 @@ registerAction2(class OpenCellOutputInEditorAction extends Action2 {
     constructor() {
         super({
             id: OPEN_OUTPUT_COMMAND_ID,
-            title: ( localize(11547, "Open Cell Output in Text Editor")),
+            title: ( localize(11674, "Open Cell Output in Text Editor")),
             f1: false,
             category: NOTEBOOK_ACTIONS_CATEGORY,
             icon: copyIcon
@@ -159,7 +159,7 @@ registerAction2(class SaveCellOutputImageAction extends Action2 {
     constructor() {
         super({
             id: SAVE_OUTPUT_IMAGE_COMMAND_ID,
-            title: ( localize(11548, "Save Image")),
+            title: ( localize(11675, "Save Image")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( ContextKeyExpr.regex(NOTEBOOK_CELL_OUTPUT_MIMETYPE.key, /^image\//))
@@ -207,7 +207,7 @@ registerAction2(class SaveCellOutputImageAction extends Action2 {
         const uri = await fileDialogService.showSaveDialog({
             defaultUri,
             filters: [{
-                name: ( localize(11549, "Image Files")),
+                name: ( localize(11676, "Image Files")),
                 extensions: [extension]
             }]
         });
@@ -228,7 +228,7 @@ registerAction2(class OpenCellOutputInNotebookOutputEditorAction extends Action2
     constructor() {
         super({
             id: OPEN_OUTPUT_IN_OUTPUT_PREVIEW_COMMAND_ID,
-            title: ( localize(11550, "Open in Output Preview")),
+            title: ( localize(11677, "Open in Output Preview")),
             menu: {
                 id: MenuId.NotebookOutputToolbar,
                 when: ( ContextKeyExpr.and(NOTEBOOK_CELL_HAS_OUTPUTS, ( ContextKeyExpr.equals("config.notebook.output.openInPreviewEditor.enabled", true))))

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

@@ -15,7 +15,7 @@ import { MarshalledId } from '../../../../../base/common/marshallingIds.js';
 import { isEqual } from '../../../../../base/common/resources.js';
 
 const SELECT_KERNEL_ID = "_notebook.selectKernel";
-const NOTEBOOK_ACTIONS_CATEGORY = ( localize2(11565, "Notebook"));
+const NOTEBOOK_ACTIONS_CATEGORY = ( localize2(11692, "Notebook"));
 const CELL_TITLE_CELL_GROUP_ID = "inline/cell";
 const CELL_TITLE_OUTPUT_GROUP_ID = "inline/output";
 const NOTEBOOK_EDITOR_WIDGET_ACTION_WEIGHT = KeybindingWeight.EditorContrib;
@@ -321,18 +321,18 @@ const cellExecutionArgs = [{
 }];
 MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
     submenu: MenuId.NotebookCellInsert,
-    title: ( localize(11566, "Insert Cell")),
+    title: ( localize(11693, "Insert Cell")),
     group: CellOverflowToolbarGroups.Insert,
     when: ( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true))
 });
 MenuRegistry.appendMenuItem(MenuId.EditorContext, {
     submenu: MenuId.NotebookCellTitle,
-    title: ( localize(11567, "Notebook Cell")),
+    title: ( localize(11694, "Notebook Cell")),
     group: CellOverflowToolbarGroups.Insert,
     when: NOTEBOOK_EDITOR_FOCUSED
 });
 MenuRegistry.appendMenuItem(MenuId.NotebookCellTitle, {
-    title: ( localize(11568, "Share")),
+    title: ( localize(11695, "Share")),
     submenu: MenuId.EditorContextShare,
     group: CellOverflowToolbarGroups.Share
 });

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

@@ -128,8 +128,8 @@ class FoldingController extends Disposable {
     }
 }
 registerNotebookContribution(FoldingController.id, FoldingController);
-const NOTEBOOK_FOLD_COMMAND_LABEL = ( localize(11608, "Fold Cell"));
-const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2(11609, "Unfold Cell"));
+const NOTEBOOK_FOLD_COMMAND_LABEL = ( localize(11735, "Fold Cell"));
+const NOTEBOOK_UNFOLD_COMMAND_LABEL = ( localize2(11736, "Unfold Cell"));
 const FOLDING_COMMAND_ARGS = {
     args: [{
         isOptional: true,
@@ -159,7 +159,7 @@ registerAction2(class extends Action2 {
     constructor() {
         super({
             id: "notebook.fold",
-            title: ( localize2(11608, "Fold Cell")),
+            title: ( localize2(11735, "Fold Cell")),
             category: NOTEBOOK_ACTIONS_CATEGORY,
             keybinding: {
                 when: ( ContextKeyExpr.and(NOTEBOOK_EDITOR_FOCUSED, ContextKeyExpr.not(InputFocusedContextKey))),

package/vscode/src/vs/workbench/contrib/notebook/browser/controller/insertCellActions.d.ts

@@ -0,0 +1,13 @@
+import { IAction2Options } from "../../../../../platform/actions/common/actions.js";
+import { ServicesAccessor } from "../../../../../platform/instantiation/common/instantiation.js";
+import { INotebookActionContext, NotebookAction } from "./coreActions.js";
+import { CellViewModel } from "../viewModel/notebookViewModelImpl.js";
+import { CellKind } from "../../common/notebookCommon.js";
+export declare function insertNewCell(accessor: ServicesAccessor, context: INotebookActionContext, kind: CellKind, direction: "above" | "below", focusEditor: boolean): CellViewModel | null;
+export declare abstract class InsertCellCommand extends NotebookAction {
+    private kind;
+    private direction;
+    private focusEditor;
+    constructor(desc: Readonly<IAction2Options>, kind: CellKind, direction: "above" | "below", focusEditor: boolean);
+    runWithContext(accessor: ServicesAccessor, context: INotebookActionContext): Promise<void>;
+}

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

@@ -0,0 +1,300 @@
+
+import { Codicon } from '../../../../../base/common/codicons.js';
+import { KeyMod as KeyMod$1, KeyCode } from '../../../../../base/common/keyCodes.js';
+import { ILanguageService } from '../../../../../editor/common/languages/language.service.js';
+import { localize } from '../../../../../nls.js';
+import { registerAction2, MenuId, MenuRegistry } from '../../../../../platform/actions/common/actions.js';
+import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
+import { InputFocusedContext } from '../../../../../platform/contextkey/common/contextkeys.js';
+import { KeybindingWeight } from '../../../../../platform/keybinding/common/keybindingsRegistry.js';
+import { insertCell } from './cellOperations.js';
+import { NotebookAction } from './coreActions.js';
+import { NOTEBOOK_CELL_LIST_FOCUSED, NOTEBOOK_EDITOR_EDITABLE } from '../../common/notebookContextKeys.js';
+import { CellKind, NotebookSetting } from '../../common/notebookCommon.js';
+import { INotebookKernelHistoryService } from '../../common/notebookKernelService.service.js';
+
+const INSERT_CODE_CELL_ABOVE_COMMAND_ID = "notebook.cell.insertCodeCellAbove";
+const INSERT_CODE_CELL_BELOW_COMMAND_ID = "notebook.cell.insertCodeCellBelow";
+const INSERT_CODE_CELL_ABOVE_AND_FOCUS_CONTAINER_COMMAND_ID = "notebook.cell.insertCodeCellAboveAndFocusContainer";
+const INSERT_CODE_CELL_BELOW_AND_FOCUS_CONTAINER_COMMAND_ID = "notebook.cell.insertCodeCellBelowAndFocusContainer";
+const INSERT_CODE_CELL_AT_TOP_COMMAND_ID = "notebook.cell.insertCodeCellAtTop";
+const INSERT_MARKDOWN_CELL_ABOVE_COMMAND_ID = "notebook.cell.insertMarkdownCellAbove";
+const INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID = "notebook.cell.insertMarkdownCellBelow";
+const INSERT_MARKDOWN_CELL_AT_TOP_COMMAND_ID = "notebook.cell.insertMarkdownCellAtTop";
+function insertNewCell(accessor, context, kind, direction, focusEditor) {
+    let newCell = null;
+    if (context.ui) {
+        context.notebookEditor.focus();
+    }
+    const languageService = accessor.get(ILanguageService);
+    const kernelHistoryService = accessor.get(INotebookKernelHistoryService);
+    if (context.cell) {
+        const idx = context.notebookEditor.getCellIndex(context.cell);
+        newCell = insertCell(
+            languageService,
+            context.notebookEditor,
+            idx,
+            kind,
+            direction,
+            undefined,
+            true,
+            kernelHistoryService
+        );
+    } else {
+        const focusRange = context.notebookEditor.getFocus();
+        const next = Math.max(focusRange.end - 1, 0);
+        newCell = insertCell(
+            languageService,
+            context.notebookEditor,
+            next,
+            kind,
+            direction,
+            undefined,
+            true,
+            kernelHistoryService
+        );
+    }
+    return newCell;
+}
+class InsertCellCommand extends NotebookAction {
+    constructor(desc, kind, direction, focusEditor) {
+        super(desc);
+        this.kind = kind;
+        this.direction = direction;
+        this.focusEditor = focusEditor;
+    }
+    async runWithContext(accessor, context) {
+        const newCell = await insertNewCell(accessor, context, this.kind, this.direction);
+        if (newCell) {
+            await context.notebookEditor.focusNotebookCell(newCell, this.focusEditor ? "editor" : "container");
+        }
+    }
+}
+registerAction2(class InsertCodeCellAboveAction extends InsertCellCommand {
+    constructor() {
+        super({
+            id: INSERT_CODE_CELL_ABOVE_COMMAND_ID,
+            title: ( localize(11737, "Insert Code Cell Above")),
+            keybinding: {
+                primary: KeyMod$1.CtrlCmd | KeyMod$1.Shift | KeyCode.Enter,
+                when: ( ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, ( InputFocusedContext.toNegated()))),
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellInsert,
+                order: 0
+            }
+        }, CellKind.Code, "above", true);
+    }
+});
+registerAction2(
+    class InsertCodeCellAboveAndFocusContainerAction extends InsertCellCommand {
+        constructor() {
+            super({
+                id: INSERT_CODE_CELL_ABOVE_AND_FOCUS_CONTAINER_COMMAND_ID,
+                title: ( localize(11738, "Insert Code Cell Above and Focus Container"))
+            }, CellKind.Code, "above", false);
+        }
+    }
+);
+registerAction2(class InsertCodeCellBelowAction extends InsertCellCommand {
+    constructor() {
+        super({
+            id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
+            title: ( localize(11739, "Insert Code Cell Below")),
+            keybinding: {
+                primary: KeyMod$1.CtrlCmd | KeyCode.Enter,
+                when: ( ContextKeyExpr.and(NOTEBOOK_CELL_LIST_FOCUSED, ( InputFocusedContext.toNegated()))),
+                weight: KeybindingWeight.WorkbenchContrib
+            },
+            menu: {
+                id: MenuId.NotebookCellInsert,
+                order: 1
+            }
+        }, CellKind.Code, "below", true);
+    }
+});
+registerAction2(
+    class InsertCodeCellBelowAndFocusContainerAction extends InsertCellCommand {
+        constructor() {
+            super({
+                id: INSERT_CODE_CELL_BELOW_AND_FOCUS_CONTAINER_COMMAND_ID,
+                title: ( localize(11740, "Insert Code Cell Below and Focus Container"))
+            }, CellKind.Code, "below", false);
+        }
+    }
+);
+registerAction2(class InsertMarkdownCellAboveAction extends InsertCellCommand {
+    constructor() {
+        super({
+            id: INSERT_MARKDOWN_CELL_ABOVE_COMMAND_ID,
+            title: ( localize(11741, "Insert Markdown Cell Above")),
+            menu: {
+                id: MenuId.NotebookCellInsert,
+                order: 2
+            }
+        }, CellKind.Markup, "above", true);
+    }
+});
+registerAction2(class InsertMarkdownCellBelowAction extends InsertCellCommand {
+    constructor() {
+        super({
+            id: INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID,
+            title: ( localize(11742, "Insert Markdown Cell Below")),
+            menu: {
+                id: MenuId.NotebookCellInsert,
+                order: 3
+            }
+        }, CellKind.Markup, "below", true);
+    }
+});
+registerAction2(class InsertCodeCellAtTopAction extends NotebookAction {
+    constructor() {
+        super({
+            id: INSERT_CODE_CELL_AT_TOP_COMMAND_ID,
+            title: ( localize(11743, "Add Code Cell At Top")),
+            f1: false
+        });
+    }
+    async run(accessor, context) {
+        context = context ?? this.getEditorContextFromArgsOrActive(accessor);
+        if (context) {
+            this.runWithContext(accessor, context);
+        }
+    }
+    async runWithContext(accessor, context) {
+        const languageService = accessor.get(ILanguageService);
+        const kernelHistoryService = accessor.get(INotebookKernelHistoryService);
+        const newCell = insertCell(
+            languageService,
+            context.notebookEditor,
+            0,
+            CellKind.Code,
+            "above",
+            undefined,
+            true,
+            kernelHistoryService
+        );
+        if (newCell) {
+            await context.notebookEditor.focusNotebookCell(newCell, "editor");
+        }
+    }
+});
+registerAction2(class InsertMarkdownCellAtTopAction extends NotebookAction {
+    constructor() {
+        super({
+            id: INSERT_MARKDOWN_CELL_AT_TOP_COMMAND_ID,
+            title: ( localize(11744, "Add Markdown Cell At Top")),
+            f1: false
+        });
+    }
+    async run(accessor, context) {
+        context = context ?? this.getEditorContextFromArgsOrActive(accessor);
+        if (context) {
+            this.runWithContext(accessor, context);
+        }
+    }
+    async runWithContext(accessor, context) {
+        const languageService = accessor.get(ILanguageService);
+        const kernelHistoryService = accessor.get(INotebookKernelHistoryService);
+        const newCell = insertCell(
+            languageService,
+            context.notebookEditor,
+            0,
+            CellKind.Markup,
+            "above",
+            undefined,
+            true,
+            kernelHistoryService
+        );
+        if (newCell) {
+            await context.notebookEditor.focusNotebookCell(newCell, "editor");
+        }
+    }
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
+    command: {
+        id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
+        title: "$(add) " + ( localize(11745, "Code")),
+        tooltip: ( localize(11746, "Add Code Cell"))
+    },
+    order: 0,
+    group: "inline",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.experimental.insertToolbarAlignment", "left"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
+    command: {
+        id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
+        title: ( localize(11747, "Add Code")),
+        icon: Codicon.add,
+        tooltip: ( localize(11746, "Add Code Cell"))
+    },
+    order: 0,
+    group: "inline",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.equals("config.notebook.experimental.insertToolbarAlignment", "left"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
+    command: {
+        id: INSERT_CODE_CELL_BELOW_COMMAND_ID,
+        icon: Codicon.add,
+        title: ( localize(11748, "Code")),
+        tooltip: ( localize(11746, "Add Code Cell"))
+    },
+    order: -5,
+    group: "navigation/add",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.insertToolbarLocation", "betweenCells")), ( ContextKeyExpr.notEquals("config.notebook.insertToolbarLocation", "hidden"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
+    command: {
+        id: INSERT_CODE_CELL_AT_TOP_COMMAND_ID,
+        title: "$(add) " + ( localize(11745, "Code")),
+        tooltip: ( localize(11746, "Add Code Cell"))
+    },
+    order: 0,
+    group: "inline",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.experimental.insertToolbarAlignment", "left"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
+    command: {
+        id: INSERT_CODE_CELL_AT_TOP_COMMAND_ID,
+        title: ( localize(11749, "Add Code")),
+        icon: Codicon.add,
+        tooltip: ( localize(11746, "Add Code Cell"))
+    },
+    order: 0,
+    group: "inline",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.equals("config.notebook.experimental.insertToolbarAlignment", "left"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellBetween, {
+    command: {
+        id: INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID,
+        title: "$(add) " + ( localize(11750, "Markdown")),
+        tooltip: ( localize(11751, "Add Markdown Cell"))
+    },
+    order: 1,
+    group: "inline",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.experimental.insertToolbarAlignment", "left"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookToolbar, {
+    command: {
+        id: INSERT_MARKDOWN_CELL_BELOW_COMMAND_ID,
+        icon: Codicon.add,
+        title: ( localize(11752, "Markdown")),
+        tooltip: ( localize(11751, "Add Markdown Cell"))
+    },
+    order: -5,
+    group: "navigation/add",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.insertToolbarLocation", "betweenCells")), ( ContextKeyExpr.notEquals("config.notebook.insertToolbarLocation", "hidden")), ( ContextKeyExpr.notEquals(`config.${NotebookSetting.globalToolbarShowLabel}`, false)), ( ContextKeyExpr.notEquals(`config.${NotebookSetting.globalToolbarShowLabel}`, "never"))))
+});
+MenuRegistry.appendMenuItem(MenuId.NotebookCellListTop, {
+    command: {
+        id: INSERT_MARKDOWN_CELL_AT_TOP_COMMAND_ID,
+        title: "$(add) " + ( localize(11750, "Markdown")),
+        tooltip: ( localize(11751, "Add Markdown Cell"))
+    },
+    order: 1,
+    group: "inline",
+    when: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.isEqualTo(true)), ( ContextKeyExpr.notEquals("config.notebook.experimental.insertToolbarAlignment", "left"))))
+});
+
+export { InsertCellCommand, insertNewCell };

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffCellEditorOptions.d.ts

@@ -0,0 +1,8 @@
+import { IDiffEditorConstructionOptions } from "../../../../../editor/browser/editorBrowser.js";
+import { IEditorOptions } from "../../../../../editor/common/config/editorOptions.js";
+export declare function getEditorPadding(lineCount: number): {
+    top: number;
+    bottom: number;
+};
+export declare const fixedEditorOptions: IEditorOptions;
+export declare const fixedDiffEditorOptions: IDiffEditorConstructionOptions;

package/vscode/src/vs/workbench/contrib/notebook/browser/diff/diffCellEditorOptions.js

@@ -0,0 +1,55 @@
+
+
+const fixedEditorPaddingSingleLineCells = {
+    top: 24,
+    bottom: 24
+};
+const fixedEditorPadding = {
+    top: 12,
+    bottom: 12
+};
+function getEditorPadding(lineCount) {
+    return lineCount === 1 ? fixedEditorPaddingSingleLineCells : fixedEditorPadding;
+}
+const fixedEditorOptions = {
+    padding: fixedEditorPadding,
+    scrollBeyondLastLine: false,
+    scrollbar: {
+        verticalScrollbarSize: 14,
+        horizontal: 'auto',
+        vertical: 'auto',
+        useShadows: true,
+        verticalHasArrows: false,
+        horizontalHasArrows: false,
+        alwaysConsumeMouseWheel: false,
+    },
+    renderLineHighlightOnlyWhenFocus: true,
+    overviewRulerLanes: 0,
+    overviewRulerBorder: false,
+    selectOnLineNumbers: false,
+    wordWrap: 'off',
+    lineNumbers: 'off',
+    glyphMargin: true,
+    fixedOverflowWidgets: true,
+    minimap: { enabled: false },
+    renderValidationDecorations: 'on',
+    renderLineHighlight: 'none',
+    readOnly: true
+};
+const fixedDiffEditorOptions = {
+    ...fixedEditorOptions,
+    glyphMargin: true,
+    enableSplitViewResizing: false,
+    renderIndicators: true,
+    renderMarginRevertIcon: false,
+    readOnly: false,
+    isInEmbeddedEditor: true,
+    renderOverviewRuler: false,
+    wordWrap: 'off',
+    diffWordWrap: 'off',
+    diffAlgorithm: 'advanced',
+    renderSideBySide: true,
+    useInlineViewWhenSpaceIsLimited: false
+};
+
+export { fixedDiffEditorOptions, fixedEditorOptions, getEditorPadding };