@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,51 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILanguageService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { CellDiffInfo } from "../notebookDiffViewModel.js";
+import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { MenuId } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { IActionViewItemProvider } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar";
+export interface INotebookDeletedCellDecorator {
+    getTop(deletedIndex: number): number | undefined;
+}
+export declare class NotebookDeletedCellDecorator extends Disposable implements INotebookDeletedCellDecorator {
+    private readonly _notebookEditor;
+    private readonly toolbar;
+    private readonly languageService;
+    private readonly instantiationService;
+    private readonly zoneRemover;
+    private readonly createdViewZones;
+    private readonly deletedCellInfos;
+    constructor(_notebookEditor: INotebookEditor, toolbar: {
+        menuId: MenuId;
+        className: string;
+        telemetrySource?: string;
+        argFactory: (deletedCellIndex: number) => any;
+        actionViewItemProvider?: IActionViewItemProvider;
+    } | undefined, languageService: ILanguageService, instantiationService: IInstantiationService);
+    getTop(deletedIndex: number): number | undefined;
+    reveal(deletedIndex: number): void;
+    apply(diffInfo: CellDiffInfo[], original: NotebookTextModel): void;
+    clear(): void;
+    private _createWidget;
+    private _createWidgetImpl;
+}
+export declare class NotebookDeletedCellWidget extends Disposable {
+    private readonly _notebookEditor;
+    private readonly _toolbarOptions;
+    private readonly code;
+    private readonly language;
+    private readonly _originalIndex;
+    private readonly languageService;
+    private readonly instantiationService;
+    private readonly container;
+    constructor(_notebookEditor: INotebookEditor, _toolbarOptions: {
+        menuId: MenuId;
+        className: string;
+        telemetrySource?: string;
+        argFactory: (deletedCellIndex: number) => any;
+        actionViewItemProvider?: IActionViewItemProvider;
+    } | undefined, code: string, language: string, container: HTMLElement, _originalIndex: number, languageService: ILanguageService, instantiationService: IInstantiationService);
+    render(): Promise<number>;
+}

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

