@codingame/monaco-vscode-notebook-service-override 4.5.1 → 5.0.0

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

@@ -6,34 +6,28 @@ import { FoldingController } from 'vscode/vscode/vs/workbench/contrib/notebook/b
 import { executeIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/notebookIcons';
 import { CellKind } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/controller/sectionActions";
 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"
-                )),
+                ...( localize2WithPath(_moduleId, 0, "Run Cell")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 1, "&&Run Cell")),
             },
-            shortTitle: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
-                'runCell',
-                "Run Cell"
-            )),
+            shortTitle: ( localizeWithPath(_moduleId, 0, "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())))
+                    when: ( (ContextKeyExpr.and(
+                         (NotebookOutlineContext.CellKind.isEqualTo(CellKind.Code)),
+                         (NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )),
+                         (NotebookOutlineContext.CellHasChildren.toNegated()),
+                         (NotebookOutlineContext.CellHasHeader.toNegated())
+                    )))
                 }
             ]
         });
@@ -50,22 +44,10 @@ class NotebookRunCellsInSection extends Action2 {
         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"
-                )),
+                ...( localize2WithPath(_moduleId, 2, "Run Cells In Section")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 3, "&&Run Cells In Section")),
             },
-            shortTitle: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
-                'runCellsInSection',
-                "Run Cells In Section"
-            )),
+            shortTitle: ( localizeWithPath(_moduleId, 2, "Run Cells In Section")),
             menu: [
                 {
                     id: MenuId.NotebookStickyScrollContext,
@@ -76,7 +58,12 @@ class NotebookRunCellsInSection extends Action2 {
                     id: MenuId.NotebookOutlineActionMenu,
                     group: 'inline',
                     order: 1,
-                    when: ( ContextKeyExpr.and(( NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)), ( NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )), NotebookOutlineContext.CellHasChildren, NotebookOutlineContext.CellHasHeader))
+                    when: ( (ContextKeyExpr.and(
+                         (NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)),
+                         (NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )),
+                        NotebookOutlineContext.CellHasChildren,
+                        NotebookOutlineContext.CellHasHeader
+                    )))
                 }
             ]
         });
@@ -103,28 +90,22 @@ class NotebookFoldSection extends Action2 {
         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"
-                )),
+                ...( localize2WithPath(_moduleId, 4, "Fold Section")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 5, "&&Fold Section")),
             },
-            shortTitle: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
-                'foldSection',
-                "Fold Section"
-            )),
+            shortTitle: ( localizeWithPath(_moduleId, 4, "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 ))))
+                    when: ( (ContextKeyExpr.and(
+                         (NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)),
+                         (NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )),
+                        NotebookOutlineContext.CellHasChildren,
+                        NotebookOutlineContext.CellHasHeader,
+                         (NotebookOutlineContext.CellFoldingState.isEqualTo(1 ))
+                    )))
                 }
             ]
         });
@@ -148,28 +129,22 @@ class NotebookExpandSection extends Action2 {
         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"
-                )),
+                ...( localize2WithPath(_moduleId, 6, "Expand Section")),
+                mnemonicTitle: ( localizeWithPath(_moduleId, 7, "&&Expand Section")),
             },
-            shortTitle: ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/controller/sectionActions',
-                'expandSection',
-                "Expand Section"
-            )),
+            shortTitle: ( localizeWithPath(_moduleId, 6, "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 ))))
+                    when: ( (ContextKeyExpr.and(
+                         (NotebookOutlineContext.CellKind.isEqualTo(CellKind.Markup)),
+                         (NotebookOutlineContext.OutlineElementTarget.isEqualTo(1 )),
+                        NotebookOutlineContext.CellHasChildren,
+                        NotebookOutlineContext.CellHasHeader,
+                         (NotebookOutlineContext.CellFoldingState.isEqualTo(2 ))
+                    )))
                 }
             ]
         });

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

