@codingame/monaco-vscode-katex-common 24.1.0

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

@@ -0,0 +1,263 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { createBareFontInfoFromRawSettings } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/config/fontInfoFromSettings';
+import { PixelRatio } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/pixelRatio';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { EditorPane } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { NOTEBOOK_MULTI_DIFF_EDITOR_ID, CellUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { FontMeasurements } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/config/fontMeasurements';
+import { NotebookOptions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/notebookOptions';
+import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
+import { NotebookMultiDiffEditorWidgetInput } from './notebookMultiDiffEditorInput.js';
+import { MultiDiffEditorWidget } from '@codingame/monaco-vscode-api/vscode/vs/editor/browser/widget/multiDiffEditor/multiDiffEditorWidget';
+import { ResourceLabel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/labels';
+import { INotebookDocumentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/notebook/common/notebookDocumentService.service';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { getIconClassesForLanguageId } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/getIconClasses';
+import { NotebookDiffViewModel } from './notebookDiffViewModel.js';
+import { NotebookDiffEditorEventDispatcher } from './eventDispatcher.js';
+import { NOTEBOOK_DIFF_CELLS_COLLAPSED, NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS, NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN } from './notebookDiffEditorBrowser.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { DiffEditorHeightCalculatorService } from './editorHeightCalculator.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+var NotebookMultiTextDiffEditor_1;
+let NotebookMultiTextDiffEditor = class NotebookMultiTextDiffEditor extends EditorPane {
+    static { NotebookMultiTextDiffEditor_1 = this; }
+    static { this.ID = NOTEBOOK_MULTI_DIFF_EDITOR_ID; }
+    get textModel() {
+        return this._model?.modified.notebook;
+    }
+    get notebookOptions() {
+        return this._notebookOptions;
+    }
+    constructor(group, instantiationService, themeService, _parentContextKeyService, notebookEditorWorkerService, configurationService, telemetryService, storageService, notebookService) {
+        super(NotebookMultiTextDiffEditor_1.ID, group, telemetryService, themeService, storageService);
+        this.instantiationService = instantiationService;
+        this._parentContextKeyService = _parentContextKeyService;
+        this.notebookEditorWorkerService = notebookEditorWorkerService;
+        this.configurationService = configurationService;
+        this.notebookService = notebookService;
+        this.modelSpecificResources = this._register(( new DisposableStore()));
+        this.ctxAllCollapsed = this._parentContextKeyService.createKey(NOTEBOOK_DIFF_CELLS_COLLAPSED.key, false);
+        this.ctxHasUnchangedCells = this._parentContextKeyService.createKey(NOTEBOOK_DIFF_HAS_UNCHANGED_CELLS.key, false);
+        this.ctxHiddenUnchangedCells = this._parentContextKeyService.createKey(NOTEBOOK_DIFF_UNCHANGED_CELLS_HIDDEN.key, true);
+        this._notebookOptions = instantiationService.createInstance(NotebookOptions, this.window, false, undefined);
+        this._register(this._notebookOptions);
+    }
+    get fontInfo() {
+        if (!this._fontInfo) {
+            this._fontInfo = this.createFontInfo();
+        }
+        return this._fontInfo;
+    }
+    layout(dimension, position) {
+        this._multiDiffEditorWidget.layout(dimension);
+    }
+    createFontInfo() {
+        const editorOptions = this.configurationService.getValue('editor');
+        return FontMeasurements.readFontInfo(this.window, createBareFontInfoFromRawSettings(editorOptions, PixelRatio.getInstance(this.window).value));
+    }
+    createEditor(parent) {
+        this._multiDiffEditorWidget = this._register(this.instantiationService.createInstance(MultiDiffEditorWidget, parent, this.instantiationService.createInstance(WorkbenchUIElementFactory)));
+        this._register(this._multiDiffEditorWidget.onDidChangeActiveControl(() => {
+            this._onDidChangeControl.fire();
+        }));
+    }
+    async setInput(input, options, context, token) {
+        super.setInput(input, options, context, token);
+        const model = await input.resolve();
+        if (this._model !== model) {
+            this._detachModel();
+            this._model = model;
+        }
+        const eventDispatcher = this.modelSpecificResources.add(( new NotebookDiffEditorEventDispatcher()));
+        const diffEditorHeightCalculator = this.instantiationService.createInstance(DiffEditorHeightCalculatorService, this.fontInfo.lineHeight);
+        this.viewModel = this.modelSpecificResources.add(( new NotebookDiffViewModel(
+            model,
+            this.notebookEditorWorkerService,
+            this.configurationService,
+            eventDispatcher,
+            this.notebookService,
+            diffEditorHeightCalculator,
+            undefined,
+            true
+        )));
+        await this.viewModel.computeDiff(this.modelSpecificResources.add(( new CancellationTokenSource())).token);
+        this.ctxHasUnchangedCells.set(this.viewModel.hasUnchangedCells);
+        this.ctxHasUnchangedCells.set(this.viewModel.hasUnchangedCells);
+        const widgetInput = this.modelSpecificResources.add(NotebookMultiDiffEditorWidgetInput.createInput(this.viewModel, this.instantiationService));
+        this.widgetViewModel = this.modelSpecificResources.add(await widgetInput.getViewModel());
+        const itemsWeHaveSeen = ( new WeakSet());
+        this.modelSpecificResources.add(autorun(reader => {
+            if (!this.widgetViewModel || !this.viewModel) {
+                return;
+            }
+            const items = this.widgetViewModel.items.read(reader);
+            const diffItems = this.viewModel.value;
+            if (items.length !== diffItems.length) {
+                return;
+            }
+            transaction((tx) => {
+                items.forEach(item => {
+                    if (( itemsWeHaveSeen.has(item))) {
+                        return;
+                    }
+                    itemsWeHaveSeen.add(item);
+                    const diffItem = diffItems.find(d => d.modifiedUri?.toString() === item.modifiedUri?.toString() && d.originalUri?.toString() === item.originalUri?.toString());
+                    if (diffItem && diffItem.type === 'unchanged') {
+                        item.collapsed.set(true, tx);
+                    }
+                });
+            });
+        }));
+        this._multiDiffEditorWidget.setViewModel(this.widgetViewModel);
+    }
+    _detachModel() {
+        this.viewModel = undefined;
+        this.modelSpecificResources.clear();
+    }
+    _generateFontFamily() {
+        return this.fontInfo.fontFamily ?? `"SF Mono", Monaco, Menlo, Consolas, "Ubuntu Mono", "Liberation Mono", "DejaVu Sans Mono", "Courier New", monospace`;
+    }
+    setOptions(options) {
+        super.setOptions(options);
+    }
+    getControl() {
+        return this._multiDiffEditorWidget.getActiveControl();
+    }
+    focus() {
+        super.focus();
+        this._multiDiffEditorWidget?.getActiveControl()?.focus();
+    }
+    hasFocus() {
+        return this._multiDiffEditorWidget?.getActiveControl()?.hasTextFocus() || super.hasFocus();
+    }
+    clearInput() {
+        super.clearInput();
+        this._multiDiffEditorWidget.setViewModel(undefined);
+        this.modelSpecificResources.clear();
+        this.viewModel = undefined;
+        this.widgetViewModel = undefined;
+    }
+    expandAll() {
+        if (this.widgetViewModel) {
+            this.widgetViewModel.expandAll();
+            this.ctxAllCollapsed.set(false);
+        }
+    }
+    collapseAll() {
+        if (this.widgetViewModel) {
+            this.widgetViewModel.collapseAll();
+            this.ctxAllCollapsed.set(true);
+        }
+    }
+    hideUnchanged() {
+        if (this.viewModel) {
+            this.viewModel.includeUnchanged = false;
+            this.ctxHiddenUnchangedCells.set(true);
+        }
+    }
+    showUnchanged() {
+        if (this.viewModel) {
+            this.viewModel.includeUnchanged = true;
+            this.ctxHiddenUnchangedCells.set(false);
+        }
+    }
+    getDiffElementViewModel(uri) {
+        if (uri.scheme === Schemas.vscodeNotebookCellOutput || uri.scheme === Schemas.vscodeNotebookCellOutputDiff ||
+            uri.scheme === Schemas.vscodeNotebookCellMetadata || uri.scheme === Schemas.vscodeNotebookCellMetadataDiff) {
+            const data = CellUri.parseCellPropertyUri(uri, uri.scheme);
+            if (data) {
+                uri = CellUri.generate(data.notebook, data.handle);
+            }
+        }
+        if (uri.scheme === Schemas.vscodeNotebookMetadata) {
+            return this.viewModel?.items.find(item => item.type === 'modifiedMetadata' ||
+                item.type === 'unchangedMetadata');
+        }
+        return this.viewModel?.items.find(c => {
+            switch (c.type) {
+                case 'delete':
+                    return c.original?.uri.toString() === ( uri.toString());
+                case 'insert':
+                    return c.modified?.uri.toString() === ( uri.toString());
+                case 'modified':
+                case 'unchanged':
+                    return c.modified?.uri.toString() === ( uri.toString()) || c.original?.uri.toString() === ( uri.toString());
+                default:
+                    return;
+            }
+        });
+    }
+};
+NotebookMultiTextDiffEditor = NotebookMultiTextDiffEditor_1 = ( __decorate([
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, INotebookEditorWorkerService)),
+    ( __param(5, IConfigurationService)),
+    ( __param(6, ITelemetryService)),
+    ( __param(7, IStorageService)),
+    ( __param(8, INotebookService))
+], NotebookMultiTextDiffEditor));
+let WorkbenchUIElementFactory = class WorkbenchUIElementFactory {
+    constructor(_instantiationService, notebookDocumentService, notebookService) {
+        this._instantiationService = _instantiationService;
+        this.notebookDocumentService = notebookDocumentService;
+        this.notebookService = notebookService;
+    }
+    createResourceLabel(element) {
+        const label = this._instantiationService.createInstance(ResourceLabel, element, {});
+        const that = this;
+        return {
+            setUri(uri, options = {}) {
+                if (!uri) {
+                    label.element.clear();
+                }
+                else {
+                    let name = '';
+                    let description = '';
+                    let extraClasses = undefined;
+                    if (uri.scheme === Schemas.vscodeNotebookCell) {
+                        const notebookDocument = uri.scheme === Schemas.vscodeNotebookCell ? that.notebookDocumentService.getNotebook(uri) : undefined;
+                        const cellIndex = Schemas.vscodeNotebookCell ? that.notebookDocumentService.getNotebook(uri)?.getCellIndex(uri) : undefined;
+                        if (notebookDocument && cellIndex !== undefined) {
+                            name = ( localize(9475, "Cell {0}", `${cellIndex + 1}`));
+                            const nb = notebookDocument ? that.notebookService.getNotebookTextModel(notebookDocument?.uri) : undefined;
+                            const cellLanguage = nb && cellIndex !== undefined ? nb.cells[cellIndex].language : undefined;
+                            extraClasses = cellLanguage ? getIconClassesForLanguageId(cellLanguage) : undefined;
+                        }
+                    }
+                    else if (uri.scheme === Schemas.vscodeNotebookCellMetadata || uri.scheme === Schemas.vscodeNotebookCellMetadataDiff) {
+                        description = ( localize(9476, "Metadata"));
+                    }
+                    else if (uri.scheme === Schemas.vscodeNotebookCellOutput || uri.scheme === Schemas.vscodeNotebookCellOutputDiff) {
+                        description = ( localize(9477, "Output"));
+                    }
+                    label.element.setResource({ name, description }, { strikethrough: options.strikethrough, forceLabel: true, hideIcon: !extraClasses, extraClasses });
+                }
+            },
+            dispose() {
+                label.dispose();
+            }
+        };
+    }
+};
+WorkbenchUIElementFactory = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, INotebookDocumentService)),
+    ( __param(2, INotebookService))
+], WorkbenchUIElementFactory));
+
+export { NotebookMultiTextDiffEditor };

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

