@codingame/monaco-vscode-api 9.0.3 → 10.0.0

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

@@ -6,12 +6,11 @@ import { IStorageService } from '../../../../../platform/storage/common/storage.
 import { ITelemetryService } from '../../../../../platform/telemetry/common/telemetry.service.js';
 import { registerThemingParticipant } from '../../../../../platform/theme/common/themeService.js';
 import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
-import { EditorPaneSelectionChangeReason, EditorPaneSelectionCompareResult } from '../../../../common/editor.js';
 import { getDefaultNotebookCreationOptions } from '../notebookEditorWidget.js';
 import { CancellationTokenSource } from '../../../../../base/common/cancellation.js';
 import { SideBySideDiffElementViewModel } from './diffElementViewModel.js';
 import { IInstantiationService } from '../../../../../platform/instantiation/common/instantiation.js';
-import { CellDiffSingleSideRenderer, CellDiffSideBySideRenderer, CellDiffPlaceholderRenderer, NotebookTextDiffList, NotebookCellTextDiffListDelegate } from './notebookDiffList.js';
+import { CellDiffSingleSideRenderer, CellDiffSideBySideRenderer, CellDiffPlaceholderRenderer, NotebookDocumentMetadataDiffRenderer, NotebookTextDiffList, NotebookCellTextDiffListDelegate } from './notebookDiffList.js';
 import { IContextKeyService } from '../../../../../platform/contextkey/common/contextkey.service.js';
 import '../../../../../platform/theme/common/colorUtils.js';
 import { foreground, focusBorder } from '../../../../../platform/theme/common/colors/baseColors.js';
@@ -44,6 +43,7 @@ import { NotebookDiffOverviewRuler } from './notebookDiffOverviewRuler.js';
 import { registerZIndex, ZIndex } from '../../../../../platform/layout/browser/zIndexRegistry.js';
 import { NotebookDiffViewModel } from './notebookDiffViewModel.js';
 import { INotebookService } from '../../common/notebookService.service.js';