@@ -35,6 +35,7 @@ import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/te
 import { fixedDiffEditorOptions, fixedEditorOptions, fixedEditorPadding } from './diffCellEditorOptions.js';
 import { IAccessibilityService } from 'vscode/vscode/vs/platform/accessibility/common/accessibility.service';
 import { DiffEditorWidget } from 'vscode/vscode/vs/editor/browser/widget/diffEditor/diffEditorWidget';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands.service';
 
 function getOptimizedNestedCodeEditorWidgetOptions() {
     return {
@@ -50,7 +51,7 @@ function getOptimizedNestedCodeEditorWidgetOptions() {
     };
 }
 let PropertyHeader = class PropertyHeader extends Disposable {
-    constructor(cell, propertyHeaderContainer, notebookEditor, accessor, contextMenuService, keybindingService, notificationService, menuService, contextKeyService, themeService, telemetryService, accessibilityService) {
+    constructor(cell, propertyHeaderContainer, notebookEditor, accessor, contextMenuService, keybindingService, commandService, notificationService, menuService, contextKeyService, themeService, telemetryService, accessibilityService) {
         super();
         this.cell = cell;
         this.propertyHeaderContainer = propertyHeaderContainer;
@@ -58,6 +59,7 @@ let PropertyHeader = class PropertyHeader extends Disposable {
         this.accessor = accessor;
         this.contextMenuService = contextMenuService;
         this.keybindingService = keybindingService;
+        this.commandService = commandService;
         this.notificationService = notificationService;
         this.menuService = menuService;
         this.contextKeyService = contextKeyService;
@@ -104,7 +106,7 @@ let PropertyHeader = class PropertyHeader extends Disposable {
                 }
                 return undefined;
             }
-        }, this.menuService, this.contextKeyService, this.contextMenuService, this.keybindingService, this.telemetryService));
+        }, this.menuService, this.contextKeyService, this.contextMenuService, this.keybindingService, this.commandService, this.telemetryService));
         this._register(this._toolbar);
         this._toolbar.context = {
             cell: this.cell
@@ -188,12 +190,13 @@ let PropertyHeader = class PropertyHeader extends Disposable {
 PropertyHeader = ( __decorate([
     ( __param(4, IContextMenuService)),
     ( __param(5, IKeybindingService)),
-    ( __param(6, INotificationService)),
-    ( __param(7, IMenuService)),
-    ( __param(8, IContextKeyService)),
-    ( __param(9, IThemeService)),
-    ( __param(10, ITelemetryService)),
-    ( __param(11, IAccessibilityService))
+    ( __param(6, ICommandService)),
+    ( __param(7, INotificationService)),
+    ( __param(8, IMenuService)),
+    ( __param(9, IContextKeyService)),
+    ( __param(10, IThemeService)),
+    ( __param(11, ITelemetryService)),
+    ( __param(12, IAccessibilityService))
 ], PropertyHeader));
 class AbstractElementRenderer extends Disposable {
     constructor(notebookEditor, cell, templateData, style, instantiationService, languageService, modelService, textModelService, contextMenuService, keybindingService, notificationService, menuService, contextKeyService, configurationService) {
@@ -578,6 +581,7 @@ class SingleSideDiffElement extends AbstractElementRenderer {
         super(notebookEditor, cell, templateData, style, instantiationService, languageService, modelService, textModelService, contextMenuService, keybindingService, notificationService, menuService, contextKeyService, configurationService);
         this.cell = cell;
         this.templateData = templateData;
+        this.updateBorders();
     }
     init() {
         this._diagonalFill = this.templateData.diagonalFill;
@@ -961,6 +965,7 @@ let ModifiedElement = class ModifiedElement extends AbstractElementRenderer {
         this.cell = cell;
         this.templateData = templateData;
         this._editorViewStateChanged = false;
+        this.updateBorders();
     }
     init() { }
     styleContainer(container) {

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

@@ -10,6 +10,7 @@ import { mimetypeIcon } from 'vscode/vscode/vs/workbench/contrib/notebook/browse
 import { StandardKeyboardEvent } from 'vscode/vscode/vs/base/browser/keyboardEvent';
 import { IQuickInputService } from 'vscode/vscode/vs/platform/quickinput/common/quickInput.service';
 
+const _moduleId = "vs/workbench/contrib/notebook/browser/diff/diffElementOutputs";
 class OutputElement extends Disposable {
     constructor(_notebookEditor, _notebookTextModel, _notebookService, _quickInputService, _diffElementViewModel, _diffSide, _nestedCell, _outputContainer, output) {
         super();
@@ -22,7 +23,7 @@ class OutputElement extends Disposable {
         this._nestedCell = _nestedCell;
         this._outputContainer = _outputContainer;
         this.output = output;
-        this.resizeListener = this._register(( new DisposableStore()));
+        this.resizeListener = this._register(( (new DisposableStore())));
     }
     render(index, beforeElement) {
         const outputItemDiv = document.createElement('div');
@@ -35,10 +36,10 @@ class OutputElement extends Disposable {
             mimeTypePicker.classList.add(...ThemeIcon.asClassNameArray(mimetypeIcon));
             mimeTypePicker.tabIndex = 0;
             mimeTypePicker.title = ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-                'mimeTypePicker',
+                _moduleId,
+                0,
                 "Choose a different output mimetype, available mimetypes: {0}",
-                ( mimeTypes.map(mimeType => mimeType.mimeType)).join(', ')
+                ( (mimeTypes.map(mimeType => mimeType.mimeType))).join(', ')
             ));
             outputItemDiv.appendChild(mimeTypePicker);
             this.resizeListener.add(addStandardDisposableListener(mimeTypePicker, 'mousedown', async (e) => {
@@ -49,7 +50,7 @@ class OutputElement extends Disposable {
                 }
             }));
             this.resizeListener.add((addDisposableListener(mimeTypePicker, EventType.KEY_DOWN, async (e) => {
-                const event = ( new StandardKeyboardEvent(e));
+                const event = ( (new StandardKeyboardEvent(e)));
                 if ((event.equals(3 ) || event.equals(10 ))) {
                     e.preventDefault();
                     e.stopPropagation();
@@ -83,18 +84,14 @@ class OutputElement extends Disposable {
     }
     _renderMissingRenderer(viewModel, preferredMimeType) {
         if (!viewModel.model.outputs.length) {
-            return this._renderMessage(viewModel, ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-                'empty',
-                "Cell has no output"
-            )));
+            return this._renderMessage(viewModel, ( localizeWithPath(_moduleId, 1, "Cell has no output")));
         }
         if (!preferredMimeType) {
-            const mimeTypes = ( viewModel.model.outputs.map(op => op.mime));
+            const mimeTypes = ( (viewModel.model.outputs.map(op => op.mime)));
             const mimeTypesMessage = mimeTypes.join(', ');
             return this._renderMessage(viewModel, ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-                'noRenderer.2',
+                _moduleId,
+                2,
                 "No renderer could be found for output. It has the following mimetypes: {0}",
                 mimeTypesMessage
             )));
@@ -117,39 +114,31 @@ class OutputElement extends Disposable {
     }
     async pickActiveMimeTypeRenderer(notebookTextModel, viewModel) {
         const [mimeTypes, currIndex] = viewModel.resolveMimeTypes(notebookTextModel, undefined);
-        const items = ( mimeTypes.filter(mimeType => mimeType.isTrusted).map((mimeType, index) => ({
+        const items = ( (mimeTypes.filter(mimeType => mimeType.isTrusted).map((mimeType, index) => ({
             label: mimeType.mimeType,
             id: mimeType.mimeType,
             index: index,
             picked: index === currIndex,
             detail: this.generateRendererInfo(mimeType.rendererId),
-            description: index === currIndex ? ( localizeWithPath(
-                'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-                'curruentActiveMimeType',
-                "Currently Active"
-            )) : undefined
-        })));
+            description: index === currIndex ? ( localizeWithPath(_moduleId, 3, "Currently Active")) : undefined
+        }))));
         const picker = this._quickInputService.createQuickPick();
         picker.items = items;
         picker.activeItems = items.filter(item => !!item.picked);
         picker.placeholder = items.length !== mimeTypes.length
             ? ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-            'promptChooseMimeTypeInSecure.placeHolder',
+            _moduleId,
+            4,
             "Select mimetype to render for current output. Rich mimetypes are available only when the notebook is trusted"
         ))
-            : ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-            'promptChooseMimeType.placeHolder',
-            "Select mimetype to render for current output"
-        ));
-        const pick = await ( new Promise(resolve => {
+            : ( localizeWithPath(_moduleId, 5, "Select mimetype to render for current output"));
+        const pick = await ( (new Promise(resolve => {
             picker.onDidAccept(() => {
                 resolve(picker.selectedItems.length === 1 ? picker.selectedItems[0].index : undefined);
                 picker.dispose();
             });
             picker.show();
-        }));
+        })));
         if (pick === undefined) {
             return;
         }
@@ -172,11 +161,7 @@ class OutputElement extends Disposable {
             const displayName = renderInfo.displayName !== '' ? renderInfo.displayName : renderInfo.id;
             return `${displayName} (${renderInfo.extensionId.value})`;
         }
-        return ( localizeWithPath(
-            'vs/workbench/contrib/notebook/browser/diff/diffElementOutputs',
-            'builtinRenderInfo',
-            "built-in"
-        ));
+        return ( localizeWithPath(_moduleId, 6, "built-in"));
     }
     getCellOutputCurrentIndex() {
         return this._diffElementViewModel.getNestedCellViewModel(this._diffSide).outputs.indexOf(this.output.model);
@@ -202,7 +187,7 @@ let OutputContainer = class OutputContainer extends Disposable {
         this._outputContainer = _outputContainer;
         this._notebookService = _notebookService;
         this._quickInputService = _quickInputService;
-        this._outputEntries = ( new Map());
+        this._outputEntries = ( (new Map()));
         this._register(this._diffElementViewModel.onDidLayoutChange(() => {
             this._outputEntries.forEach((value, key) => {
                 const index = _nestedCellViewModel.outputs.indexOf(key.model);
@@ -232,7 +217,7 @@ let OutputContainer = class OutputContainer extends Disposable {
         let prevElement = undefined;
         const outputsToRender = this._nestedCellViewModel.outputsViewModels;
         outputsToRender.reverse().forEach(output => {
-            if (( this._outputEntries.has(output))) {
+            if (( (this._outputEntries.has(output)))) {
                 prevElement = this._outputEntries.get(output).domNode;
                 return;
             }
@@ -259,8 +244,8 @@ let OutputContainer = class OutputContainer extends Disposable {
         });
     }
     _renderOutput(currOutput, index, beforeElement) {
-        if (!( this._outputEntries.has(currOutput))) {
-            this._outputEntries.set(currOutput, ( new OutputElement(
+        if (!( (this._outputEntries.has(currOutput)))) {
+            this._outputEntries.set(currOutput, ( (new OutputElement(
                 this._editor,
                 this._notebookTextModel,
                 this._notebookService,
@@ -270,15 +255,15 @@ let OutputContainer = class OutputContainer extends Disposable {
                 this._nestedCellViewModel,
                 this._outputContainer,
                 currOutput
-            )));
+            ))));
         }
         const renderElement = this._outputEntries.get(currOutput);
         renderElement.render(index, beforeElement);
     }
 };
-OutputContainer = ( __decorate([
-    ( __param(6, INotebookService)),
-    ( __param(7, IQuickInputService))
-], OutputContainer));
+OutputContainer = ( (__decorate([
+    ( (__param(6, INotebookService))),
+    ( (__param(7, IQuickInputService)))
+], OutputContainer)));
 
 export { OutputContainer, OutputElement };

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

@@ -19,43 +19,43 @@ class DiffElementViewModelBase extends Disposable {
         this._layout({ rawOutputHeight: Math.min(OUTPUT_EDITOR_HEIGHT_MAGIC, height) });
     }
     get rawOutputHeight() {
-        throw new Error('Use Cell.layoutInfo.rawOutputHeight');
+        throw ( new Error('Use Cell.layoutInfo.rawOutputHeight'));
     }
     set outputStatusHeight(height) {
         this._layout({ outputStatusHeight: height });
     }
     get outputStatusHeight() {
-        throw new Error('Use Cell.layoutInfo.outputStatusHeight');
+        throw ( new Error('Use Cell.layoutInfo.outputStatusHeight'));
     }
     set outputMetadataHeight(height) {
         this._layout({ outputMetadataHeight: height });
     }
     get outputMetadataHeight() {
-        throw new Error('Use Cell.layoutInfo.outputStatusHeight');
+        throw ( new Error('Use Cell.layoutInfo.outputStatusHeight'));
     }
     set editorHeight(height) {
         this._layout({ editorHeight: height });
     }
     get editorHeight() {
-        throw new Error('Use Cell.layoutInfo.editorHeight');
+        throw ( new Error('Use Cell.layoutInfo.editorHeight'));
     }
     set editorMargin(margin) {
         this._layout({ editorMargin: margin });
     }
     get editorMargin() {
-        throw new Error('Use Cell.layoutInfo.editorMargin');
+        throw ( new Error('Use Cell.layoutInfo.editorMargin'));
     }
     set metadataStatusHeight(height) {
         this._layout({ metadataStatusHeight: height });
     }
     get metadataStatusHeight() {
-        throw new Error('Use Cell.layoutInfo.outputStatusHeight');
+        throw ( new Error('Use Cell.layoutInfo.outputStatusHeight'));
     }
     set metadataHeight(height) {
         this._layout({ metadataHeight: height });
     }
     get metadataHeight() {
-        throw new Error('Use Cell.layoutInfo.metadataHeight');
+        throw ( new Error('Use Cell.layoutInfo.metadataHeight'));
     }
     set renderOutput(value) {
         this._renderOutput = value;

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

@@ -83,13 +83,13 @@ let DiffNestedCellViewModel = class DiffNestedCellViewModel extends Disposable {
     getOutputOffset(index) {
         this._ensureOutputsTop();
         if (index >= this._outputCollection.length) {
-            throw new Error('Output index out of range!');
+            throw ( new Error('Output index out of range!'));
         }
         return this._outputsTop.getPrefixSum(index - 1);
     }
     updateOutputHeight(index, height) {
         if (index >= this._outputCollection.length) {
-            throw new Error('Output index out of range!');
+            throw ( new Error('Output index out of range!'));
         }
         this._ensureOutputsTop();
         this._outputCollection[index] = height;