@codingame/monaco-vscode-notebook-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/contrib/notebook/browser/services/notebookWorkerServiceImpl.js

@@ -1,200 +0,0 @@
-import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore, toDisposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { SimpleWorkerClient } from 'vscode/vscode/vs/base/common/worker/simpleWorker';
-import { DefaultWorkerFactory } from 'vscode/vscode/vs/base/browser/defaultWorkerFactory';
-import { NotebookCellsChangeType } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
-import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
-
-let NotebookEditorWorkerServiceImpl = class NotebookEditorWorkerServiceImpl extends Disposable {
-    constructor(notebookService) {
-        super();
-        this._workerManager = this._register(( new WorkerManager(notebookService)));
-    }
-    canComputeDiff(original, modified) {
-        throw new Error('Method not implemented.');
-    }
-    computeDiff(original, modified) {
-        return this._workerManager.withWorker().then(client => {
-            return client.computeDiff(original, modified);
-        });
-    }
-    canPromptRecommendation(model) {
-        return this._workerManager.withWorker().then(client => {
-            return client.canPromptRecommendation(model);
-        });
-    }
-};
-NotebookEditorWorkerServiceImpl = ( __decorate([
-    ( __param(0, INotebookService))
-], NotebookEditorWorkerServiceImpl));
-class WorkerManager extends Disposable {
-    constructor(_notebookService) {
-        super();
-        this._notebookService = _notebookService;
-        this._editorWorkerClient = null;
-    }
-    withWorker() {
-        if (!this._editorWorkerClient) {
-            this._editorWorkerClient = ( new NotebookWorkerClient(this._notebookService, 'notebookEditorWorkerService'));
-        }
-        return Promise.resolve(this._editorWorkerClient);
-    }
-}
-class NotebookEditorModelManager extends Disposable {
-    constructor(_proxy, _notebookService) {
-        super();
-        this._proxy = _proxy;
-        this._notebookService = _notebookService;
-        this._syncedModels = Object.create(null);
-        this._syncedModelsLastUsedTime = Object.create(null);
-    }
-    ensureSyncedResources(resources) {
-        for (const resource of resources) {
-            const resourceStr = ( resource.toString());
-            if (!this._syncedModels[resourceStr]) {
-                this._beginModelSync(resource);
-            }
-            if (this._syncedModels[resourceStr]) {
-                this._syncedModelsLastUsedTime[resourceStr] = (( new Date())).getTime();
-            }
-        }
-    }
-    _beginModelSync(resource) {
-        const model = this._notebookService.listNotebookDocuments().find(document => ( document.uri.toString()) === ( resource.toString()));
-        if (!model) {
-            return;
-        }
-        const modelUrl = ( resource.toString());
-        this._proxy.acceptNewModel(( model.uri.toString()), {
-            cells: ( model.cells.map(cell => ({
-                handle: cell.handle,
-                uri: cell.uri,
-                source: cell.getValue(),
-                eol: cell.textBuffer.getEOL(),
-                language: cell.language,
-                mime: cell.mime,
-                cellKind: cell.cellKind,
-                outputs: ( cell.outputs.map(op => ({ outputId: op.outputId, outputs: op.outputs }))),
-                metadata: cell.metadata,
-                internalMetadata: cell.internalMetadata,
-            }))),
-            metadata: model.metadata
-        });
-        const toDispose = ( new DisposableStore());
-        const cellToDto = (cell) => {
-            return {
-                handle: cell.handle,
-                uri: cell.uri,
-                source: cell.textBuffer.getLinesContent(),
-                eol: cell.textBuffer.getEOL(),
-                language: cell.language,
-                cellKind: cell.cellKind,
-                outputs: ( cell.outputs.map(op => ({ outputId: op.outputId, outputs: op.outputs }))),
-                metadata: cell.metadata,
-                internalMetadata: cell.internalMetadata,
-            };
-        };
-        toDispose.add(model.onDidChangeContent((event) => {
-            const dto = ( event.rawEvents.map(e => {
-                const data = e.kind === NotebookCellsChangeType.ModelChange || e.kind === NotebookCellsChangeType.Initialize
-                    ? {
-                        kind: e.kind,
-                        versionId: event.versionId,
-                        changes: ( e.changes.map(diff => [diff[0], diff[1], ( diff[2].map(cell => cellToDto(cell)))]))
-                    }
-                    : (e.kind === NotebookCellsChangeType.Move
-                        ? {
-                            kind: e.kind,
-                            index: e.index,
-                            length: e.length,
-                            newIdx: e.newIdx,
-                            versionId: event.versionId,
-                            cells: ( e.cells.map(cell => cellToDto(cell)))
-                        }
-                        : e);
-                return data;
-            }));
-            this._proxy.acceptModelChanged(( modelUrl.toString()), {
-                rawEvents: dto,
-                versionId: event.versionId
-            });
-        }));
-        toDispose.add(model.onWillDispose(() => {
-            this._stopModelSync(modelUrl);
-        }));
-        toDispose.add(toDisposable(() => {
-            this._proxy.acceptRemovedModel(modelUrl);
-        }));
-        this._syncedModels[modelUrl] = toDispose;
-    }
-    _stopModelSync(modelUrl) {
-        const toDispose = this._syncedModels[modelUrl];
-        delete this._syncedModels[modelUrl];
-        delete this._syncedModelsLastUsedTime[modelUrl];
-        dispose(toDispose);
-    }
-}
-class NotebookWorkerHost {
-    constructor(workerClient) {
-        this._workerClient = workerClient;
-    }
-    fhr(method, args) {
-        return this._workerClient.fhr(method, args);
-    }
-}
-class NotebookWorkerClient extends Disposable {
-    constructor(_notebookService, label) {
-        super();
-        this._notebookService = _notebookService;
-        this._workerFactory = ( new DefaultWorkerFactory(label));
-        this._worker = null;
-        this._modelManager = null;
-    }
-    fhr(method, args) {
-        throw new Error(`Not implemented!`);
-    }
-    computeDiff(original, modified) {
-        return this._withSyncedResources([original, modified]).then(proxy => {
-            return proxy.computeDiff(( original.toString()), ( modified.toString()));
-        });
-    }
-    canPromptRecommendation(modelUri) {
-        return this._withSyncedResources([modelUri]).then(proxy => {
-            return proxy.canPromptRecommendation(( modelUri.toString()));
-        });
-    }
-    _getOrCreateModelManager(proxy) {
-        if (!this._modelManager) {
-            this._modelManager = this._register(( new NotebookEditorModelManager(proxy, this._notebookService)));
-        }
-        return this._modelManager;
-    }
-    _withSyncedResources(resources) {
-        return this._getProxy().then((proxy) => {
-            this._getOrCreateModelManager(proxy).ensureSyncedResources(resources);
-            return proxy;
-        });
-    }
-    _getOrCreateWorker() {
-        if (!this._worker) {
-            try {
-                this._worker = this._register(( new SimpleWorkerClient(
-                    this._workerFactory,
-                    'vs/workbench/contrib/notebook/common/services/notebookSimpleWorker',
-                    ( new NotebookWorkerHost(this))
-                )));
-            }
-            catch (err) {
-                throw (err);
-            }
-        }
-        return this._worker;
-    }
-    _getProxy() {
-        return this._getOrCreateWorker().getProxyObject().then(undefined, (err) => {
-            throw (err);
-        });
-    }
-}
-
-export { NotebookEditorWorkerServiceImpl };

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

