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

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorker.js

@@ -1,279 +0,0 @@
-
-import { LcsDiff } from '@codingame/monaco-vscode-api/vscode/vs/base/common/diff/diff';
-import { numberHash, doHash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
-import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
-import { PieceTreeTextBufferBuilder } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/pieceTreeTextBuffer/pieceTreeTextBufferBuilder';
-import { NotebookCellsChangeType, CellKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
-import { SearchParams } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModelSearch';
-import { MirrorModel } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textModelSync/textModelSync.impl';
-import { DefaultEndOfLine } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
-import { filter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
-
-class MirrorCell {
-    get eol() {
-        return this._eol === '\r\n' ? DefaultEndOfLine.CRLF : DefaultEndOfLine.LF;
-    }
-    constructor(handle, uri, source, _eol, versionId, language, cellKind, outputs, metadata, internalMetadata) {
-        this.handle = handle;
-        this._eol = _eol;
-        this.language = language;
-        this.cellKind = cellKind;
-        this.outputs = outputs;
-        this.metadata = metadata;
-        this.internalMetadata = internalMetadata;
-        this.textModel = ( new MirrorModel(uri, source, _eol, versionId));
-    }
-    onEvents(e) {
-        this.textModel.onEvents(e);
-        this._hash = undefined;
-    }
-    getValue() {
-        return this.textModel.getValue();
-    }
-    async getComparisonValue() {
-        return this._hash ??= this._getHash();
-    }
-    async _getHash() {
-        let hashValue = numberHash(104579, 0);
-        hashValue = doHash(this.language, hashValue);
-        hashValue = doHash(this.getValue(), hashValue);
-        hashValue = doHash(this.metadata, hashValue);
-        hashValue = doHash({ ...this.internalMetadata, 'cellId': '' }, hashValue);
-        for (const op of this.outputs) {
-            hashValue = doHash(op.metadata, hashValue);
-            for (const output of op.outputs) {
-                hashValue = doHash(output.mime, hashValue);
-            }
-        }
-        const digests = await Promise.all(this.outputs.flatMap(op => ( op.outputs.map(o => crypto.subtle.digest('sha-1', o.data.buffer)))));
-        for (const digest of digests) {
-            hashValue = numberHash(( new Int32Array(digest))[0], hashValue);
-        }
-        return hashValue;
-    }
-}
-class MirrorNotebookDocument {
-    constructor(uri, cells, metadata, transientDocumentMetadata) {
-        this.uri = uri;
-        this.cells = cells;
-        this.metadata = metadata;
-        this.transientDocumentMetadata = transientDocumentMetadata;
-    }
-    acceptModelChanged(event) {
-        event.rawEvents.forEach(e => {
-            if (e.kind === NotebookCellsChangeType.ModelChange) {
-                this._spliceNotebookCells(e.changes);
-            }
-            else if (e.kind === NotebookCellsChangeType.Move) {
-                const cells = this.cells.splice(e.index, 1);
-                this.cells.splice(e.newIdx, 0, ...cells);
-            }
-            else if (e.kind === NotebookCellsChangeType.Output) {
-                const cell = this.cells[e.index];
-                cell.outputs = e.outputs;
-            }
-            else if (e.kind === NotebookCellsChangeType.ChangeCellLanguage) {
-                this._assertIndex(e.index);
-                const cell = this.cells[e.index];
-                cell.language = e.language;
-            }
-            else if (e.kind === NotebookCellsChangeType.ChangeCellMetadata) {
-                this._assertIndex(e.index);
-                const cell = this.cells[e.index];
-                cell.metadata = e.metadata;
-            }
-            else if (e.kind === NotebookCellsChangeType.ChangeCellInternalMetadata) {
-                this._assertIndex(e.index);
-                const cell = this.cells[e.index];
-                cell.internalMetadata = e.internalMetadata;
-            }
-            else if (e.kind === NotebookCellsChangeType.ChangeDocumentMetadata) {
-                this.metadata = e.metadata;
-            }
-        });
-    }
-    _assertIndex(index) {
-        if (index < 0 || index >= this.cells.length) {
-            throw ( new Error(`Illegal index ${index}. Cells length: ${this.cells.length}`));
-        }
-    }
-    _spliceNotebookCells(splices) {
-        splices.reverse().forEach(splice => {
-            const cellDtos = splice[2];
-            const newCells = ( cellDtos.map(cell => {
-                return ( new MirrorCell(cell.handle, ( URI.parse(cell.url)), cell.source, cell.eol, cell.versionId, cell.language, cell.cellKind, cell.outputs, cell.metadata));
-            }));
-            this.cells.splice(splice[0], splice[1], ...newCells);
-        });
-    }
-}
-class CellSequence {
-    static async create(textModel) {
-        const hashValue = ( new Int32Array(textModel.cells.length));
-        await Promise.all(( textModel.cells.map(async (c, i) => {
-            hashValue[i] = await c.getComparisonValue();
-        })));
-        return ( new CellSequence(hashValue));
-    }
-    static async createWithCellId(textModel) {
-        const hashValue = ( new Map());
-        await Promise.all(( textModel.cells.map(async (c, i) => {
-            const value = await c.getComparisonValue();
-            const id = (c.metadata?.id || '');
-            hashValue.set(id, value);
-        })));
-        return hashValue;
-    }
-    constructor(hashValue) {
-        this.hashValue = hashValue;
-    }
-    getElements() {
-        return this.hashValue;
-    }
-}
-class NotebookEditorSimpleWorker {
-    constructor() {
-        this._models = Object.create(null);
-    }
-    dispose() {
-    }
-    $acceptNewModel(uri, metadata, transientDocumentMetadata, cells) {
-        this._models[uri] = ( new MirrorNotebookDocument(( URI.parse(uri)), ( cells.map(dto => ( new MirrorCell(dto.handle, ( URI.parse(dto.url)), dto.source, dto.eol, dto.versionId, dto.language, dto.cellKind, dto.outputs, dto.metadata, dto.internalMetadata)))), metadata, transientDocumentMetadata));
-    }
-    $acceptModelChanged(strURL, event) {
-        const model = this._models[strURL];
-        model?.acceptModelChanged(event);
-    }
-    $acceptCellModelChanged(strURL, handle, event) {
-        const model = this._models[strURL];
-        model.cells.find(cell => cell.handle === handle)?.onEvents(event);
-    }
-    $acceptRemovedModel(strURL) {
-        if (!this._models[strURL]) {
-            return;
-        }
-        delete this._models[strURL];
-    }
-    async $computeDiff(originalUrl, modifiedUrl) {
-        const original = this._getModel(originalUrl);
-        const modified = this._getModel(modifiedUrl);
-        const [originalSeq, modifiedSeq] = await Promise.all([
-            CellSequence.create(original),
-            CellSequence.create(modified),
-        ]);
-        const diff = ( new LcsDiff(originalSeq, modifiedSeq));
-        const diffResult = diff.ComputeDiff(false);
-        const originalMetadata = filter(original.metadata, key => !original.transientDocumentMetadata[key]);
-        const modifiedMetadata = filter(modified.metadata, key => !modified.transientDocumentMetadata[key]);
-        return {
-            metadataChanged: JSON.stringify(originalMetadata) !== JSON.stringify(modifiedMetadata),
-            cellsDiff: (await this.$computeDiffWithCellIds(original, modified)) || diffResult,
-        };
-    }
-    async $computeDiffWithCellIds(original, modified) {
-        const originalCellIndexIds = ( original.cells.map((cell, index) => ({ index, id: (cell.metadata?.id || '') })));
-        const modifiedCellIndexIds = ( modified.cells.map((cell, index) => ({ index, id: (cell.metadata?.id || '') })));
-        const originalCellIds = ( originalCellIndexIds.map(c => c.id));
-        const modifiedCellIds = ( modifiedCellIndexIds.map(c => c.id));
-        const orderOrOriginalCellIds = originalCellIds.filter(id => modifiedCellIds.includes(id)).join(',');
-        const orderOrModifiedCellIds = modifiedCellIds.filter(id => originalCellIds.includes(id)).join(',');
-        if (( originalCellIndexIds.some(c => !c.id)) || ( modifiedCellIndexIds.some(c => !c.id)) || orderOrOriginalCellIds !== orderOrModifiedCellIds) {
-            return;
-        }
-        const diffResult = { changes: [], quitEarly: false, };
-        const computeCellHashesById = async (notebook) => {
-            const hashValue = ( new Map());
-            await Promise.all(( notebook.cells.map(async (c, i) => {
-                const value = await c.getComparisonValue();
-                const id = (c.metadata?.id || '');
-                hashValue.set(id, value);
-            })));
-            return hashValue;
-        };
-        const [originalSeq, modifiedSeq] = await Promise.all([computeCellHashesById(original), computeCellHashesById(modified)]);
-        while (modifiedCellIndexIds.length) {
-            const modifiedCell = modifiedCellIndexIds.shift();
-            const originalCell = originalCellIndexIds.find(c => c.id === modifiedCell.id);
-            if (originalCell) {
-                const index = originalCellIndexIds.indexOf(originalCell);
-                const deletedFromOriginal = originalCellIndexIds.splice(0, index + 1);
-                if (deletedFromOriginal.length === 1) {
-                    if (originalSeq.get(originalCell.id) === modifiedSeq.get(originalCell.id)) ;
-                    else {
-                        diffResult.changes.push({
-                            originalStart: originalCell.index,
-                            originalLength: 1,
-                            modifiedStart: modifiedCell.index,
-                            modifiedLength: 1
-                        });
-                    }
-                }
-                else {
-                    diffResult.changes.push({
-                        originalStart: deletedFromOriginal[0].index,
-                        originalLength: deletedFromOriginal.length - 1,
-                        modifiedStart: modifiedCell.index,
-                        modifiedLength: 0
-                    });
-                }
-                continue;
-            }
-            else {
-                diffResult.changes.push({
-                    originalStart: originalCellIndexIds.length ? originalCellIndexIds[0].index : original.cells.length,
-                    originalLength: 0,
-                    modifiedStart: modifiedCell.index,
-                    modifiedLength: 1
-                });
-            }
-        }
-        if (originalCellIndexIds.length) {
-            diffResult.changes.push({
-                originalStart: originalCellIndexIds[0].index,
-                originalLength: originalCellIndexIds.length,
-                modifiedStart: modifiedCellIndexIds.length,
-                modifiedLength: 0
-            });
-        }
-        return diffResult;
-    }
-    $canPromptRecommendation(modelUrl) {
-        const model = this._getModel(modelUrl);
-        const cells = model.cells;
-        for (let i = 0; i < cells.length; i++) {
-            const cell = cells[i];
-            if (cell.cellKind === CellKind.Markup) {
-                continue;
-            }
-            if (cell.language !== 'python') {
-                continue;
-            }
-            const searchParams = ( new SearchParams('import\\s*pandas|from\\s*pandas', true, false, null));
-            const searchData = searchParams.parseSearchRequest();
-            if (!searchData) {
-                continue;
-            }
-            const builder = ( new PieceTreeTextBufferBuilder());
-            builder.acceptChunk(cell.getValue());
-            const bufferFactory = builder.finish(true);
-            const textBuffer = bufferFactory.create(cell.eol).textBuffer;
-            const lineCount = textBuffer.getLineCount();
-            const maxLineCount = Math.min(lineCount, 20);
-            const range = ( new Range(1, 1, maxLineCount, textBuffer.getLineLength(maxLineCount) + 1));
-            const cellMatches = textBuffer.findMatchesLineByLine(range, searchData, true, 1);
-            if (cellMatches.length > 0) {
-                return true;
-            }
-        }
-        return false;
-    }
-    _getModel(uri) {
-        return this._models[uri];
-    }
-}
-function create(workerServer) {
-    return ( new NotebookEditorSimpleWorker());
-}
-
-export { NotebookEditorSimpleWorker, create };

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

@@ -1 +0,0 @@
-export {};

package/vscode/src/vs/workbench/contrib/notebook/common/services/notebookSimpleWorkerMain.js

@@ -1,5 +0,0 @@
-
-import { bootstrapSimpleWorker } from '@codingame/monaco-vscode-695440c8-a687-5594-b476-bbc7b36bafe9-common/vscode/vs/base/common/worker/simpleWorkerBootstrap';
-import { create } from './notebookSimpleWorker.js';
-
-bootstrapSimpleWorker(create);