@@ -0,0 +1,22 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
+import { ITextResourceConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { MultiDiffEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput";
+import { IResolvedMultiDiffSource, type IMultiDiffSourceResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService";
+import { IMultiDiffSourceResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service";
+import { NotebookDiffViewModel } from "./notebookDiffViewModel.js";
+import { NotebookDiffEditorInput } from "../../common/notebookDiffEditorInput.js";
+import { ITextFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service";
+export declare const NotebookMultiDiffEditorScheme = "multi-cell-notebook-diff-editor";
+export declare class NotebookMultiDiffEditorInput extends NotebookDiffEditorInput {
+    static readonly ID: string;
+    static create(instantiationService: IInstantiationService, resource: URI, name: string | undefined, description: string | undefined, originalResource: URI, viewType: string): NotebookMultiDiffEditorInput;
+}
+export declare class NotebookMultiDiffEditorWidgetInput extends MultiDiffEditorInput implements IMultiDiffSourceResolver {
+    private readonly notebookDiffViewModel;
+    static createInput(notebookDiffViewModel: NotebookDiffViewModel, instantiationService: IInstantiationService): NotebookMultiDiffEditorWidgetInput;
+    constructor(multiDiffSource: URI, notebookDiffViewModel: NotebookDiffViewModel, _textModelService: ITextModelService, _textResourceConfigurationService: ITextResourceConfigurationService, _instantiationService: IInstantiationService, _multiDiffSourceResolverService: IMultiDiffSourceResolverService, _textFileService: ITextFileService);
+    canHandleUri(uri: URI): boolean;
+    resolveDiffSource(_: URI): Promise<IResolvedMultiDiffSource>;
+}

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

@@ -0,0 +1,48 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
+import { ITextResourceConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { MultiDiffEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffEditorInput';
+import { IMultiDiffSourceResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.service';
+import { NotebookDiffEditorInput } from '../../common/notebookDiffEditorInput.js';
+import { NotebookEditorInput } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput';
+import { ITextFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/textfile/common/textfiles.service';
+
+var NotebookMultiDiffEditorWidgetInput_1;
+const NotebookMultiDiffEditorScheme = 'multi-cell-notebook-diff-editor';
+class NotebookMultiDiffEditorInput extends NotebookDiffEditorInput {
+    static { this.ID = 'workbench.input.multiDiffNotebookInput'; }
+    static create(instantiationService, resource, name, description, originalResource, viewType) {
+        const original = NotebookEditorInput.getOrCreate(instantiationService, originalResource, undefined, viewType);
+        const modified = NotebookEditorInput.getOrCreate(instantiationService, resource, undefined, viewType);
+        return instantiationService.createInstance(NotebookMultiDiffEditorInput, name, description, original, modified, viewType);
+    }
+}
+let NotebookMultiDiffEditorWidgetInput = NotebookMultiDiffEditorWidgetInput_1 = class NotebookMultiDiffEditorWidgetInput extends MultiDiffEditorInput {
+    static createInput(notebookDiffViewModel, instantiationService) {
+        const multiDiffSource = ( URI.parse(`${NotebookMultiDiffEditorScheme}:${( ( new Date()).getMilliseconds().toString()) + ( Math.random().toString())}`));
+        return instantiationService.createInstance(NotebookMultiDiffEditorWidgetInput_1, multiDiffSource, notebookDiffViewModel);
+    }
+    constructor(multiDiffSource, notebookDiffViewModel, _textModelService, _textResourceConfigurationService, _instantiationService, _multiDiffSourceResolverService, _textFileService) {
+        super(multiDiffSource, undefined, undefined, true, _textModelService, _textResourceConfigurationService, _instantiationService, _multiDiffSourceResolverService, _textFileService);
+        this.notebookDiffViewModel = notebookDiffViewModel;
+        this._register(_multiDiffSourceResolverService.registerResolver(this));
+    }
+    canHandleUri(uri) {
+        return ( uri.toString()) === ( this.multiDiffSource.toString());
+    }
+    async resolveDiffSource(_) {
+        return { resources: this.notebookDiffViewModel };
+    }
+};
+NotebookMultiDiffEditorWidgetInput = NotebookMultiDiffEditorWidgetInput_1 = ( __decorate([
+    ( __param(2, ITextModelService)),
+    ( __param(3, ITextResourceConfigurationService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IMultiDiffSourceResolverService)),
+    ( __param(6, ITextFileService))
+], NotebookMultiDiffEditorWidgetInput));
+
+export { NotebookMultiDiffEditorInput, NotebookMultiDiffEditorScheme, NotebookMultiDiffEditorWidgetInput };

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

@@ -0,0 +1,13 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+export type UnchangedEditorRegionOptions = {
+    options: {
+        enabled: boolean;
+        contextLineCount: number;
+        minimumLineCount: number;
+        revealLineCount: number;
+    };
+    readonly onDidChangeEnablement: Event<boolean>;
+};
+export declare function getUnchangedRegionSettings(configurationService: IConfigurationService): (Readonly<UnchangedEditorRegionOptions> & IDisposable);

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

@@ -0,0 +1,39 @@
+
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+function getUnchangedRegionSettings(configurationService) {
+    return createHideUnchangedRegionOptions(configurationService);
+}
+function createHideUnchangedRegionOptions(configurationService) {
+    const disposables = ( new DisposableStore());
+    const unchangedRegionsEnablementEmitter = disposables.add(( new Emitter()));
+    const result = {
+        options: {
+            enabled: configurationService.getValue('diffEditor.hideUnchangedRegions.enabled'),
+            minimumLineCount: configurationService.getValue('diffEditor.hideUnchangedRegions.minimumLineCount'),
+            contextLineCount: configurationService.getValue('diffEditor.hideUnchangedRegions.contextLineCount'),
+            revealLineCount: configurationService.getValue('diffEditor.hideUnchangedRegions.revealLineCount'),
+        },
+        onDidChangeEnablement: unchangedRegionsEnablementEmitter.event.bind(unchangedRegionsEnablementEmitter),
+        dispose: () => disposables.dispose()
+    };
+    disposables.add(configurationService.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration('diffEditor.hideUnchangedRegions.minimumLineCount')) {
+            result.options.minimumLineCount = configurationService.getValue('diffEditor.hideUnchangedRegions.minimumLineCount');
+        }
+        if (e.affectsConfiguration('diffEditor.hideUnchangedRegions.contextLineCount')) {
+            result.options.contextLineCount = configurationService.getValue('diffEditor.hideUnchangedRegions.contextLineCount');
+        }
+        if (e.affectsConfiguration('diffEditor.hideUnchangedRegions.revealLineCount')) {
+            result.options.revealLineCount = configurationService.getValue('diffEditor.hideUnchangedRegions.revealLineCount');
+        }
+        if (e.affectsConfiguration('diffEditor.hideUnchangedRegions.enabled')) {
+            result.options.enabled = configurationService.getValue('diffEditor.hideUnchangedRegions.enabled');
+            unchangedRegionsEnablementEmitter.fire(result.options.enabled);
+        }
+    }));
+    return result;
+}
+
+export { getUnchangedRegionSettings };

package/vscode/src/vs/workbench/contrib/notebook/common/model/notebookMetadataTextModel.d.ts

@@ -0,0 +1,19 @@
+import { INotebookDocumentMetadataTextModel, INotebookTextModel, NotebookDocumentMetadata, TransientDocumentMetadata } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ITextBuffer } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/model";
+export declare function getFormattedNotebookMetadataJSON(transientMetadata: TransientDocumentMetadata | undefined, metadata: NotebookDocumentMetadata): string;
+export declare class NotebookDocumentMetadataTextModel extends Disposable implements INotebookDocumentMetadataTextModel {
+    readonly notebookModel: INotebookTextModel;
+    readonly uri: URI;
+    get metadata(): NotebookDocumentMetadata;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _textBufferHash;
+    private _textBuffer?;
+    get textBuffer(): ITextBuffer;
+    constructor(notebookModel: INotebookTextModel);
+    getHash(): string;
+    getValue(): string;
+    private getFullModelRange;
+}

package/vscode/src/vs/workbench/contrib/notebook/common/model/notebookMetadataTextModel.js

@@ -0,0 +1,89 @@
+
+import { toFormattedString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonFormatter';
+import { NotebookMetadataUri, NotebookCellsChangeType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { DefaultEndOfLine, EndOfLinePreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { createTextBuffer } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+
+function getFormattedNotebookMetadataJSON(transientMetadata, metadata) {
+    let filteredMetadata = {};
+    if (transientMetadata) {
+        const keys = ( new Set([...( Object.keys(metadata))]));
+        for (const key of keys) {
+            if (!(transientMetadata[key])) {
+                filteredMetadata[key] = metadata[key];
+            }
+        }
+    }
+    else {
+        filteredMetadata = metadata;
+    }
+    const metadataSource = toFormattedString(filteredMetadata, {});
+    return metadataSource;
+}
+class NotebookDocumentMetadataTextModel extends Disposable {
+    get metadata() {
+        return this.notebookModel.metadata;
+    }
+    get textBuffer() {
+        if (this._textBuffer) {
+            return this._textBuffer;
+        }
+        const source = getFormattedNotebookMetadataJSON(this.notebookModel.transientOptions.transientDocumentMetadata, this.metadata);
+        this._textBuffer = this._register(createTextBuffer(source, DefaultEndOfLine.LF).textBuffer);
+        this._register(this._textBuffer.onDidChangeContent(() => {
+            this._onDidChange.fire();
+        }));
+        return this._textBuffer;
+    }
+    constructor(notebookModel) {
+        super();
+        this.notebookModel = notebookModel;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._textBufferHash = null;
+        this.uri = NotebookMetadataUri.generate(this.notebookModel.uri);
+        this._register(this.notebookModel.onDidChangeContent((e) => {
+            if (( e.rawEvents.some(
+                event => event.kind === NotebookCellsChangeType.ChangeDocumentMetadata || event.kind === NotebookCellsChangeType.ModelChange
+            ))) {
+                this._textBuffer?.dispose();
+                this._textBuffer = undefined;
+                this._textBufferHash = null;
+                this._onDidChange.fire();
+            }
+        }));
+    }
+    getHash() {
+        if (this._textBufferHash !== null) {
+            return this._textBufferHash;
+        }
+        const shaComputer = ( new StringSHA1());
+        const snapshot = this.textBuffer.createSnapshot(false);
+        let text;
+        while ((text = snapshot.read())) {
+            shaComputer.update(text);
+        }
+        this._textBufferHash = shaComputer.digest();
+        return this._textBufferHash;
+    }
+    getValue() {
+        const fullRange = this.getFullModelRange();
+        const eol = this.textBuffer.getEOL();
+        if (eol === '\n') {
+            return this.textBuffer.getValueInRange(fullRange, EndOfLinePreference.LF);
+        }
+        else {
+            return this.textBuffer.getValueInRange(fullRange, EndOfLinePreference.CRLF);
+        }
+    }
+    getFullModelRange() {
+        const lineCount = this.textBuffer.getLineCount();
+        return ( new Range(1, 1, lineCount, this.textBuffer.getLineLength(lineCount) + 1));
+    }
+}
+
+export { NotebookDocumentMetadataTextModel, getFormattedNotebookMetadataJSON };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiff.d.ts

@@ -0,0 +1,26 @@
+import { CellKind, INotebookDiffResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+export type CellDiffInfo = {
+    originalCellIndex: number;
+    modifiedCellIndex: number;
+    type: "unchanged" | "modified";
+} | {
+    originalCellIndex: number;
+    type: "delete";
+} | {
+    modifiedCellIndex: number;
+    type: "insert";
+};
+interface ICell {
+    cellKind: CellKind;
+    getHashValue(): number;
+    equal(cell: ICell): boolean;
+}
+export declare function computeDiff(originalModel: {
+    readonly cells: readonly ICell[];
+}, modifiedModel: {
+    readonly cells: readonly ICell[];
+}, diffResult: INotebookDiffResult): {
+    cellDiffInfo: CellDiffInfo[];
+    firstChangeIndex: number;
+};
+export {};

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiff.js

@@ -0,0 +1,92 @@
+
+
+function computeDiff(originalModel, modifiedModel, diffResult) {
+    const cellChanges = diffResult.cellsDiff.changes;
+    const cellDiffInfo = [];
+    let originalCellIndex = 0;
+    let modifiedCellIndex = 0;
+    let firstChangeIndex = -1;
+    for (let i = 0; i < cellChanges.length; i++) {
+        const change = cellChanges[i];
+        for (let j = 0; j < change.originalStart - originalCellIndex; j++) {
+            const originalCell = originalModel.cells[originalCellIndex + j];
+            const modifiedCell = modifiedModel.cells[modifiedCellIndex + j];
+            if (originalCell.getHashValue() === modifiedCell.getHashValue()) {
+                cellDiffInfo.push({
+                    originalCellIndex: originalCellIndex + j,
+                    modifiedCellIndex: modifiedCellIndex + j,
+                    type: 'unchanged'
+                });
+            }
+            else {
+                if (firstChangeIndex === -1) {
+                    firstChangeIndex = cellDiffInfo.length;
+                }
+                cellDiffInfo.push({
+                    originalCellIndex: originalCellIndex + j,
+                    modifiedCellIndex: modifiedCellIndex + j,
+                    type: 'modified'
+                });
+            }
+        }
+        const modifiedLCS = computeModifiedLCS(change, originalModel, modifiedModel);
+        if (modifiedLCS.length && firstChangeIndex === -1) {
+            firstChangeIndex = cellDiffInfo.length;
+        }
+        cellDiffInfo.push(...modifiedLCS);
+        originalCellIndex = change.originalStart + change.originalLength;
+        modifiedCellIndex = change.modifiedStart + change.modifiedLength;
+    }
+    for (let i = originalCellIndex; i < originalModel.cells.length; i++) {
+        cellDiffInfo.push({
+            originalCellIndex: i,
+            modifiedCellIndex: i - originalCellIndex + modifiedCellIndex,
+            type: 'unchanged'
+        });
+    }
+    return {
+        cellDiffInfo,
+        firstChangeIndex
+    };
+}
+function computeModifiedLCS(change, originalModel, modifiedModel) {
+    const result = [];
+    const modifiedLen = Math.min(change.originalLength, change.modifiedLength);
+    for (let j = 0; j < modifiedLen; j++) {
+        const originalCell = originalModel.cells[change.originalStart + j];
+        const modifiedCell = modifiedModel.cells[change.modifiedStart + j];
+        if (originalCell.cellKind !== modifiedCell.cellKind) {
+            result.push({
+                originalCellIndex: change.originalStart + j,
+                type: 'delete'
+            });
+            result.push({
+                modifiedCellIndex: change.modifiedStart + j,
+                type: 'insert'
+            });
+        }
+        else {
+            const isTheSame = originalCell.equal(modifiedCell);
+            result.push({
+                originalCellIndex: change.originalStart + j,
+                modifiedCellIndex: change.modifiedStart + j,
+                type: isTheSame ? 'unchanged' : 'modified'
+            });
+        }
+    }
+    for (let j = modifiedLen; j < change.originalLength; j++) {
+        result.push({
+            originalCellIndex: change.originalStart + j,
+            type: 'delete'
+        });
+    }
+    for (let j = modifiedLen; j < change.modifiedLength; j++) {
+        result.push({
+            modifiedCellIndex: change.modifiedStart + j,
+            type: 'insert'
+        });
+    }
+    return result;
+}
+
+export { computeDiff };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiffEditorInput.d.ts

@@ -0,0 +1,33 @@
+import { IResourceDiffEditorInput, IResourceSideBySideEditorInput, IUntypedEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { EditorModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorModel";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { INotebookDiffEditorModel, IResolvedNotebookEditorModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+import { DiffEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/diffEditorInput";
+import { NotebookEditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorInput";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+declare class NotebookDiffEditorModel extends EditorModel implements INotebookDiffEditorModel {
+    readonly original: IResolvedNotebookEditorModel;
+    readonly modified: IResolvedNotebookEditorModel;
+    constructor(original: IResolvedNotebookEditorModel, modified: IResolvedNotebookEditorModel);
+}
+export declare class NotebookDiffEditorInput extends DiffEditorInput {
+    readonly original: NotebookEditorInput;
+    readonly modified: NotebookEditorInput;
+    readonly viewType: string;
+    static create(instantiationService: IInstantiationService, resource: URI, name: string | undefined, description: string | undefined, originalResource: URI, viewType: string): NotebookDiffEditorInput;
+    static readonly ID: string;
+    private _modifiedTextModel;
+    private _originalTextModel;
+    get resource(): URI;
+    get editorId(): string;
+    private _cachedModel;
+    constructor(name: string | undefined, description: string | undefined, original: NotebookEditorInput, modified: NotebookEditorInput, viewType: string, editorService: IEditorService);
+    get typeId(): string;
+    resolve(): Promise<NotebookDiffEditorModel>;
+    toUntyped(): IResourceDiffEditorInput & IResourceSideBySideEditorInput;
+    matches(otherInput: EditorInput | IUntypedEditorInput): boolean;
+    dispose(): void;
+}
+export {};