@codingame/monaco-vscode-notebook-service-override 4.1.0 → 4.1.2

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

@@ -0,0 +1,199 @@
+import { localize2WithPath, localizeWithPath } from 'vscode/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { NotebookOutlineContext } from '../contrib/outline/notebookOutline.js';
+import { FoldingController } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/controller/foldingController';
+import { executeIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
+import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+
+class NotebookRunSingleCellInSection extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.section.runSingleCell',
+            title: {
+                ...( localize2WithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    'runCell',
+                    "Run Cell"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    { key: 'mirunCell', comment: ['&& denotes a mnemonic'] },
+                    "&&Run Cell"
+                )),
+            },
+            shortTitle: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                'runCell',
+                "Run Cell"
+            )),
+            icon: executeIcon,
+            menu: [
+                {
+                    id: MenuId.NotebookOutlineActionMenu,
+                    group: 'inline',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(( NotebookOutlineContext.CellKind.isEqualTo(CellKind.Code)), ( NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )), ( NotebookOutlineContext.CellHasChildren.toNegated()), ( NotebookOutlineContext.CellHasHeader.toNegated())))
+                }
+            ]
+        });
+    }
+    async run(_accessor, context) {
+        if (!checkSectionContext(context)) {
+            return;
+        }
+        context.notebookEditor.executeNotebookCells([context.outlineEntry.cell]);
+    }
+}
+class NotebookRunCellsInSection extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.section.runCells',
+            title: {
+                ...( localize2WithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    'runCellsInSection',
+                    "Run Cells In Section"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    { key: 'mirunCellsInSection', comment: ['&& denotes a mnemonic'] },
+                    "&&Run Cells In Section"
+                )),
+            },
+            shortTitle: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                'runCellsInSection',
+                "Run Cells In Section"
+            )),
+            menu: [
+                {
+                    id: MenuId.NotebookStickyScrollContext,
+                    group: 'notebookExecution',
+                    order: 1
+                },
+                {
+                    id: MenuId.NotebookOutlineActionMenu,
+                    group: 'inline',
+                    order: 1,
+                    when: ( ContextKeyExpr.and(( NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)), ( NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )), NotebookOutlineContext.CellHasChildren, NotebookOutlineContext.CellHasHeader))
+                }
+            ]
+        });
+    }
+    async run(_accessor, context) {
+        if (!checkSectionContext(context)) {
+            return;
+        }
+        const cell = context.outlineEntry.cell;
+        const idx = context.notebookEditor.getViewModel()?.getCellIndex(cell);
+        if (idx === undefined) {
+            return;
+        }
+        const length = context.notebookEditor.getViewModel()?.getFoldedLength(idx);
+        if (length === undefined) {
+            return;
+        }
+        const cells = context.notebookEditor.getCellsInRange({ start: idx, end: idx + length + 1 });
+        context.notebookEditor.executeNotebookCells(cells);
+    }
+}
+class NotebookFoldSection extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.section.foldSection',
+            title: {
+                ...( localize2WithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    'foldSection',
+                    "Fold Section"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    { key: 'mifoldSection', comment: ['&& denotes a mnemonic'] },
+                    "&&Fold Section"
+                )),
+            },
+            shortTitle: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                'foldSection',
+                "Fold Section"
+            )),
+            menu: [
+                {
+                    id: MenuId.NotebookOutlineActionMenu,
+                    group: 'notebookFolding',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(( NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)), ( NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )), NotebookOutlineContext.CellHasChildren, NotebookOutlineContext.CellHasHeader, ( NotebookOutlineContext.CellFoldingState.isEqualTo(1 ))))
+                }
+            ]
+        });
+    }
+    async run(_accessor, context) {
+        if (!checkSectionContext(context)) {
+            return;
+        }
+        this.toggleFoldRange(context.outlineEntry, context.notebookEditor);
+    }
+    toggleFoldRange(entry, notebookEditor) {
+        const foldingController = notebookEditor.getContribution(FoldingController.id);
+        const index = entry.index;
+        const headerLevel = entry.level;
+        const newFoldingState = 2 ;
+        foldingController.setFoldingStateDown(index, newFoldingState, headerLevel);
+    }
+}
+class NotebookExpandSection extends Action2 {
+    constructor() {
+        super({
+            id: 'notebook.section.expandSection',
+            title: {
+                ...( localize2WithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    'expandSection',
+                    "Expand Section"
+                )),
+                mnemonicTitle: ( localizeWithPath(
+                    'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                    { key: 'miexpandSection', comment: ['&& denotes a mnemonic'] },
+                    "&&Expand Section"
+                )),
+            },
+            shortTitle: ( localizeWithPath(
+                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
+                'expandSection',
+                "Expand Section"
+            )),
+            menu: [
+                {
+                    id: MenuId.NotebookOutlineActionMenu,
+                    group: 'notebookFolding',
+                    order: 2,
+                    when: ( ContextKeyExpr.and(( NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)), ( NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )), NotebookOutlineContext.CellHasChildren, NotebookOutlineContext.CellHasHeader, ( NotebookOutlineContext.CellFoldingState.isEqualTo(2 ))))
+                }
+            ]
+        });
+    }
+    async run(_accessor, context) {
+        if (!checkSectionContext(context)) {
+            return;
+        }
+        this.toggleFoldRange(context.outlineEntry, context.notebookEditor);
+    }
+    toggleFoldRange(entry, notebookEditor) {
+        const foldingController = notebookEditor.getContribution(FoldingController.id);
+        const index = entry.index;
+        const headerLevel = entry.level;
+        const newFoldingState = 1 ;
+        foldingController.setFoldingStateDown(index, newFoldingState, headerLevel);
+    }
+}
+function checkSectionContext(context) {
+    return !!(context && context.notebookEditor && context.outlineEntry);
+}
+registerAction2(NotebookRunSingleCellInSection);
+registerAction2(NotebookRunCellsInSection);
+registerAction2(NotebookFoldSection);
+registerAction2(NotebookExpandSection);
+
+export { NotebookExpandSection, NotebookFoldSection, NotebookRunCellsInSection, NotebookRunSingleCellInSection };

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

@@ -0,0 +1,47 @@
+const fixedEditorPadding = {
+    top: 12,
+    bottom: 12
+};
+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',
+    lineDecorationsWidth: 0,
+    glyphMargin: false,
+    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, fixedEditorPadding };