@codingame/monaco-vscode-notebook-service-override 15.0.3 → 16.0.0

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.d.ts

@@ -1,64 +0,0 @@
-import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
-import { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
-import { NotebookTextModel } from "../../../common/model/notebookTextModel.js";
-import { CellDiffInfo } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel";
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-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 { INotebookLoggingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service";
-import { INotebookEditorModelResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service";
-import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service";
-import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
-import { INotebookOriginalModelReferenceFactory } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.service";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { ITextModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service";
-import { INotebookEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service";
-import { IModelService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service";
-import { INotebookModelSynchronizerFactory } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.service";
-export declare class NotebookModelSynchronizerFactory implements INotebookModelSynchronizerFactory {
-    readonly _serviceBrand: undefined;
-    private readonly _data;
-    constructor(instantiationService: IInstantiationService);
-    getOrCreate(model: NotebookTextModel): IReference<NotebookModelSynchronizer>;
-}
-export declare class NotebookModelSynchronizer extends Disposable {
-    private readonly model;
-    private readonly notebookService;
-    private readonly notebookEditorService;
-    private readonly modelService;
-    private readonly textModelService;
-    private readonly logService;
-    private readonly configurationService;
-    private readonly notebookEditorWorkerService;
-    private readonly notebookModelResolverService;
-    private readonly originalModelRefFactory;
-    private readonly throttledUpdateNotebookModel;
-    private _diffInfo;
-    get diffInfo(): IObservable<{
-        cellDiff: CellDiffInfo[];
-        modelVersion: number;
-    } | undefined>;
-    private snapshot?;
-    private isEditFromUs;
-    private isTextEditFromUs;
-    private isReverting;
-    private throttledTextModelUpdate;
-    constructor(model: NotebookTextModel, _chatEditingService: IChatEditingService, notebookService: INotebookService, notebookEditorService: INotebookEditorService, chatService: IChatService, modelService: IModelService, textModelService: ITextModelService, logService: INotebookLoggingService, configurationService: IConfigurationService, notebookEditorWorkerService: INotebookEditorWorkerService, notebookModelResolverService: INotebookEditorModelResolverService, originalModelRefFactory: INotebookOriginalModelReferenceFactory);
-    private createSnapshot;
-    revert(): Promise<void>;
-    private revertImpl;
-    private updateNotebook;
-    private accept;
-    private updateTextDocumentModel;
-    getNotebookSerializer(): Promise<import("@codingame/monaco-vscode-9b5a5e82-d649-5455-b4bf-ef90d6afd294-common/vscode/vs/workbench/contrib/notebook/common/notebookService").INotebookSerializer>;
-    private _originalModel?;
-    private getOriginalModel;
-    private updateNotebookModel;
-    private previousUriOfModelForDiff?;
-    private getModifiedModelForDiff;
-    computeDiff(original: NotebookTextModel, modified: NotebookTextModel, token: CancellationToken): Promise<{
-        cellDiffInfo: CellDiffInfo[];
-        firstChangeIndex: number;
-    } | undefined>;
-}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizer.js

@@ -1,443 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-import { ReferenceCollection, Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
-import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { VSBuffer, streamToBuffer, bufferToStream } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
-import { ThrottledDelayer, raceCancellation } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { prettyChanges, computeDiff } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/diff/notebookDiffViewModel';
-import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { INotebookEditorWorkerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/services/notebookWorkerService.service';
-import { NotebookSetting, CellEditType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { EditOperation } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/editOperation';
-import { INotebookLoggingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService.service';
-import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
-import { INotebookEditorModelResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookEditorModelResolverService.service';
-import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService.service';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { INotebookOriginalModelReferenceFactory } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookOriginalModelRefFactory.service';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
-import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
-import { SnapshotContext } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/fileWorkingCopy';
-import { INotebookEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService.service';
-import { CellEditState } from '@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/notebook/browser/notebookBrowser';
-import { IModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/model.service';
-import { ChatEditingModifiedDocumentEntry } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedDocumentEntry';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/base';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/derived';
-import { autorunWithStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/autorun';
-
-let NotebookModelSynchronizerReferenceCollection = class NotebookModelSynchronizerReferenceCollection extends ReferenceCollection {
-    constructor(instantiationService) {
-        super();
-        this.instantiationService = instantiationService;
-    }
-    createReferencedObject(_key, model) {
-        return this.instantiationService.createInstance(NotebookModelSynchronizer, model);
-    }
-    destroyReferencedObject(_key, object) {
-        object.dispose();
-    }
-};
-NotebookModelSynchronizerReferenceCollection = ( __decorate([
-    ( __param(0, IInstantiationService))
-], NotebookModelSynchronizerReferenceCollection));
-let NotebookModelSynchronizerFactory = class NotebookModelSynchronizerFactory {
-    constructor(instantiationService) {
-        this._data = instantiationService.createInstance(NotebookModelSynchronizerReferenceCollection);
-    }
-    getOrCreate(model) {
-        return this._data.acquire(( model.uri.toString()), model);
-    }
-};
-NotebookModelSynchronizerFactory = ( __decorate([
-    ( __param(0, IInstantiationService))
-], NotebookModelSynchronizerFactory));
-let NotebookModelSynchronizer = class NotebookModelSynchronizer extends Disposable {
-    get diffInfo() {
-        return this._diffInfo;
-    }
-    constructor(model, _chatEditingService, notebookService, notebookEditorService, chatService, modelService, textModelService, logService, configurationService, notebookEditorWorkerService, notebookModelResolverService, originalModelRefFactory) {
-        super();
-        this.model = model;
-        this.notebookService = notebookService;
-        this.notebookEditorService = notebookEditorService;
-        this.modelService = modelService;
-        this.textModelService = textModelService;
-        this.logService = logService;
-        this.configurationService = configurationService;
-        this.notebookEditorWorkerService = notebookEditorWorkerService;
-        this.notebookModelResolverService = notebookModelResolverService;
-        this.originalModelRefFactory = originalModelRefFactory;
-        this.throttledUpdateNotebookModel = ( new ThrottledDelayer(200));
-        this._diffInfo = observableValue('diffInfo', undefined);
-        this.isEditFromUs = false;
-        this.isTextEditFromUs = false;
-        this.isReverting = false;
-        this.throttledTextModelUpdate = ( new ThrottledDelayer(100));
-        const entryObs = derived((r) => {
-            const sessions = _chatEditingService.editingSessionsObs.read(r);
-            const entry = ( sessions.map(s => s.readEntry(model.uri, r))).find(r => !!r);
-            return entry instanceof ChatEditingModifiedDocumentEntry ? entry : undefined;
-        }).recomputeInitiallyAndOnChange(this._store);
-        this._register(chatService.onDidPerformUserAction(async (e) => {
-            const entry = entryObs.read(undefined);
-            if (!entry) {
-                return;
-            }
-            if (e.action.kind === 'chatEditingSessionAction' && !e.action.hasRemainingEdits && isEqual(e.action.uri, entry.modifiedURI)) {
-                if (e.action.outcome === 'accepted') {
-                    await this.accept(entry);
-                    await this.createSnapshot();
-                    this._diffInfo.set(undefined, undefined);
-                }
-                else if (e.action.outcome === 'rejected') {
-                    await this.revertImpl();
-                }
-            }
-        }));
-        const updateNotebookModel = (entry, token) => {
-            this.throttledUpdateNotebookModel.trigger(() => this.updateNotebookModel(entry, token));
-        };
-        let snapshotCreated = false;
-        this._register(autorunWithStore((r, store) => {
-            const entry = entryObs.read(r);
-            if (!entry) {
-                return;
-            }
-            if (!snapshotCreated) {
-                this.createSnapshot();
-                snapshotCreated = true;
-            }
-            const modifiedModel = this.modelService.getModel(entry.modifiedURI);
-            if (!modifiedModel) {
-                return;
-            }
-            let cancellationToken = store.add(( new CancellationTokenSource()));
-            store.add(modifiedModel.onDidChangeContent(async () => {
-                const originalModel = this.modelService.getModel(entry.originalURI);
-                if (originalModel && !this.isTextEditFromUs && !modifiedModel.isDisposed() && !originalModel.isDisposed() && modifiedModel.getValue() !== originalModel.getValue()) {
-                    cancellationToken = store.add(( new CancellationTokenSource()));
-                    updateNotebookModel(entry, cancellationToken.token);
-                }
-            }));
-            updateNotebookModel(entry, cancellationToken.token);
-        }));
-        this._register(model.onDidChangeContent(() => {
-            if (!this.isEditFromUs && this.snapshot) {
-                this.snapshot.dirty = true;
-                const entry = entryObs.get();
-                if (entry) {
-                    this.throttledTextModelUpdate.trigger(() => this.updateTextDocumentModel(entry));
-                }
-            }
-        }));
-    }
-    async createSnapshot() {
-        const [serializer, ref] = await Promise.all([
-            this.getNotebookSerializer(),
-            this.notebookModelResolverService.resolve(this.model.uri)
-        ]);
-        try {
-            const data = {
-                metadata: filter(this.model.metadata, key => !serializer.options.transientDocumentMetadata[key]),
-                cells: [],
-            };
-            const indentAmount = this.model.metadata.indentAmount || ref.object.notebook.metadata.indentAmount || undefined;
-            if (typeof indentAmount === 'string' && indentAmount) {
-                data.metadata.indentAmount = indentAmount;
-            }
-            let outputSize = 0;
-            for (const cell of this.model.cells) {
-                const cellData = {
-                    cellKind: cell.cellKind,
-                    language: cell.language,
-                    mime: cell.mime,
-                    source: cell.getValue(),
-                    outputs: [],
-                    internalMetadata: cell.internalMetadata
-                };
-                const outputSizeLimit = this.configurationService.getValue(NotebookSetting.outputBackupSizeLimit) * 1024;
-                if (outputSizeLimit > 0) {
-                    cell.outputs.forEach(output => {
-                        output.outputs.forEach(item => {
-                            outputSize += item.data.byteLength;
-                        });
-                    });
-                    if (outputSize > outputSizeLimit) {
-                        return;
-                    }
-                }
-                cellData.outputs = !serializer.options.transientOutputs ? cell.outputs : [];
-                cellData.metadata = filter(cell.metadata, key => !serializer.options.transientCellMetadata[key]);
-                data.cells.push(cellData);
-            }
-            const bytes = await serializer.notebookToData(data);
-            this.snapshot = { bytes, dirty: ref.object.isDirty() };
-        }
-        finally {
-            ref.dispose();
-        }
-    }
-    async revert() {
-        await this.revertImpl();
-    }
-    async revertImpl() {
-        if (!this.snapshot || this.isReverting) {
-            return;
-        }
-        this.isReverting = true;
-        try {
-            await this.updateNotebook(this.snapshot.bytes, !this.snapshot.dirty);
-        }
-        finally {
-            this.isReverting = false;
-            this._diffInfo.set(undefined, undefined);
-        }
-    }
-    async updateNotebook(bytes, saveForRevert) {
-        const oldEditIsFromus = this.isEditFromUs;
-        this.isEditFromUs = true;
-        const ref = await this.notebookModelResolverService.resolve(this.model.uri);
-        try {
-            const serializer = await this.getNotebookSerializer();
-            const data = await serializer.dataToNotebook(bytes);
-            this.model.reset(data.cells, data.metadata, serializer.options);
-            if (saveForRevert) {
-                await ref.object.save({ reason: SaveReason.EXPLICIT, force: true, ignoreModifiedSince: true });
-            }
-        }
-        finally {
-            ref.dispose();
-            this.isEditFromUs = oldEditIsFromus;
-        }
-    }
-    async accept(entry) {
-        const modifiedModel = this.modelService.getModel(entry.modifiedURI);
-        if (!modifiedModel) {
-            return;
-        }
-        const content = modifiedModel.getValue();
-        await this.updateNotebook(VSBuffer.fromString(content), false);
-        this._diffInfo.set(undefined, undefined);
-        const stream = await this.notebookService.createNotebookTextDocumentSnapshot(this.model.uri, SnapshotContext.Save, CancellationToken.None);
-        const originalModel = await this.getOriginalModel(entry);
-        await this.notebookService.restoreNotebookTextModelFromSnapshot(originalModel.uri, originalModel.viewType, stream);
-    }
-    async updateTextDocumentModel(entry) {
-        const modifiedModel = this.modelService.getModel(entry.modifiedURI);
-        if (!modifiedModel) {
-            return;
-        }
-        const stream = await this.notebookService.createNotebookTextDocumentSnapshot(this.model.uri, SnapshotContext.Save, CancellationToken.None);
-        const buffer = await streamToBuffer(stream);
-        const text = ( new TextDecoder()).decode(buffer.buffer);
-        this.isTextEditFromUs = true;
-        modifiedModel.pushEditOperations(null, [{ range: modifiedModel.getFullModelRange(), text }], () => null);
-        this.isTextEditFromUs = false;
-    }
-    async getNotebookSerializer() {
-        const info = await this.notebookService.withNotebookDataProvider(this.model.viewType);
-        return info.serializer;
-    }
-    async getOriginalModel(entry) {
-        if (!this._originalModel) {
-            this._originalModel = this.originalModelRefFactory.getOrCreate(entry, this.model.viewType).then(ref => {
-                if (this._store.isDisposed) {
-                    ref.dispose();
-                    return ref.object;
-                }
-                else {
-                    return this._register(ref).object;
-                }
-            });
-        }
-        return this._originalModel;
-    }
-    async updateNotebookModel(entry, token) {
-        const modifiedModel = this.modelService.getModel(entry.modifiedURI);
-        if (!modifiedModel) {
-            return;
-        }
-        const modifiedModelVersion = modifiedModel.getVersionId();
-        const currentModel = this.model;
-        const modelVersion = currentModel?.versionId ?? 0;
-        const modelWithChatEdits = await this.getModifiedModelForDiff(entry, token);
-        if (!modelWithChatEdits || token.isCancellationRequested || !currentModel) {
-            return;
-        }
-        const originalModel = await this.getOriginalModel(entry);
-        const cellDiffInfo = (await this.computeDiff(originalModel, modelWithChatEdits, token))?.cellDiffInfo;
-        const cellDiffInfoToApplyEdits = (await this.computeDiff(currentModel, modelWithChatEdits, token))?.cellDiffInfo;
-        const currentVersion = modifiedModel.getVersionId();
-        if (!cellDiffInfo || !cellDiffInfoToApplyEdits || token.isCancellationRequested || currentVersion !== modifiedModelVersion || modelVersion !== currentModel.versionId) {
-            return;
-        }
-        if (cellDiffInfoToApplyEdits.every(d => d.type === 'unchanged')) {
-            return;
-        }
-        this.isEditFromUs = true;
-        try {
-            const edits = [];
-            const mappings = ( new Map());
-            const deletedIndexes = [];
-            await Promise.all(( cellDiffInfoToApplyEdits.reverse().map(async (diff) => {
-                if (diff.type === 'delete') {
-                    deletedIndexes.push(diff.originalCellIndex);
-                    edits.push({
-                        editType: CellEditType.Replace,
-                        index: diff.originalCellIndex,
-                        cells: [],
-                        count: 1
-                    });
-                }
-            })));
-            if (edits.length) {
-                currentModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
-                edits.length = 0;
-            }
-            const notebookEditor = this.notebookEditorService.retrieveExistingWidgetFromURI(this.model.uri)?.value;
-            cellDiffInfoToApplyEdits.reverse().forEach(diff => {
-                if (diff.type === 'modified' || diff.type === 'unchanged') {
-                    mappings.set(diff.modifiedCellIndex, diff.originalCellIndex);
-                }
-                if (diff.type === 'insert') {
-                    const originalIndex = mappings.get(diff.modifiedCellIndex - 1) ?? 0;
-                    mappings.set(diff.modifiedCellIndex, originalIndex);
-                    const index = currentModel.cells.length ? originalIndex + 1 : originalIndex;
-                    const cell = modelWithChatEdits.cells[diff.modifiedCellIndex];
-                    const newCell = {
-                        source: cell.getValue(),
-                        cellKind: cell.cellKind,
-                        language: cell.language,
-                        outputs: ( cell.outputs.map(output => output.asDto())),
-                        mime: cell.mime,
-                        metadata: cell.metadata,
-                        collapseState: cell.collapseState,
-                        internalMetadata: cell.internalMetadata
-                    };
-                    edits.push({
-                        editType: CellEditType.Replace,
-                        index,
-                        cells: [newCell],
-                        count: 0
-                    });
-                }
-            });
-            if (edits.length) {
-                currentModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
-                for (const edit of edits.filter(e => e.editType === CellEditType.Replace)) {
-                    const cell = currentModel.cells[edit.index];
-                    if (cell) {
-                        const cellViewModel = notebookEditor?.getCellByHandle(cell.handle);
-                        cellViewModel?.updateEditState(CellEditState.Editing, 'chatEdit');
-                    }
-                }
-                edits.length = 0;
-            }
-            await Promise.all(( cellDiffInfoToApplyEdits.map(async (diff) => {
-                if (diff.type === 'modified') {
-                    const cell = currentModel.cells[diff.originalCellIndex];
-                    const cellModelRef = await this.textModelService.createModelReference(cell.uri);
-                    try {
-                        const modifiedCell = modelWithChatEdits.cells[diff.modifiedCellIndex];
-                        if (modifiedCell.cellKind === cell.cellKind) {
-                            const cellViewModel = notebookEditor?.getCellByHandle(cell.handle);
-                            cellViewModel?.updateEditState(CellEditState.Editing, 'chatEdit');
-                            const textModel = cellModelRef.object.textEditorModel;
-                            textModel.pushEditOperations(null, [
-                                EditOperation.replace(textModel.getFullModelRange(), modifiedCell.getValue())
-                            ], () => null);
-                        }
-                        else {
-                            const newCellDto = {
-                                source: modifiedCell.getValue(),
-                                cellKind: modifiedCell.cellKind,
-                                language: modifiedCell.language,
-                                outputs: ( modifiedCell.outputs.map(output => output.asDto())),
-                                mime: modifiedCell.mime,
-                                metadata: modifiedCell.metadata,
-                                collapseState: modifiedCell.collapseState,
-                                internalMetadata: modifiedCell.internalMetadata
-                            };
-                            const edit = {
-                                editType: CellEditType.Replace,
-                                index: diff.originalCellIndex,
-                                cells: [newCellDto],
-                                count: 1
-                            };
-                            currentModel.applyEdits([edit], true, undefined, () => undefined, undefined, false);
-                            const newCell = currentModel.cells[diff.originalCellIndex];
-                            const cellViewModel = notebookEditor?.getCellByHandle(newCell.handle);
-                            cellViewModel?.updateEditState(CellEditState.Editing, 'chatEdit');
-                        }
-                    }
-                    finally {
-                        cellModelRef.dispose();
-                    }
-                }
-            })));
-            if (edits.length) {
-                currentModel.applyEdits(edits, true, undefined, () => undefined, undefined, false);
-            }
-            this._diffInfo.set({ cellDiff: cellDiffInfo, modelVersion: currentModel.versionId }, undefined);
-        }
-        finally {
-            this.isEditFromUs = false;
-        }
-    }
-    async getModifiedModelForDiff(entry, token) {
-        const modifiedModel = this.modelService.getModel(entry.modifiedURI);
-        if (!modifiedModel) {
-            return;
-        }
-        const text = modifiedModel.getValue();
-        const bytes = VSBuffer.fromString(text);
-        const uri = entry.modifiedURI.with({ scheme: `NotebookChatEditorController.modifiedScheme${( Date.now().toString())}` });
-        const stream = bufferToStream(bytes);
-        if (this.previousUriOfModelForDiff) {
-            this.notebookService.getNotebookTextModel(this.previousUriOfModelForDiff)?.dispose();
-        }
-        this.previousUriOfModelForDiff = uri;
-        try {
-            const model = await this.notebookService.createNotebookTextModel(this.model.viewType, uri, stream);
-            if (token.isCancellationRequested) {
-                model.dispose();
-                return;
-            }
-            this._register(model);
-            return model;
-        }
-        catch (ex) {
-            this.logService.warn('NotebookChatEdit', `Failed to deserialize Notebook for ${uri.toString}, ${ex.message}`);
-            this.logService.debug('NotebookChatEdit', ( ex.toString()));
-            return;
-        }
-    }
-    async computeDiff(original, modified, token) {
-        const diffResult = await raceCancellation(this.notebookEditorWorkerService.computeDiff(original.uri, modified.uri), token);
-        if (!diffResult || token.isCancellationRequested) {
-            return;
-        }
-        prettyChanges(original, modified, diffResult.cellsDiff);
-        return computeDiff(original, modified, diffResult);
-    }
-};
-NotebookModelSynchronizer = ( __decorate([
-    ( __param(1, IChatEditingService)),
-    ( __param(2, INotebookService)),
-    ( __param(3, INotebookEditorService)),
-    ( __param(4, IChatService)),
-    ( __param(5, IModelService)),
-    ( __param(6, ITextModelService)),
-    ( __param(7, INotebookLoggingService)),
-    ( __param(8, IConfigurationService)),
-    ( __param(9, INotebookEditorWorkerService)),
-    ( __param(10, INotebookEditorModelResolverService)),
-    ( __param(11, INotebookOriginalModelReferenceFactory))
-], NotebookModelSynchronizer));
-
-export { NotebookModelSynchronizer, NotebookModelSynchronizerFactory };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizerService.d.ts

@@ -1,20 +0,0 @@
-import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
-import { IStoredFileWorkingCopy } from "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy";
-import { IUntitledFileWorkingCopy } from "../../../../../services/workingCopy/common/untitledFileWorkingCopy.js";
-import { IWorkingCopyFileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service";
-import { IChatEditingService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service";
-import { NotebookFileWorkingCopyModel } from "@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/contrib/notebook/common/notebookEditorModel";
-import { INotebookSynchronizerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookSynchronizerService.service";
-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 { INotebookService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service";
-export declare class NotebookSynchronizerService extends Disposable implements INotebookSynchronizerService {
-    private readonly _chatEditingService;
-    protected readonly _fileService: IFileService;
-    private readonly _notebookService;
-    private readonly _instantiationService;
-    private readonly _workingCopyFileService;
-    _serviceBrand: undefined;
-    constructor(_chatEditingService: IChatEditingService, _fileService: IFileService, _notebookService: INotebookService, _instantiationService: IInstantiationService, _workingCopyFileService: IWorkingCopyFileService);
-    revert(workingCopy: IStoredFileWorkingCopy<NotebookFileWorkingCopyModel> | IUntitledFileWorkingCopy<NotebookFileWorkingCopyModel>): Promise<void>;
-}

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/chatEdit/notebookSynchronizerService.js

@@ -1,86 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
-import { StoredFileWorkingCopy } from '@codingame/monaco-vscode-bba55be6-41a2-50cd-a3cc-8bafa35bfa89-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
-import { IWorkingCopyFileService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/workingCopy/common/workingCopyFileService.service';
-import { IChatEditingService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatEditingService.service';
-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 { NotebookSaveParticipant } from '../saveParticipants/saveParticipants.js';
-import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
-import { INotebookService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookService.service';
-import { ChatEditingModifiedDocumentEntry } from '@codingame/monaco-vscode-e4d0fd26-1b26-5583-b3f7-582e08d7b389-common/vscode/vs/workbench/contrib/chat/browser/chatEditing/chatEditingModifiedDocumentEntry';
-import { SaveReason } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
-
-let NotebookSynchronizerSaveParticipant = class NotebookSynchronizerSaveParticipant extends NotebookSaveParticipant {
-    constructor(editorService, _chatEditingService, _fileService, _notebookService) {
-        super(editorService);
-        this._chatEditingService = _chatEditingService;
-        this._fileService = _fileService;
-        this._notebookService = _notebookService;
-    }
-    async participate(workingCopy, context, progress, token) {
-        const sessions = this._chatEditingService.editingSessionsObs.get();
-        const session = sessions.find(s => s.getEntry(workingCopy.resource));
-        if (!session) {
-            return;
-        }
-        if (!this._notebookService.hasSupportedNotebooks(workingCopy.resource)) {
-            return;
-        }
-        const entry = session.getEntry(workingCopy.resource);
-        if (entry && entry instanceof ChatEditingModifiedDocumentEntry) {
-            await entry.docFileEditorModel.save({ reason: SaveReason.EXPLICIT, ignoreModifiedSince: true });
-        }
-        const inWorkingSet = ( session.workingSet.has(workingCopy.resource));
-        if (!(entry && entry instanceof ChatEditingModifiedDocumentEntry) && !inWorkingSet) {
-            return;
-        }
-        if (workingCopy instanceof StoredFileWorkingCopy) {
-            const metadata = await this._fileService.stat(workingCopy.resource);
-            if (workingCopy.lastResolvedFileStat) {
-                workingCopy.lastResolvedFileStat = {
-                    ...workingCopy.lastResolvedFileStat,
-                    ...metadata
-                };
-            }
-        }
-    }
-};
-NotebookSynchronizerSaveParticipant = ( __decorate([
-    ( __param(0, IEditorService)),
-    ( __param(1, IChatEditingService)),
-    ( __param(2, IFileService)),
-    ( __param(3, INotebookService))
-], NotebookSynchronizerSaveParticipant));
-let NotebookSynchronizerService = class NotebookSynchronizerService extends Disposable {
-    constructor(_chatEditingService, _fileService, _notebookService, _instantiationService, _workingCopyFileService) {
-        super();
-        this._chatEditingService = _chatEditingService;
-        this._fileService = _fileService;
-        this._notebookService = _notebookService;
-        this._instantiationService = _instantiationService;
-        this._workingCopyFileService = _workingCopyFileService;
-        this._register(this._workingCopyFileService.addSaveParticipant(this._instantiationService.createInstance(NotebookSynchronizerSaveParticipant)));
-    }
-    async revert(workingCopy) {
-        const resource = workingCopy.resource;
-        if (!this._notebookService.hasSupportedNotebooks(workingCopy.resource)) {
-            return;
-        }
-        const sessions = this._chatEditingService.editingSessionsObs.get();
-        const entry = ( sessions.map(s => s.getEntry(resource))).find(r => !!r);
-        if (entry instanceof ChatEditingModifiedDocumentEntry) {
-            await entry.docFileEditorModel.revert({ soft: true });
-        }
-    }
-};
-NotebookSynchronizerService = ( __decorate([
-    ( __param(0, IChatEditingService)),
-    ( __param(1, IFileService)),
-    ( __param(2, INotebookService)),
-    ( __param(3, IInstantiationService)),
-    ( __param(4, IWorkingCopyFileService))
-], NotebookSynchronizerService));
-
-export { NotebookSynchronizerService };

package/vscode/src/vs/workbench/contrib/notebook/browser/contrib/find/media/notebookFind.css.js

@@ -1,6 +0,0 @@
-import n from '@codingame/monaco-vscode-api/external/rollup-plugin-styles/dist/runtime/inject-css';
-
-var css = ".monaco-workbench .notebookOverlay.notebook-editor.find-hide-transition,.monaco-workbench .notebookOverlay.notebook-editor.find-show-transition{overflow-y:hidden}.monaco-workbench .notebookOverlay.notebook-editor .simple-fr-find-part-wrapper .matchesCount{box-sizing:border-box;overflow:hidden;padding:0 2px;text-align:center;text-overflow:ellipsis;white-space:nowrap}.monaco-workbench .nb-findScope{background-color:var(--vscode-editor-findRangeHighlightBackground)}";
-n(css,{});
-
-export { css, css as default };