@@ -0,0 +1,241 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { createTrustedTypesPolicy } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/trustedTypes';
+import { Disposable, DisposableStore, toDisposable, dispose } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { splitLines } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import { EditorOption } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions';
+import { ILanguageService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/language.service';
+import { tokenizeToString } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/textToHtmlTokenizer';
+import { DefaultLineHeight } from '../diffElementViewModel.js';
+import { NotebookOverviewRulerLane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { createElement, append, $ } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { MenuWorkbenchToolBar, HiddenItemStrategy } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/toolbar';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ServiceCollection } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/serviceCollection';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { overviewRulerDeletedForeground } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff';
+
+const ttPolicy = createTrustedTypesPolicy('notebookRenderer', { createHTML: value => value });
+let NotebookDeletedCellDecorator = class NotebookDeletedCellDecorator extends Disposable {
+    constructor(_notebookEditor, toolbar, languageService, instantiationService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this.toolbar = toolbar;
+        this.languageService = languageService;
+        this.instantiationService = instantiationService;
+        this.zoneRemover = this._register(( new DisposableStore()));
+        this.createdViewZones = ( new Map());
+        this.deletedCellInfos = ( new Map());
+    }
+    getTop(deletedIndex) {
+        const info = this.deletedCellInfos.get(deletedIndex);
+        if (!info) {
+            return;
+        }
+        if (info.previousIndex === -1) {
+            return 0;
+        }
+        const cells = this._notebookEditor.getCellsInRange({ start: info.previousIndex, end: info.previousIndex + 1 });
+        if (!cells.length) {
+            return this._notebookEditor.getLayoutInfo().height + info.offset;
+        }
+        const cell = cells[0];
+        const cellHeight = this._notebookEditor.getHeightOfElement(cell);
+        const top = this._notebookEditor.getAbsoluteTopOfElement(cell);
+        return top + cellHeight + info.offset;
+    }
+    reveal(deletedIndex) {
+        const top = this.getTop(deletedIndex);
+        if (typeof top === 'number') {
+            this._notebookEditor.focusContainer();
+            this._notebookEditor.revealOffsetInCenterIfOutsideViewport(top);
+            const info = this.deletedCellInfos.get(deletedIndex);
+            if (info) {
+                const prevIndex = info.previousIndex === -1 ? 0 : info.previousIndex;
+                this._notebookEditor.setFocus({ start: prevIndex, end: prevIndex });
+                this._notebookEditor.setSelections([{ start: prevIndex, end: prevIndex }]);
+            }
+        }
+    }
+    apply(diffInfo, original) {
+        this.clear();
+        let currentIndex = -1;
+        const deletedCellsToRender = { cells: [], index: 0 };
+        diffInfo.forEach(diff => {
+            if (diff.type === 'delete') {
+                const deletedCell = original.cells[diff.originalCellIndex];
+                if (deletedCell) {
+                    deletedCellsToRender.cells.push({ cell: deletedCell, originalIndex: diff.originalCellIndex, previousIndex: currentIndex });
+                    deletedCellsToRender.index = currentIndex;
+                }
+            }
+            else {
+                if (deletedCellsToRender.cells.length) {
+                    this._createWidget(deletedCellsToRender.index + 1, deletedCellsToRender.cells);
+                    deletedCellsToRender.cells.length = 0;
+                }
+                currentIndex = diff.modifiedCellIndex;
+            }
+        });
+        if (deletedCellsToRender.cells.length) {
+            this._createWidget(deletedCellsToRender.index + 1, deletedCellsToRender.cells);
+        }
+    }
+    clear() {
+        this.deletedCellInfos.clear();
+        this.zoneRemover.clear();
+    }
+    _createWidget(index, cells) {
+        this._createWidgetImpl(index, cells);
+    }
+    async _createWidgetImpl(index, cells) {
+        const rootContainer = createElement('div');
+        const widgets = [];
+        const heights = await Promise.all(( cells.map(async (cell) => {
+            const widget = ( new NotebookDeletedCellWidget(
+                this._notebookEditor,
+                this.toolbar,
+                cell.cell.getValue(),
+                cell.cell.language,
+                rootContainer,
+                cell.originalIndex,
+                this.languageService,
+                this.instantiationService
+            ));
+            widgets.push(widget);
+            const height = await widget.render();
+            this.deletedCellInfos.set(cell.originalIndex, { height, previousIndex: cell.previousIndex, offset: 0 });
+            return height;
+        })));
+        Array.from(( this.deletedCellInfos.keys())).sort((a, b) => a - b).forEach((originalIndex) => {
+            const previousDeletedCell = this.deletedCellInfos.get(originalIndex - 1);
+            if (previousDeletedCell) {
+                const deletedCell = this.deletedCellInfos.get(originalIndex);
+                if (deletedCell) {
+                    deletedCell.offset = previousDeletedCell.height + previousDeletedCell.offset;
+                }
+            }
+        });
+        const totalHeight = heights.reduce((prev, curr) => prev + curr, 0);
+        this._notebookEditor.changeViewZones(accessor => {
+            const notebookViewZone = {
+                afterModelPosition: index,
+                heightInPx: totalHeight + 4,
+                domNode: rootContainer
+            };
+            const id = accessor.addZone(notebookViewZone);
+            accessor.layoutZone(id);
+            this.createdViewZones.set(index, id);
+            const deletedCellOverviewRulereDecorationIds = this._notebookEditor.deltaCellDecorations([], [{
+                    viewZoneId: id,
+                    options: {
+                        overviewRuler: {
+                            color: overviewRulerDeletedForeground,
+                            position: NotebookOverviewRulerLane.Center,
+                        }
+                    }
+                }]);
+            this.zoneRemover.add(toDisposable(() => {
+                if (this.createdViewZones.get(index) === id) {
+                    this.createdViewZones.delete(index);
+                }
+                if (!this._notebookEditor.isDisposed) {
+                    this._notebookEditor.changeViewZones(accessor => {
+                        accessor.removeZone(id);
+                        dispose(widgets);
+                    });
+                    this._notebookEditor.deltaCellDecorations(deletedCellOverviewRulereDecorationIds, []);
+                }
+            }));
+        });
+    }
+};
+NotebookDeletedCellDecorator = ( __decorate([
+    ( __param(2, ILanguageService)),
+    ( __param(3, IInstantiationService))
+], NotebookDeletedCellDecorator));
+let NotebookDeletedCellWidget = class NotebookDeletedCellWidget extends Disposable {
+    constructor(_notebookEditor, _toolbarOptions, code, language, container, _originalIndex, languageService, instantiationService) {
+        super();
+        this._notebookEditor = _notebookEditor;
+        this._toolbarOptions = _toolbarOptions;
+        this.code = code;
+        this.language = language;
+        this._originalIndex = _originalIndex;
+        this.languageService = languageService;
+        this.instantiationService = instantiationService;
+        this.container = append(container, createElement('div'));
+        this._register(toDisposable(() => {
+            container.removeChild(this.container);
+        }));
+    }
+    async render() {
+        const code = this.code;
+        const languageId = this.language;
+        const codeHtml = await tokenizeToString(this.languageService, code, languageId);
+        const fontInfo = this._notebookEditor.getBaseCellEditorOptions(languageId).value;
+        const fontFamilyVar = '--notebook-editor-font-family';
+        const fontSizeVar = '--notebook-editor-font-size';
+        const fontWeightVar = '--notebook-editor-font-weight';
+        const editor = ( this._notebookEditor.codeEditors.map(c => c[1])).find(c => c);
+        const layoutInfo = editor?.getOptions().get(EditorOption.layoutInfo);
+        const style = ``
+            + `font-family: var(${fontFamilyVar});`
+            + `font-weight: var(${fontWeightVar});`
+            + `font-size: var(${fontSizeVar});`
+            + fontInfo.lineHeight ? `line-height: ${fontInfo.lineHeight}px;` : ''
+            + layoutInfo?.contentLeft ? `margin-left: ${layoutInfo}px;` : ''
+            + `white-space: pre;`;
+        const rootContainer = this.container;
+        rootContainer.classList.add('code-cell-row');
+        if (this._toolbarOptions) {
+            const toolbar = createElement('div');
+            toolbar.className = this._toolbarOptions.className;
+            rootContainer.appendChild(toolbar);
+            const scopedInstaService = this._register(this.instantiationService.createChild(( new ServiceCollection([IContextKeyService, this._notebookEditor.scopedContextKeyService]))));
+            const toolbarWidget = scopedInstaService.createInstance(MenuWorkbenchToolBar, toolbar, this._toolbarOptions.menuId, {
+                telemetrySource: this._toolbarOptions.telemetrySource,
+                hiddenItemStrategy: HiddenItemStrategy.NoHide,
+                toolbarOptions: { primaryGroup: () => true },
+                menuOptions: {
+                    renderShortTitle: true,
+                    arg: this._toolbarOptions.argFactory(this._originalIndex),
+                },
+                actionViewItemProvider: this._toolbarOptions.actionViewItemProvider
+            });
+            this._store.add(toolbarWidget);
+            toolbar.style.position = 'absolute';
+            toolbar.style.right = '40px';
+            toolbar.style.zIndex = '10';
+            toolbar.classList.add('hover');
+        }
+        const container = append(rootContainer, $('.cell-inner-container'));
+        container.style.position = 'relative';
+        const focusIndicatorLeft = append(container, $('.cell-focus-indicator.cell-focus-indicator-side.cell-focus-indicator-left'));
+        const cellContainer = append(container, $('.cell.code'));
+        append(focusIndicatorLeft, $('div.execution-count-label'));
+        const editorPart = append(cellContainer, $('.cell-editor-part'));
+        let editorContainer = append(editorPart, $('.cell-editor-container'));
+        editorContainer = append(editorContainer, $('.code', { style }));
+        if (fontInfo.fontFamily) {
+            editorContainer.style.setProperty(fontFamilyVar, fontInfo.fontFamily);
+        }
+        if (fontInfo.fontSize) {
+            editorContainer.style.setProperty(fontSizeVar, `${fontInfo.fontSize}px`);
+        }
+        if (fontInfo.fontWeight) {
+            editorContainer.style.setProperty(fontWeightVar, fontInfo.fontWeight);
+        }
+        editorContainer.innerHTML = (ttPolicy?.createHTML(codeHtml) || codeHtml);
+        const lineCount = splitLines(code).length;
+        const height = (lineCount * (fontInfo.lineHeight || DefaultLineHeight)) + 12 + 12;
+        const totalHeight = height + 16 + 16;
+        return totalHeight;
+    }
+};
+NotebookDeletedCellWidget = ( __decorate([
+    ( __param(6, ILanguageService)),
+    ( __param(7, IInstantiationService))
+], NotebookDeletedCellWidget));
+
+export { NotebookDeletedCellDecorator, NotebookDeletedCellWidget };

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

@@ -0,0 +1,24 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotebookEditorWorkerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service";
+import { INotebookEditorContribution, INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { INotebookLoggingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
+export declare class NotebookInlineDiffDecorationContribution extends Disposable implements INotebookEditorContribution {
+    private readonly notebookEditor;
+    private readonly notebookEditorWorkerService;
+    private readonly instantiationService;
+    private readonly logService;
+    static ID: string;
+    private previous?;
+    private insertedCellDecorator;
+    private deletedCellDecorator;
+    private readonly cellDecorators;
+    private cachedNotebookDiff?;
+    private listeners;
+    constructor(notebookEditor: INotebookEditor, notebookEditorWorkerService: INotebookEditorWorkerService, instantiationService: IInstantiationService, logService: INotebookLoggingService);
+    private clear;
+    dispose(): void;
+    private initialize;
+    private _update;
+    private updateCells;
+}

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

@@ -0,0 +1,146 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
+import { registerNotebookContribution } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { NotebookCellDiffDecorator } from './notebookCellDiffDecorator.js';
+import { NotebookDeletedCellDecorator } from './notebookDeletedCellDecorator.js';
+import { NotebookInsertedCellDecorator } from './notebookInsertedCellDecorator.js';
+import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
+import { computeDiff } from '../../../common/notebookDiff.js';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import './notebookOriginalModelRefFactory.js';
+import './notebookOriginalCellModelFactory.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let NotebookInlineDiffDecorationContribution = class NotebookInlineDiffDecorationContribution extends Disposable {
+    static { this.ID = 'workbench.notebook.inlineDiffDecoration'; }
+    constructor(notebookEditor, notebookEditorWorkerService, instantiationService, logService) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.cellDecorators = ( new Map());
+        this.listeners = [];
+        this.logService.debug('inlineDiff', 'Watching for previous model');
+        this._register(autorun((reader) => {
+            this.previous = this.notebookEditor.notebookOptions.previousModelToCompare.read(reader);
+            if (this.previous) {
+                this.logService.debug('inlineDiff', 'Previous model set');
+                if (this.notebookEditor.hasModel()) {
+                    this.initialize();
+                }
+                else {
+                    this.logService.debug('inlineDiff', 'Waiting for model to attach');
+                    this.listeners.push(Event.once(this.notebookEditor.onDidAttachViewModel)(() => this.initialize()));
+                }
+            }
+        }));
+    }
+    clear() {
+        this.listeners.forEach(l => l.dispose());
+        this.cellDecorators.forEach((v, cell) => {
+            v.dispose();
+            this.cellDecorators.delete(cell);
+        });
+        this.insertedCellDecorator?.dispose();
+        this.deletedCellDecorator?.dispose();
+        this.cachedNotebookDiff = undefined;
+        this.listeners = [];
+        this.logService.debug('inlineDiff', 'Cleared decorations and listeners');
+    }
+    dispose() {
+        this.logService.debug('inlineDiff', 'Disposing');
+        this.clear();
+        super.dispose();
+    }
+    initialize() {
+        this.clear();
+        if (!this.previous) {
+            return;
+        }
+        this.insertedCellDecorator = this.instantiationService.createInstance(NotebookInsertedCellDecorator, this.notebookEditor);
+        this.deletedCellDecorator = this.instantiationService.createInstance(NotebookDeletedCellDecorator, this.notebookEditor, undefined);
+        this._update();
+        const onVisibleChange = Event.debounce(this.notebookEditor.onDidChangeVisibleRanges, (e) => e, 100, undefined, undefined, undefined, this._store);
+        this.listeners.push(onVisibleChange(() => this._update()));
+        this.listeners.push(this.notebookEditor.onDidChangeModel(() => this._update()));
+        if (this.notebookEditor.textModel) {
+            const onContentChange = Event.debounce(this.notebookEditor.textModel.onDidChangeContent, (_, event) => event, 100, undefined, undefined, undefined, this._store);
+            const onOriginalContentChange = Event.debounce(this.previous.onDidChangeContent, (_, event) => event, 100, undefined, undefined, undefined, this._store);
+            this.listeners.push(onContentChange(() => this._update()));
+            this.listeners.push(onOriginalContentChange(() => this._update()));
+        }
+        this.logService.debug('inlineDiff', 'Initialized');
+    }
+    async _update() {
+        const current = this.notebookEditor.getViewModel()?.notebookDocument;
+        if (!this.previous || !current) {
+            this.logService.debug('inlineDiff', 'Update skipped - no original or current document');
+            return;
+        }
+        if (!this.cachedNotebookDiff ||
+            this.cachedNotebookDiff.originalVersion !== this.previous.versionId ||
+            this.cachedNotebookDiff.version !== current.versionId) {
+            let diffInfo = { cellDiffInfo: [] };
+            try {
+                const notebookDiff = await this.notebookEditorWorkerService.computeDiff(this.previous.uri, current.uri);
+                diffInfo = computeDiff(this.previous, current, notebookDiff);
+            }
+            catch (e) {
+                this.logService.error('inlineDiff', 'Error computing diff:\n' + e);
+                return;
+            }
+            this.cachedNotebookDiff = { cellDiffInfo: diffInfo.cellDiffInfo, originalVersion: this.previous.versionId, version: current.versionId };
+            this.insertedCellDecorator?.apply(diffInfo.cellDiffInfo);
+            this.deletedCellDecorator?.apply(diffInfo.cellDiffInfo, this.previous);
+        }
+        await this.updateCells(this.previous, current, this.cachedNotebookDiff.cellDiffInfo);
+    }
+    async updateCells(original, modified, cellDiffs) {
+        const validDiffDecorators = ( new Set());
+        cellDiffs.forEach((diff) => {
+            if (diff.type === 'modified') {
+                const modifiedCell = modified.cells[diff.modifiedCellIndex];
+                const originalCell = original.cells[diff.originalCellIndex];
+                const editor = this.notebookEditor.codeEditors.find(([vm,]) => vm.handle === modifiedCell.handle)?.[1];
+                if (editor) {
+                    const currentDecorator = this.cellDecorators.get(modifiedCell);
+                    if ((currentDecorator?.modifiedCell !== modifiedCell || currentDecorator?.originalCell !== originalCell)) {
+                        currentDecorator?.dispose();
+                        const decorator = this.instantiationService.createInstance(NotebookCellDiffDecorator, this.notebookEditor, modifiedCell, originalCell, editor);
+                        this.cellDecorators.set(modifiedCell, decorator);
+                        validDiffDecorators.add(decorator);
+                        this._register(editor.onDidDispose(() => {
+                            decorator.dispose();
+                            if (this.cellDecorators.get(modifiedCell) === decorator) {
+                                this.cellDecorators.delete(modifiedCell);
+                            }
+                        }));
+                    }
+                    else if (currentDecorator) {
+                        validDiffDecorators.add(currentDecorator);
+                    }
+                }
+            }
+        });
+        this.cellDecorators.forEach((v, cell) => {
+            if (!( validDiffDecorators.has(v))) {
+                v.dispose();
+                this.cellDecorators.delete(cell);
+            }
+        });
+    }
+};
+NotebookInlineDiffDecorationContribution = ( __decorate([
+    ( __param(1, INotebookEditorWorkerService)),
+    ( __param(2, IInstantiationService)),
+    ( __param(3, INotebookLoggingService))
+], NotebookInlineDiffDecorationContribution));
+registerNotebookContribution(NotebookInlineDiffDecorationContribution.ID, NotebookInlineDiffDecorationContribution);
+
+export { NotebookInlineDiffDecorationContribution };

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

@@ -0,0 +1,28 @@
+import * as DOM from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { CodeWindow } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/window";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { NotebookTextModel } from "@codingame/monaco-vscode-notebook-service-override/vscode/vs/workbench/contrib/notebook/common/model/notebookTextModel";
+import { NotebookDiffEditorInput } from "../../../common/notebookDiffEditorInput.js";
+import { INotebookEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+import { NotebookEditorWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditorWidget";
+import { NotebookOptions } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookOptions";
+import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
+export declare class NotebookInlineDiffWidget extends Disposable {
+    private readonly rootElement;
+    private readonly groupId;
+    private readonly window;
+    private readonly options;
+    private dimension;
+    private readonly instantiationService;
+    private readonly widgetService;
+    private widget;
+    private position;
+    get editorWidget(): NotebookEditorWidget | undefined;
+    constructor(rootElement: HTMLElement, groupId: number, window: CodeWindow, options: NotebookOptions, dimension: DOM.Dimension | undefined, instantiationService: IInstantiationService, widgetService: INotebookEditorService);
+    show(input: NotebookDiffEditorInput, model: NotebookTextModel | undefined, previousModel: NotebookTextModel | undefined, options: INotebookEditorOptions | undefined): Promise<void>;
+    hide(): void;
+    setLayout(dimension: DOM.Dimension, position: DOM.IDomPosition): void;
+    private createNotebookWidget;
+    dispose(): void;
+}

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

@@ -0,0 +1,90 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { setParentFlowTo } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { EditorExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorExtensions';
+import { MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { NotebookInlineDiffDecorationContribution } from './notebookInlineDiff.js';
+import { NotebookEditorExtensionsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookEditorExtensions';
+import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
+
+let NotebookInlineDiffWidget = class NotebookInlineDiffWidget extends Disposable {
+    get editorWidget() {
+        return this.widget.value;
+    }
+    constructor(rootElement, groupId, window, options, dimension, instantiationService, widgetService) {
+        super();
+        this.rootElement = rootElement;
+        this.groupId = groupId;
+        this.window = window;
+        this.options = options;
+        this.dimension = dimension;
+        this.instantiationService = instantiationService;
+        this.widgetService = widgetService;
+        this.widget = { value: undefined };
+    }
+    async show(input, model, previousModel, options) {
+        if (!this.widget.value) {
+            this.createNotebookWidget(input, this.groupId, this.rootElement);
+        }
+        if (this.dimension) {
+            this.widget.value?.layout(this.dimension, this.rootElement, this.position);
+        }
+        if (model) {
+            await this.widget.value?.setOptions({ ...options });
+            this.widget.value?.notebookOptions.previousModelToCompare.set(previousModel, undefined);
+            await this.widget.value.setModel(model, options?.viewState);
+        }
+    }
+    hide() {
+        if (this.widget.value) {
+            this.widget.value.notebookOptions.previousModelToCompare.set(undefined, undefined);
+            this.widget.value.onWillHide();
+        }
+    }
+    setLayout(dimension, position) {
+        this.dimension = dimension;
+        this.position = position;
+    }
+    createNotebookWidget(input, groupId, rootElement) {
+        const contributions = NotebookEditorExtensionsRegistry.getSomeEditorContributions([NotebookInlineDiffDecorationContribution.ID]);
+        const menuIds = {
+            notebookToolbar: MenuId.NotebookToolbar,
+            cellTitleToolbar: MenuId.NotebookCellTitle,
+            cellDeleteToolbar: MenuId.NotebookCellDelete,
+            cellInsertToolbar: MenuId.NotebookCellBetween,
+            cellTopInsertToolbar: MenuId.NotebookCellListTop,
+            cellExecuteToolbar: MenuId.NotebookCellExecute,
+            cellExecutePrimary: undefined,
+        };
+        const skipContributions = [
+            'editor.contrib.review',
+            'editor.contrib.floatingClickMenu',
+            'editor.contrib.dirtydiff',
+            'editor.contrib.testingOutputPeek',
+            'editor.contrib.testingDecorations',
+            'store.contrib.stickyScrollController',
+            'editor.contrib.findController',
+            'editor.contrib.emptyTextEditorHint',
+        ];
+        const cellEditorContributions = EditorExtensionsRegistry.getEditorContributions().filter(c => skipContributions.indexOf(c.id) === -1);
+        this.widget = this.instantiationService.invokeFunction(this.widgetService.retrieveWidget, groupId, input, { contributions, menuIds, cellEditorContributions, options: this.options }, this.dimension, this.window);
+        if (this.rootElement && this.widget.value.getDomNode()) {
+            this.rootElement.setAttribute('aria-flowto', this.widget.value.getDomNode().id || '');
+            setParentFlowTo(this.widget.value.getDomNode(), this.rootElement);
+        }
+    }
+    dispose() {
+        super.dispose();
+        if (this.widget.value) {
+            this.widget.value.dispose();
+        }
+    }
+};
+NotebookInlineDiffWidget = ( __decorate([
+    ( __param(5, IInstantiationService)),
+    ( __param(6, INotebookEditorService))
+], NotebookInlineDiffWidget));
+
+export { NotebookInlineDiffWidget };

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

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { CellDiffInfo } from "../notebookDiffViewModel.js";
+import { INotebookEditor } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser";
+export declare class NotebookInsertedCellDecorator extends Disposable {
+    private readonly notebookEditor;
+    private readonly decorators;
+    constructor(notebookEditor: INotebookEditor);
+    apply(diffInfo: CellDiffInfo[]): void;
+    clear(): void;
+}

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

@@ -0,0 +1,41 @@
+
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { NotebookOverviewRulerLane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
+import { overviewRulerAddedForeground } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/quickDiff';
+
+class NotebookInsertedCellDecorator extends Disposable {
+    constructor(notebookEditor) {
+        super();
+        this.notebookEditor = notebookEditor;
+        this.decorators = this._register(( new DisposableStore()));
+    }
+    apply(diffInfo) {
+        const model = this.notebookEditor.textModel;
+        if (!model) {
+            return;
+        }
+        const cells = ( diffInfo.filter(diff => diff.type === 'insert').map((diff) => model.cells[diff.modifiedCellIndex]));
+        const ids = this.notebookEditor.deltaCellDecorations([], ( cells.map(cell => ({
+            handle: cell.handle,
+            options: {
+                className: 'nb-insertHighlight', outputClassName: 'nb-insertHighlight', overviewRuler: {
+                    color: overviewRulerAddedForeground,
+                    modelRanges: [],
+                    includeOutput: true,
+                    position: NotebookOverviewRulerLane.Full
+                }
+            }
+        }))));
+        this.clear();
+        this.decorators.add(toDisposable(() => {
+            if (!this.notebookEditor.isDisposed) {
+                this.notebookEditor.deltaCellDecorations(ids, []);
+            }
+        }));
+    }
+    clear() {
+        this.decorators.clear();
+    }
+}
+
+export { NotebookInsertedCellDecorator };