@@ -1,80 +0,0 @@
-class MoveCellEdit {
-    constructor(resource, fromIndex, length, toIndex, editingDelegate, beforedSelections, endSelections) {
-        this.resource = resource;
-        this.fromIndex = fromIndex;
-        this.length = length;
-        this.toIndex = toIndex;
-        this.editingDelegate = editingDelegate;
-        this.beforedSelections = beforedSelections;
-        this.endSelections = endSelections;
-        this.type = 0 ;
-        this.label = 'Move Cell';
-        this.code = 'undoredo.notebooks.moveCell';
-    }
-    undo() {
-        if (!this.editingDelegate.moveCell) {
-            throw new Error('Notebook Move Cell not implemented for Undo/Redo');
-        }
-        this.editingDelegate.moveCell(this.toIndex, this.length, this.fromIndex, this.endSelections, this.beforedSelections);
-    }
-    redo() {
-        if (!this.editingDelegate.moveCell) {
-            throw new Error('Notebook Move Cell not implemented for Undo/Redo');
-        }
-        this.editingDelegate.moveCell(this.fromIndex, this.length, this.toIndex, this.beforedSelections, this.endSelections);
-    }
-}
-class SpliceCellsEdit {
-    constructor(resource, diffs, editingDelegate, beforeHandles, endHandles) {
-        this.resource = resource;
-        this.diffs = diffs;
-        this.editingDelegate = editingDelegate;
-        this.beforeHandles = beforeHandles;
-        this.endHandles = endHandles;
-        this.type = 0 ;
-        this.label = 'Insert Cell';
-        this.code = 'undoredo.notebooks.insertCell';
-    }
-    undo() {
-        if (!this.editingDelegate.replaceCell) {
-            throw new Error('Notebook Replace Cell not implemented for Undo/Redo');
-        }
-        this.diffs.forEach(diff => {
-            this.editingDelegate.replaceCell(diff[0], diff[2].length, diff[1], this.beforeHandles);
-        });
-    }
-    redo() {
-        if (!this.editingDelegate.replaceCell) {
-            throw new Error('Notebook Replace Cell not implemented for Undo/Redo');
-        }
-        this.diffs.reverse().forEach(diff => {
-            this.editingDelegate.replaceCell(diff[0], diff[1].length, diff[2], this.endHandles);
-        });
-    }
-}
-class CellMetadataEdit {
-    constructor(resource, index, oldMetadata, newMetadata, editingDelegate) {
-        this.resource = resource;
-        this.index = index;
-        this.oldMetadata = oldMetadata;
-        this.newMetadata = newMetadata;
-        this.editingDelegate = editingDelegate;
-        this.type = 0 ;
-        this.label = 'Update Cell Metadata';
-        this.code = 'undoredo.notebooks.updateCellMetadata';
-    }
-    undo() {
-        if (!this.editingDelegate.updateCellMetadata) {
-            return;
-        }
-        this.editingDelegate.updateCellMetadata(this.index, this.oldMetadata);
-    }
-    redo() {
-        if (!this.editingDelegate.updateCellMetadata) {
-            return;
-        }
-        this.editingDelegate.updateCellMetadata(this.index, this.newMetadata);
-    }
-}
-
-export { CellMetadataEdit, MoveCellEdit, SpliceCellsEdit };