+import { DiffEditorHeightCalculatorService } from './editorHeightCalculator.js';
 var NotebookTextDiffEditor_1;
 const $ = $$1;
 class NotebookDiffEditorSelection {
@@ -52,17 +52,17 @@ class NotebookDiffEditorSelection {
     }
     compare(other) {
         if (!(other instanceof NotebookDiffEditorSelection)) {
-            return EditorPaneSelectionCompareResult.DIFFERENT;
+            return 3 ;
         }
         if (this.selections.length !== other.selections.length) {
-            return EditorPaneSelectionCompareResult.DIFFERENT;
+            return 3 ;
         }
         for (let i = 0; i < this.selections.length; i++) {
             if (this.selections[i] !== other.selections[i]) {
-                return EditorPaneSelectionCompareResult.DIFFERENT;
+                return 3 ;
             }
         }
-        return EditorPaneSelectionCompareResult.IDENTICAL;
+        return 1 ;
     }
     restore(options) {
         const notebookOptions = {
@@ -112,6 +112,7 @@ let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
         this.onDidChangeSelection = this._onDidChangeSelection.event;
         this._isDisposed = false;
         this.pendingLayouts = ( (new WeakMap()));
+        this.diffEditorCalcuator = this.instantiationService.createInstance(DiffEditorHeightCalculatorService, this.fontInfo.lineHeight);
         this._notebookOptions = instantiationService.createInstance(NotebookOptions, this.window, false, undefined);
         this._register(this._notebookOptions);
         this._revealFirst = true;
@@ -208,6 +209,7 @@ let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
             this.instantiationService.createInstance(CellDiffSingleSideRenderer, this),
             this.instantiationService.createInstance(CellDiffSideBySideRenderer, this),
             this.instantiationService.createInstance(CellDiffPlaceholderRenderer, this),
+            this.instantiationService.createInstance(NotebookDocumentMetadataDiffRenderer, this),
         ];
         this._listViewContainer = append(this._rootElement, $$1('.notebook-diff-list-view'));
         this._list = this.instantiationService.createInstance(NotebookTextDiffList, 'NotebookTextDiff', this._listViewContainer, this.instantiationService.createInstance(NotebookCellTextDiffListDelegate, this.window), renderers, this.contextKeyService, {
@@ -241,7 +243,7 @@ let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
             accessibilityProvider: {
                 getAriaLabel() { return null; },
                 getWidgetAriaLabel() {
-                    return ( localize(7878, "Notebook Text Diff"));
+                    return ( localize(7937, "Notebook Text Diff"));
                 }
             },
         });
@@ -257,7 +259,7 @@ let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
         this._register(this._list.onDidScroll(() => {
             this._onDidScroll.fire();
         }));
-        this._register(this._list.onDidChangeFocus(() => this._onDidChangeSelection.fire({ reason: EditorPaneSelectionChangeReason.USER })));
+        this._register(this._list.onDidChangeFocus(() => this._onDidChangeSelection.fire({ reason: 2  })));
         this._overviewRulerContainer = document.createElement('div');
         this._overviewRulerContainer.classList.add('notebook-overview-ruler-container');
         this._rootElement.appendChild(this._overviewRulerContainer);
@@ -391,11 +393,12 @@ let NotebookTextDiffEditor = class NotebookTextDiffEditor extends EditorPane {
             const vm = this.notebookDiffViewModel = this._register(( (new NotebookDiffViewModel(
                 this._model,
                 this.notebookEditorWorkerService,
-                this.instantiationService,
                 this.configurationService,
                 this._eventDispatcher,
                 this.notebookService,
-                this.fontInfo
+                this.diffEditorCalcuator,
+                this.fontInfo,
+                undefined
             ))));
             this._localStore.add(this.notebookDiffViewModel.onDidChangeItems(e => {
                 this._list.splice(e.start, e.deleteCount, e.elements);

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

@@ -7,22 +7,23 @@ var DiffSide;
 })(DiffSide || (DiffSide = {}))));
 const DIFF_CELL_MARGIN = 16;
 const NOTEBOOK_DIFF_CELL_INPUT = ( (new RawContextKey('notebook.diffEditor.cell.inputChanged', false)));
+const NOTEBOOK_DIFF_METADATA = ( (new RawContextKey('notebook.diffEditor.metadataChanged', false)));
 const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY = 'notebook.diffEditor.cell.ignoreWhitespace';
 const NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE = ( (new RawContextKey(NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY, false)));
 const NOTEBOOK_DIFF_CELL_PROPERTY = ( (new RawContextKey('notebook.diffEditor.cell.property.changed', false)));
 const NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED = ( (new RawContextKey('notebook.diffEditor.cell.property.expanded', false)));
-const NOTEBOOK_DIFF_CELLS_COLLAPSED = ( (new RawContextKey('notebook.diffEditor.allCollapsed', undefined, ( localize(10728, "Whether all cells in notebook diff editor are collapsed")))));
-const NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS = ( (new RawContextKey('notebook.diffEditor.hasUnchangedCells', undefined, ( localize(10729, "Whether there are unchanged cells in the notebook diff editor")))));
+const NOTEBOOK_DIFF_CELLS_COLLAPSED = ( (new RawContextKey('notebook.diffEditor.allCollapsed', undefined, ( localize(10812, "Whether all cells in notebook diff editor are collapsed")))));
+const NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS = ( (new RawContextKey('notebook.diffEditor.hasUnchangedCells', undefined, ( localize(10813, "Whether there are unchanged cells in the notebook diff editor")))));
 const NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN = ( (new RawContextKey('notebook.diffEditor.unchangedCellsAreHidden', undefined, ( localize(
- 10730,
+ 10814,
  "Whether the unchanged cells in the notebook diff editor are hidden"
 )))));
 const NOTEBOOK_DIFF_ITEM_KIND = ( (new RawContextKey('notebook.diffEditor.item.kind', undefined, ( localize(
- 10731,
+ 10815,
  "The kind of item in the notebook diff editor, Cell, Metadata or Output"
 )))));
 const NOTEBOOK_DIFF_ITEM_DIFF_STATE = ( (new RawContextKey('notebook.diffEditor.item.state', undefined, ( localize(
- 10732,
+ 10816,
  "The diff state of item in the notebook diff editor, delete, insert, modified or unchanged"
 )))));
-export { DIFF_CELL_MARGIN, DiffSide, NOTEBOOK_DIFF_CELLS_COLLAPSED, NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE, NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY, NOTEBOOK_DIFF_CELL_INPUT, NOTEBOOK_DIFF_CELL_PROPERTY, NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED, NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS, NOTEBOOK_DIFF_ITEM_DIFF_STATE, NOTEBOOK_DIFF_ITEM_KIND, NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN };
+export { DIFF_CELL_MARGIN, DiffSide, NOTEBOOK_DIFF_CELLS_COLLAPSED, NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE, NOTEBOOK_DIFF_CELL_IGNORE_WHITESPACE_KEY, NOTEBOOK_DIFF_CELL_INPUT, NOTEBOOK_DIFF_CELL_PROPERTY, NOTEBOOK_DIFF_CELL_PROPERTY_EXPANDED, NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS, NOTEBOOK_DIFF_ITEM_DIFF_STATE, NOTEBOOK_DIFF_ITEM_KIND, NOTEBOOK_DIFF_METADATA, NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN };

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

@@ -11,7 +11,7 @@ import { WorkbenchList } from '../../../../../platform/list/browser/listService.
 import { IListService } from '../../../../../platform/list/browser/listService.service.js';
 import { IThemeService } from '../../../../../platform/theme/common/themeService.service.js';
 import { DIFF_CELL_MARGIN } from './notebookDiffEditorBrowser.js';
-import { CellDiffPlaceholderElement, getOptimizedNestedCodeEditorWidgetOptions, ModifiedElement, CollapsedCellOverlayWidget, InsertElement, DeletedElement, UnchangedCellOverlayWidget } from './diffComponents.js';
+import { CellDiffPlaceholderElement, NotebookDocumentMetadataElement, InsertElement, DeletedElement, getOptimizedNestedCodeEditorWidgetOptions, CollapsedCellOverlayWidget, UnchangedCellOverlayWidget, ModifiedElement } from './diffComponents.js';
 import { CodeEditorWidget } from '../../../../../editor/browser/widget/codeEditor/codeEditorWidget.js';
 import { DiffEditorWidget } from '../../../../../editor/browser/widget/diffEditor/diffEditorWidget.js';
 import { MenuItemAction } from '../../../../../platform/actions/common/actions.js';
@@ -25,7 +25,7 @@ import { WorkbenchToolBar } from '../../../../../platform/actions/browser/toolba
 import { fixedDiffEditorOptions, fixedEditorOptions } from './diffCellEditorOptions.js';
 import { IAccessibilityService } from '../../../../../platform/accessibility/common/accessibility.service.js';
 import { localize } from '../../../../../nls.js';
-var CellDiffPlaceholderRenderer_1, CellDiffSingleSideRenderer_1, CellDiffSideBySideRenderer_1;
+var CellDiffPlaceholderRenderer_1, NotebookDocumentMetadataDiffRenderer_1, CellDiffSingleSideRenderer_1, CellDiffSideBySideRenderer_1;
 let NotebookCellTextDiffListDelegate = class NotebookCellTextDiffListDelegate {
     constructor(targetWindow, configurationService) {
         this.configurationService = configurationService;
@@ -48,6 +48,9 @@ let NotebookCellTextDiffListDelegate = class NotebookCellTextDiffListDelegate {
                 return CellDiffSideBySideRenderer.TEMPLATE_ID;
             case 'placeholder':
                 return CellDiffPlaceholderRenderer.TEMPLATE_ID;
+            case 'modifiedMetadata':
+            case 'unchangedMetadata':
+                return NotebookDocumentMetadataDiffRenderer.TEMPLATE_ID;
         }
     }
 };
@@ -70,7 +73,7 @@ let CellDiffPlaceholderRenderer = class CellDiffPlaceholderRenderer {
         const elementDisposables = ( (new DisposableStore()));
         const marginOverlay = ( (new CollapsedCellOverlayWidget(body)));
         const contents = append(body, $('.contents'));
-        const placeholder = append(contents, $('span.text', { title: ( localize(10727, 'Double click to show')) }));
+        const placeholder = append(contents, $('span.text', { title: ( localize(10811, 'Double click to show')) }));
         return {
             body,
             container,
@@ -93,6 +96,106 @@ let CellDiffPlaceholderRenderer = class CellDiffPlaceholderRenderer {
 CellDiffPlaceholderRenderer = CellDiffPlaceholderRenderer_1 = ( (__decorate([
     ( (__param(1, IInstantiationService)))
 ], CellDiffPlaceholderRenderer)));
+let NotebookDocumentMetadataDiffRenderer = class NotebookDocumentMetadataDiffRenderer {
+    static { NotebookDocumentMetadataDiffRenderer_1 = this; }
+    static { this.TEMPLATE_ID = 'notebook_metadata_diff_side_by_side'; }
+    constructor(notebookEditor, instantiationService, contextMenuService, keybindingService, menuService, contextKeyService, notificationService, themeService, accessibilityService) {
+        this.notebookEditor = notebookEditor;
+        this.instantiationService = instantiationService;
+        this.contextMenuService = contextMenuService;
+        this.keybindingService = keybindingService;
+        this.menuService = menuService;
+        this.contextKeyService = contextKeyService;
+        this.notificationService = notificationService;
+        this.themeService = themeService;
+        this.accessibilityService = accessibilityService;
+    }
+    get templateId() {
+        return NotebookDocumentMetadataDiffRenderer_1.TEMPLATE_ID;
+    }
+    renderTemplate(container) {
+        const body = $('.cell-body');
+        append(container, body);
+        const diffEditorContainer = $('.cell-diff-editor-container');
+        append(body, diffEditorContainer);
+        const cellHeaderContainer = append(diffEditorContainer, $('.input-header-container'));
+        const sourceContainer = append(diffEditorContainer, $('.source-container'));
+        const { editor, editorContainer } = this._buildSourceEditor(sourceContainer);
+        const inputToolbarContainer = append(sourceContainer, $('.editor-input-toolbar-container'));
+        const cellToolbarContainer = append(inputToolbarContainer, $('div.property-toolbar'));
+        const toolbar = this.instantiationService.createInstance(WorkbenchToolBar, cellToolbarContainer, {
+            actionViewItemProvider: (action, options) => {
+                if (action instanceof MenuItemAction) {
+                    const item = ( (new CodiconActionViewItem(
+                        action,
+                        { hoverDelegate: options.hoverDelegate },
+                        this.keybindingService,
+                        this.notificationService,
+                        this.contextKeyService,
+                        this.themeService,
+                        this.contextMenuService,
+                        this.accessibilityService
+                    )));
+                    return item;
+                }
+                return undefined;
+            },
+            highlightToggledItems: true
+        });
+        const borderContainer = append(body, $('.border-container'));
+        const leftBorder = append(borderContainer, $('.left-border'));
+        const rightBorder = append(borderContainer, $('.right-border'));
+        const topBorder = append(borderContainer, $('.top-border'));
+        const bottomBorder = append(borderContainer, $('.bottom-border'));
+        const marginOverlay = ( (new UnchangedCellOverlayWidget(body)));
+        const elementDisposables = ( (new DisposableStore()));
+        return {
+            body,
+            container,
+            diffEditorContainer,
+            cellHeaderContainer,
+            sourceEditor: editor,
+            editorContainer,
+            inputToolbarContainer,
+            toolbar,
+            leftBorder,
+            rightBorder,
+            topBorder,
+            bottomBorder,
+            marginOverlay,
+            elementDisposables
+        };
+    }
+    _buildSourceEditor(sourceContainer) {
+        return buildDiffEditorWidget(this.instantiationService, this.notebookEditor, sourceContainer, { readOnly: true });
+    }
+    renderElement(element, index, templateData, height) {
+        templateData.body.classList.remove('full');
+        templateData.elementDisposables.add(this.instantiationService.createInstance(NotebookDocumentMetadataElement, this.notebookEditor, element, templateData));
+    }
+    disposeTemplate(templateData) {
+        templateData.container.innerText = '';
+        templateData.sourceEditor.dispose();
+        templateData.toolbar?.dispose();
+        templateData.elementDisposables.dispose();
+    }
+    disposeElement(element, index, templateData) {
+        if (templateData.toolbar) {
+            templateData.toolbar.context = undefined;
+        }
+        templateData.elementDisposables.clear();
+    }
+};
+NotebookDocumentMetadataDiffRenderer = NotebookDocumentMetadataDiffRenderer_1 = ( (__decorate([
+    ( (__param(1, IInstantiationService))),
+    ( (__param(2, IContextMenuService))),
+    ( (__param(3, IKeybindingService))),
+    ( (__param(4, IMenuService))),
+    ( (__param(5, IContextKeyService))),
+    ( (__param(6, INotificationService))),
+    ( (__param(7, IThemeService))),
+    ( (__param(8, IAccessibilityService)))
+], NotebookDocumentMetadataDiffRenderer)));
 let CellDiffSingleSideRenderer = class CellDiffSingleSideRenderer {
     static { CellDiffSingleSideRenderer_1 = this; }
     static { this.TEMPLATE_ID = 'cell_diff_single'; }
@@ -141,18 +244,7 @@ let CellDiffSingleSideRenderer = class CellDiffSingleSideRenderer {
         };
     }
     _buildSourceEditor(sourceContainer) {
-        const editorContainer = append(sourceContainer, $('.editor-container'));
-        const editor = this.instantiationService.createInstance(CodeEditorWidget, editorContainer, {
-            ...fixedEditorOptions,
-            glyphMargin: false,
-            dimension: {
-                width: (this.notebookEditor.getLayoutInfo().width - 2 * DIFF_CELL_MARGIN) / 2 - 18,
-                height: 0
-            },
-            automaticLayout: false,
-            overflowWidgetsDomNode: this.notebookEditor.getOverflowContainerDomNode()
-        }, {});
-        return { editor, editorContainer };
+        return buildSourceEditor(this.instantiationService, this.notebookEditor, sourceContainer);
     }
     renderElement(element, index, templateData, height) {
         templateData.body.classList.remove('left', 'right', 'full');
@@ -256,27 +348,7 @@ let CellDiffSideBySideRenderer = class CellDiffSideBySideRenderer {
         };
     }
     _buildSourceEditor(sourceContainer) {
-        const editorContainer = append(sourceContainer, $('.editor-container'));
-        const editor = this.instantiationService.createInstance(DiffEditorWidget, editorContainer, {
-            ...fixedDiffEditorOptions,
-            overflowWidgetsDomNode: this.notebookEditor.getOverflowContainerDomNode(),
-            originalEditable: false,
-            ignoreTrimWhitespace: false,
-            automaticLayout: false,
-            dimension: {
-                height: 0,
-                width: 0
-            },
-            renderSideBySide: true,
-            useInlineViewWhenSpaceIsLimited: false
-        }, {
-            originalEditor: getOptimizedNestedCodeEditorWidgetOptions(),
-            modifiedEditor: getOptimizedNestedCodeEditorWidgetOptions()
-        });
-        return {
-            editor,
-            editorContainer
-        };
+        return buildDiffEditorWidget(this.instantiationService, this.notebookEditor, sourceContainer);
     }
     renderElement(element, index, templateData, height) {
         templateData.body.classList.remove('left', 'right', 'full');
@@ -442,4 +514,43 @@ NotebookTextDiffList = ( (__decorate([
     ( (__param(7, IConfigurationService))),
     ( (__param(8, IInstantiationService)))
 ], NotebookTextDiffList)));
-export { CellDiffPlaceholderRenderer, CellDiffSideBySideRenderer, CellDiffSingleSideRenderer, NotebookCellTextDiffListDelegate, NotebookMouseController, NotebookTextDiffList };
+function buildDiffEditorWidget(instantiationService, notebookEditor, sourceContainer, options = {}) {
+    const editorContainer = append(sourceContainer, $('.editor-container'));
+    const editor = instantiationService.createInstance(DiffEditorWidget, editorContainer, {
+        ...fixedDiffEditorOptions,
+        overflowWidgetsDomNode: notebookEditor.getOverflowContainerDomNode(),
+        originalEditable: false,
+        ignoreTrimWhitespace: false,
+        automaticLayout: false,
+        dimension: {
+            height: 0,
+            width: 0
+        },
+        renderSideBySide: true,
+        useInlineViewWhenSpaceIsLimited: false,
+        ...options
+    }, {
+        originalEditor: getOptimizedNestedCodeEditorWidgetOptions(),
+        modifiedEditor: getOptimizedNestedCodeEditorWidgetOptions()
+    });
+    return {
+        editor,
+        editorContainer
+    };
+}
+function buildSourceEditor(instantiationService, notebookEditor, sourceContainer, options = {}) {
+    const editorContainer = append(sourceContainer, $('.editor-container'));
+    const editor = instantiationService.createInstance(CodeEditorWidget, editorContainer, {
+        ...fixedEditorOptions,
+        glyphMargin: false,
+        dimension: {
+            width: (notebookEditor.getLayoutInfo().width - 2 * DIFF_CELL_MARGIN) / 2 - 18,
+            height: 0
+        },
+        automaticLayout: false,
+        overflowWidgetsDomNode: notebookEditor.getOverflowContainerDomNode(),
+        readOnly: true,
+    }, {});
+    return { editor, editorContainer };
+}
+export { CellDiffPlaceholderRenderer, CellDiffSideBySideRenderer, CellDiffSingleSideRenderer, NotebookCellTextDiffListDelegate, NotebookDocumentMetadataDiffRenderer, NotebookMouseController, NotebookTextDiffList };

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

@@ -159,8 +159,10 @@ let NotebookDiffOverviewRuler = class NotebookDiffOverviewRuler extends Themable
                     ctx.fillRect(0, currentFrom, laneWidth, cellHeight);
                     break;
                 case 'unchanged':
+                case 'unchangedMetadata':
                     break;
                 case 'modified':
+                case 'modifiedMetadata':
                     ctx.fillStyle = this._removeColorHex;
                     ctx.fillRect(0, currentFrom, laneWidth, cellHeight);
                     ctx.fillStyle = this._insertColorHex;

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

@@ -2,7 +2,7 @@ import { Emitter } from '../../../../../base/common/event.js';
 import { Disposable, DisposableStore, dispose } from '../../../../../base/common/lifecycle.js';
 import { Schemas } from '../../../../../base/common/network.js';
 import { MultiDiffEditorItem } from '../../../multiDiffEditor/browser/multiDiffSourceResolverService.js';
-import { SideBySideDiffElementViewModel, SingleSideDiffElementViewModel, DiffElementPlaceholderViewModel } from './diffElementViewModel.js';
+import { NotebookDocumentMetadataViewModel, SideBySideDiffElementViewModel, SingleSideDiffElementViewModel, DiffElementPlaceholderViewModel } from './diffElementViewModel.js';
 import { NOTEBOOK_DIFF_ITEM_KIND, NOTEBOOK_DIFF_ITEM_DIFF_STATE } from './notebookDiffEditorBrowser.js';
 import { CellUri } from '../../common/notebookCommon.js';
 class NotebookDiffViewModel extends Disposable {
@@ -28,7 +28,7 @@ class NotebookDiffViewModel extends Disposable {
             return true;
         })
             .filter(item => item instanceof NotebookMultiDiffEditorOutputItem ? !this.hideOutput : true)
-            .filter(item => item instanceof NotebookMultiDiffEditorMetadataItem ? !this.hideCellMetadata : true);
+            .filter(item => item instanceof NotebookMultiDiffEditorMetadataItem ? !this.ignoreMetadata : true);
     }
     get hasUnchangedCells() {
         return this._hasUnchangedCells === true;
@@ -40,14 +40,14 @@ class NotebookDiffViewModel extends Disposable {
         this._includeUnchanged = value;
         this._onDidChange.fire();
     }
-    constructor(model, notebookEditorWorkerService, instantiationService, configurationService, eventDispatcher, notebookService, fontInfo, excludeUnchangedPlaceholder) {
+    constructor(model, notebookEditorWorkerService, configurationService, eventDispatcher, notebookService, diffEditorHeightCalculator, fontInfo, excludeUnchangedPlaceholder) {
         super();
         this.model = model;
         this.notebookEditorWorkerService = notebookEditorWorkerService;
-        this.instantiationService = instantiationService;
         this.configurationService = configurationService;
         this.eventDispatcher = eventDispatcher;
         this.notebookService = notebookService;
+        this.diffEditorHeightCalculator = diffEditorHeightCalculator;
         this.fontInfo = fontInfo;
         this.excludeUnchangedPlaceholder = excludeUnchangedPlaceholder;
         this.placeholderAndRelatedCells = ( new Map());
@@ -60,14 +60,16 @@ class NotebookDiffViewModel extends Disposable {
         this.onDidChange = this._onDidChange.event;
         this.originalCellViewModels = [];
         this.hideOutput = this.model.modified.notebook.transientOptions.transientOutputs || this.configurationService.getValue('notebook.diff.ignoreOutputs');
-        this.hideCellMetadata = this.configurationService.getValue('notebook.diff.ignoreMetadata');
+        this.ignoreMetadata = this.configurationService.getValue('notebook.diff.ignoreMetadata');
         this._register(this.configurationService.onDidChangeConfiguration(e => {
             let triggerChange = false;
+            let metadataChanged = false;
             if (e.affectsConfiguration('notebook.diff.ignoreMetadata')) {
                 const newValue = this.configurationService.getValue('notebook.diff.ignoreMetadata');
-                if (newValue !== undefined && this.hideCellMetadata !== newValue) {
-                    this.hideCellMetadata = newValue;
+                if (newValue !== undefined && this.ignoreMetadata !== newValue) {
+                    this.ignoreMetadata = newValue;
                     triggerChange = true;
+                    metadataChanged = true;
                 }
             }
             if (e.affectsConfiguration('notebook.diff.ignoreOutputs')) {
@@ -77,6 +79,9 @@ class NotebookDiffViewModel extends Disposable {
                     triggerChange = true;
                 }
             }
+            if (metadataChanged) {
+                this.toggleNotebookMetadata();
+            }
             if (triggerChange) {
                 this._onDidChange.fire();
             }
@@ -106,11 +111,28 @@ class NotebookDiffViewModel extends Disposable {
             return;
         }
         else {
-            this.updateViewModels(cellDiffInfo);
+            await this.updateViewModels(cellDiffInfo, diffResult.metadataChanged);
             this.updateDiffEditorItems();
             return { firstChangeIndex };
         }
     }
+    toggleNotebookMetadata() {
+        if (!this.notebookMetadataViewModel) {
+            return;
+        }
+        if (this.ignoreMetadata) {
+            if (this._items.length && this._items[0] === this.notebookMetadataViewModel) {
+                this._items.splice(0, 1);
+                this._onDidChangeItems.fire({ start: 0, deleteCount: 1, elements: [] });
+            }
+        }
+        else {
+            if (!this._items.length || this._items[0] !== this.notebookMetadataViewModel) {
+                this._items.splice(0, 0, this.notebookMetadataViewModel);
+                this._onDidChangeItems.fire({ start: 0, deleteCount: 0, elements: [this.notebookMetadataViewModel] });
+            }
+        }
+    }
     updateDiffEditorItems() {
         this.diffEditorItems = [];
         const originalSourceUri = this.model.original.resource;
@@ -171,8 +193,8 @@ class NotebookDiffViewModel extends Disposable {
         });
         this._onDidChange.fire();
     }
-    updateViewModels(cellDiffInfo) {
-        const cellViewModels = createDiffViewModels(this.instantiationService, this.configurationService, this.model, this.eventDispatcher, cellDiffInfo, this.fontInfo, this.notebookService);
+    async updateViewModels(cellDiffInfo, metadataChanged) {
+        const cellViewModels = await this.createDiffViewModels(cellDiffInfo, metadataChanged);
         const oldLength = this._items.length;
         this.clear();
         this._items.splice(0, oldLength);
@@ -216,6 +238,99 @@ class NotebookDiffViewModel extends Disposable {
         });
         this._onDidChangeItems.fire({ start: 0, deleteCount: oldLength, elements: this._items });
     }
+    async createDiffViewModels(computedCellDiffs, metadataChanged) {
+        const originalModel = this.model.original.notebook;
+        const modifiedModel = this.model.modified.notebook;
+        const initData = {
+            metadataStatusHeight: this.configurationService.getValue('notebook.diff.ignoreMetadata') ? 0 : 25,
+            outputStatusHeight: this.configurationService.getValue('notebook.diff.ignoreOutputs') || !!(modifiedModel.transientOptions.transientOutputs) ? 0 : 25,
+            fontInfo: this.fontInfo
+        };
+        const viewModels = [];
+        this.notebookMetadataViewModel = this._register(( new NotebookDocumentMetadataViewModel(
+            this.model.original.notebook,
+            this.model.modified.notebook,
+            metadataChanged ? 'modifiedMetadata' : 'unchangedMetadata',
+            this.eventDispatcher,
+            initData,
+            this.notebookService,
+            this.diffEditorHeightCalculator
+        )));
+        if (!this.ignoreMetadata) {
+            if (metadataChanged) {
+                await this.notebookMetadataViewModel.computeHeights();
+            }
+            viewModels.push(this.notebookMetadataViewModel);
+        }
+        const cellViewModels = await Promise.all(( computedCellDiffs.map(async (diff) => {
+            switch (diff.type) {
+                case 'delete': {
+                    return ( new SingleSideDiffElementViewModel(
+                        originalModel,
+                        modifiedModel,
+                        originalModel.cells[diff.originalCellIndex],
+                        undefined,
+                        'delete',
+                        this.eventDispatcher,
+                        initData,
+                        this.notebookService,
+                        this.configurationService,
+                        this.diffEditorHeightCalculator,
+                        diff.originalCellIndex
+                    ));
+                }
+                case 'insert': {
+                    return ( new SingleSideDiffElementViewModel(
+                        modifiedModel,
+                        originalModel,
+                        undefined,
+                        modifiedModel.cells[diff.modifiedCellIndex],
+                        'insert',
+                        this.eventDispatcher,
+                        initData,
+                        this.notebookService,
+                        this.configurationService,
+                        this.diffEditorHeightCalculator,
+                        diff.modifiedCellIndex
+                    ));
+                }
+                case 'modified': {
+                    const viewModel = ( new SideBySideDiffElementViewModel(
+                        this.model.modified.notebook,
+                        this.model.original.notebook,
+                        originalModel.cells[diff.originalCellIndex],
+                        modifiedModel.cells[diff.modifiedCellIndex],
+                        'modified',
+                        this.eventDispatcher,
+                        initData,
+                        this.notebookService,
+                        this.configurationService,
+                        diff.originalCellIndex,
+                        this.diffEditorHeightCalculator
+                    ));
+                    await viewModel.computeEditorHeights();
+                    return viewModel;
+                }
+                case 'unchanged': {
+                    return ( new SideBySideDiffElementViewModel(
+                        this.model.modified.notebook,
+                        this.model.original.notebook,
+                        originalModel.cells[diff.originalCellIndex],
+                        modifiedModel.cells[diff.modifiedCellIndex],
+                        'unchanged',
+                        this.eventDispatcher,
+                        initData,
+                        this.notebookService,
+                        this.configurationService,
+                        diff.originalCellIndex,
+                        this.diffEditorHeightCalculator
+                    ));
+                }
+            }
+        })));
+        cellViewModels.forEach(vm => viewModels.push(vm));
+        return viewModels;
+    }
 }
 function prettyChanges(model, diffResult) {
     const changes = diffResult.changes;
@@ -333,67 +448,6 @@ function isEqual(cellDiffInfo, viewModels, model) {
     }
     return true;
 }
-function createDiffViewModels(instantiationService, configurationService, model, eventDispatcher, computedCellDiffs, fontInfo, notebookService) {
-    const originalModel = model.original.notebook;
-    const modifiedModel = model.modified.notebook;
-    const initData = {
-        metadataStatusHeight: configurationService.getValue('notebook.diff.ignoreMetadata') ? 0 : 25,
-        outputStatusHeight: configurationService.getValue('notebook.diff.ignoreOutputs') || !!(modifiedModel.transientOptions.transientOutputs) ? 0 : 25,
-        fontInfo
-    };
-    return ( computedCellDiffs.map(diff => {
-        switch (diff.type) {
-            case 'delete': {
-                return ( new SingleSideDiffElementViewModel(
-                    originalModel,
-                    modifiedModel,
-                    originalModel.cells[diff.originalCellIndex],
-                    undefined,
-                    'delete',
-                    eventDispatcher,
-                    initData,
-                    notebookService
-                ));
-            }
-            case 'insert': {
-                return ( new SingleSideDiffElementViewModel(
-                    modifiedModel,
-                    originalModel,
-                    undefined,
-                    modifiedModel.cells[diff.modifiedCellIndex],
-                    'insert',
-                    eventDispatcher,
-                    initData,
-                    notebookService
-                ));
-            }
-            case 'modified': {
-                return ( new SideBySideDiffElementViewModel(
-                    model.modified.notebook,
-                    model.original.notebook,
-                    originalModel.cells[diff.originalCellIndex],
-                    modifiedModel.cells[diff.modifiedCellIndex],
-                    'modified',
-                    eventDispatcher,
-                    initData,
-                    notebookService
-                ));
-            }
-            case 'unchanged': {
-                return ( new SideBySideDiffElementViewModel(
-                    model.modified.notebook,
-                    model.original.notebook,
-                    originalModel.cells[diff.originalCellIndex],
-                    modifiedModel.cells[diff.modifiedCellIndex],
-                    'unchanged',
-                    eventDispatcher,
-                    initData,
-                    notebookService
-                ));
-            }
-        }
-    }));
-}
 function computeModifiedLCS(change, originalModel, modifiedModel) {
     const result = [];
     const modifiedLen = Math.min(change.originalLength, change.modifiedLength);