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

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

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

@@ -0,0 +1,90 @@
+class MoveCellEdit {
+    get label() {
+        return this.length === 1 ? 'Move Cell' : 'Move Cells';
+    }
+    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.code = 'undoredo.textBufferEdit';
+    }
+    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 {
+    get label() {
+        if (this.diffs.length === 1 && this.diffs[0][1].length === 0) {
+            return this.diffs[0][2].length > 1 ? 'Insert Cells' : 'Insert Cell';
+        }
+        if (this.diffs.length === 1 && this.diffs[0][2].length === 0) {
+            return this.diffs[0][1].length > 1 ? 'Delete Cells' : 'Delete Cell';
+        }
+        return 'Insert Cell';
+    }
+    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.code = 'undoredo.textBufferEdit';
+    }
+    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.textBufferEdit';
+    }
+    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 };