@codingame/monaco-vscode-katex-common 25.1.2 → 26.0.1

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

@@ -1,51 +0,0 @@
-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

@@ -1,241 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-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

@@ -1,146 +0,0 @@
-
-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

@@ -1,28 +0,0 @@
-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

@@ -1,90 +0,0 @@
-
-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

@@ -1,10 +0,0 @@
-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

@@ -1,41 +0,0 @@
-
-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 };