@codingame/monaco-vscode-notebook-service-override 25.1.2 → 26.0.0

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

@@ -16,7 +16,7 @@ let NotebookEditorWorkerServiceImpl = class NotebookEditorWorkerServiceImpl exte
         this._workerManager = this._register(( new WorkerManager(notebookService, modelService, webWorkerService)));
     }
     canComputeDiff(original, modified) {
-        throw ( new Error('Method not implemented.'));
+        throw ( new Error("Method not implemented."));
     }
     computeDiff(original, modified) {
         return this._workerManager.withWorker().then(client => {
@@ -29,11 +29,7 @@ let NotebookEditorWorkerServiceImpl = class NotebookEditorWorkerServiceImpl exte
         });
     }
 };
-NotebookEditorWorkerServiceImpl = ( __decorate([
-    ( __param(0, INotebookService)),
-    ( __param(1, IModelService)),
-    ( __param(2, IWebWorkerService))
-], NotebookEditorWorkerServiceImpl));
+NotebookEditorWorkerServiceImpl = ( __decorate([( __param(0, INotebookService)), ( __param(1, IModelService)), ( __param(2, IWebWorkerService))], NotebookEditorWorkerServiceImpl));
 class WorkerManager extends Disposable {
     constructor(_notebookService, _modelService, _webWorkerService) {
         super();
@@ -66,7 +62,7 @@ class NotebookEditorModelManager extends Disposable {
                 this._beginModelSync(resource);
             }
             if (this._syncedModels[resourceStr]) {
-                this._syncedModelsLastUsedTime[resourceStr] = (( new Date())).getTime();
+                this._syncedModelsLastUsedTime[resourceStr] = ( new Date()).getTime();
             }
         }
     }
@@ -85,12 +81,15 @@ class NotebookEditorModelManager extends Disposable {
             language: cell.language,
             mime: cell.mime,
             cellKind: cell.cellKind,
-            outputs: ( cell.outputs.map(op => ({ outputId: op.outputId, outputs: op.outputs }))),
+            outputs: ( cell.outputs.map(op => ({
+                outputId: op.outputId,
+                outputs: op.outputs
+            }))),
             metadata: cell.metadata,
-            internalMetadata: cell.internalMetadata,
+            internalMetadata: cell.internalMetadata
         }))));
         const toDispose = ( new DisposableStore());
-        const cellToDto = (cell) => {
+        const cellToDto = cell => {
             return {
                 handle: cell.handle,
                 url: ( cell.uri.toString()),
@@ -99,23 +98,26 @@ class NotebookEditorModelManager extends Disposable {
                 versionId: 0,
                 language: cell.language,
                 cellKind: cell.cellKind,
-                outputs: ( cell.outputs.map(op => ({ outputId: op.outputId, outputs: op.outputs }))),
+                outputs: ( cell.outputs.map(op => ({
+                    outputId: op.outputId,
+                    outputs: op.outputs
+                }))),
                 metadata: cell.metadata,
-                internalMetadata: cell.internalMetadata,
+                internalMetadata: cell.internalMetadata
             };
         };
         const cellHandlers = ( new Set());
-        const addCellContentChangeHandler = (cell) => {
+        const addCellContentChangeHandler = cell => {
             cellHandlers.add(cell);
-            toDispose.add(cell.onDidChangeContent((e) => {
-                if (typeof e === 'object' && e.type === 'model') {
+            toDispose.add(cell.onDidChangeContent(e => {
+                if (typeof e === "object" && e.type === "model") {
                     this._proxy.$acceptCellModelChanged(modelUrl, cell.handle, e.event);
                 }
             }));
         };
         model.cells.forEach(cell => addCellContentChangeHandler(cell));
         if (model.cells.length !== cellHandlers.size) {
-            toDispose.add(this._modelService.onModelAdded((textModel) => {
+            toDispose.add(this._modelService.onModelAdded(textModel => {
                 if (textModel.uri.scheme !== Schemas.vscodeNotebookCell || !(textModel instanceof TextModel)) {
                     return;
                 }
@@ -129,13 +131,13 @@ class NotebookEditorModelManager extends Disposable {
                 }
             }));
         }
-        toDispose.add(model.onDidChangeContent((event) => {
+        toDispose.add(model.onDidChangeContent(event => {
             const dto = [];
-            event.rawEvents
-                .forEach(e => {
+            event.rawEvents.forEach(e => {
                 switch (e.kind) {
-                    case NotebookCellsChangeType.ModelChange:
-                    case NotebookCellsChangeType.Initialize: {
+                case NotebookCellsChangeType.ModelChange:
+                case NotebookCellsChangeType.Initialize:
+                    {
                         dto.push({
                             kind: e.kind,
                             changes: ( e.changes.map(diff => [diff[0], diff[1], ( diff[2].map(cell => cellToDto(cell)))]))
@@ -147,7 +149,8 @@ class NotebookEditorModelManager extends Disposable {
                         }
                         break;
                     }
-                    case NotebookCellsChangeType.Move: {
+                case NotebookCellsChangeType.Move:
+                    {
                         dto.push({
                             kind: NotebookCellsChangeType.Move,
                             index: e.index,
@@ -157,15 +160,15 @@ class NotebookEditorModelManager extends Disposable {
                         });
                         break;
                     }
-                    case NotebookCellsChangeType.ChangeCellContent:
-                        break;
-                    case NotebookCellsChangeType.ChangeDocumentMetadata:
-                        dto.push({
-                            kind: e.kind,
-                            metadata: e.metadata
-                        });
-                    default:
-                        dto.push(e);
+                case NotebookCellsChangeType.ChangeCellContent:
+                    break;
+                case NotebookCellsChangeType.ChangeDocumentMetadata:
+                    dto.push({
+                        kind: e.kind,
+                        metadata: e.metadata
+                    });
+                default:
+                    dto.push(e);
                 }
             });
             this._proxy.$acceptModelChanged(( modelUrl.toString()), {
@@ -220,12 +223,11 @@ class NotebookWorkerClient extends Disposable {
         if (!this._worker) {
             try {
                 this._worker = this._register(this._webWorkerService.createWorkerClient(( new WebWorkerDescriptor({
-                    esmModuleLocation: ( FileAccess.asBrowserUri('vs/workbench/contrib/notebook/common/services/notebookWebWorkerMain.js')),
-                    label: 'NotebookEditorWorker'
+                    esmModuleLocation: ( FileAccess.asBrowserUri("vs/workbench/contrib/notebook/common/services/notebookWebWorkerMain.js")),
+                    label: "NotebookEditorWorker"
                 }))));
-            }
-            catch (err) {
-                throw (err);
+            } catch (err) {
+                throw err;
             }
         }
         return this._worker;

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSource.js

@@ -36,7 +36,7 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
     async computeFullSymbols(cancelToken) {
         try {
             const notebookEditorWidget = this._editor;
-            const notebookCells = notebookEditorWidget?.getViewModel()?.viewCells.filter((cell) => cell.cellKind === CellKind.Code);
+            const notebookCells = notebookEditorWidget?.getViewModel()?.viewCells.filter(cell => cell.cellKind === CellKind.Code);
             if (notebookCells) {
                 const promises = [];
                 for (const cell of notebookCells.slice(0, 50)) {
@@ -45,9 +45,8 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
                 await Promise.allSettled(promises);
             }
             this.recomputeState();
-        }
-        catch (err) {
-            console.error('Failed to compute notebook outline symbols:', err);
+        } catch (err) {
+            console.error("Failed to compute notebook outline symbols:", err);
             this.recomputeState();
         }
     }
@@ -79,15 +78,13 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
                         result.push(entry);
                         parentStack.push(entry);
                         break;
-                    }
-                    else {
+                    } else {
                         const parentCandidate = parentStack[len - 1];
                         if (parentCandidate.level < entry.level) {
                             parentCandidate.addChild(entry);
                             parentStack.push(entry);
                             break;
-                        }
-                        else {
+                        } else {
                             parentStack.pop();
                         }
                     }
@@ -101,17 +98,16 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
             if (notebookEditorWidget.isDisposed) {
                 return;
             }
-            const doUpdateMarker = (clear) => {
+            const doUpdateMarker = clear => {
                 for (const entry of this._entries) {
                     if (clear) {
                         entry.clearMarkers();
-                    }
-                    else {
+                    } else {
                         entry.updateMarkers(this._markerService);
                     }
                 }
             };
-            const problem = this._configurationService.getValue('problems.visibility');
+            const problem = this._configurationService.getValue("problems.visibility");
             if (problem === undefined) {
                 return;
             }
@@ -119,7 +115,7 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
             if (problem && config) {
                 markerServiceListener.value = this._markerService.onMarkerChanged(e => {
                     if (notebookEditorWidget.isDisposed) {
-                        console.error('notebook editor is disposed');
+                        console.error("notebook editor is disposed");
                         return;
                     }
                     if (( e.some(uri => ( notebookEditorWidget.getCellsInRange().some(cell => isEqual(cell.uri, uri)))))) {
@@ -128,20 +124,21 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
                     }
                 });
                 doUpdateMarker(false);
-            }
-            else {
+            } else {
                 markerServiceListener.clear();
                 doUpdateMarker(true);
             }
         };
         updateMarkerUpdater();
         this._disposables.add(this._configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration('problems.visibility') || e.affectsConfiguration(OutlineConfigKeys.problemsEnabled)) {
+            if (e.affectsConfiguration("problems.visibility") || e.affectsConfiguration(OutlineConfigKeys.problemsEnabled)) {
                 updateMarkerUpdater();
                 this._onDidChange.fire({});
             }
         }));
-        const { changeEventTriggered } = this.recomputeActive();
+        const {
+            changeEventTriggered
+        } = this.recomputeActive();
         if (!changeEventTriggered) {
             this._onDidChange.fire({});
         }
@@ -164,10 +161,16 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
         }
         if (newActive !== this._activeEntry) {
             this._activeEntry = newActive;
-            this._onDidChange.fire({ affectOnlyActiveElement: true });
-            return { changeEventTriggered: true };
+            this._onDidChange.fire({
+                affectOnlyActiveElement: true
+            });
+            return {
+                changeEventTriggered: true
+            };
         }
-        return { changeEventTriggered: false };
+        return {
+            changeEventTriggered: false
+        };
     }
     dispose() {
         this._entries.length = 0;
@@ -175,10 +178,6 @@ let NotebookCellOutlineDataSource = class NotebookCellOutlineDataSource {
         this._disposables.dispose();
     }
 };
-NotebookCellOutlineDataSource = ( __decorate([
-    ( __param(1, IMarkerService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, INotebookOutlineEntryFactory))
-], NotebookCellOutlineDataSource));
+NotebookCellOutlineDataSource = ( __decorate([( __param(1, IMarkerService)), ( __param(2, IConfigurationService)), ( __param(3, INotebookOutlineEntryFactory))], NotebookCellOutlineDataSource));
 
 export { NotebookCellOutlineDataSource };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineDataSourceFactory.js

@@ -16,9 +16,7 @@ let NotebookCellOutlineDataSourceReferenceCollection = class NotebookCellOutline
         object.dispose();
     }
 };
-NotebookCellOutlineDataSourceReferenceCollection = ( __decorate([
-    ( __param(0, IInstantiationService))
-], NotebookCellOutlineDataSourceReferenceCollection));
+NotebookCellOutlineDataSourceReferenceCollection = ( __decorate([( __param(0, IInstantiationService))], NotebookCellOutlineDataSourceReferenceCollection));
 let NotebookCellOutlineDataSourceFactory = class NotebookCellOutlineDataSourceFactory {
     constructor(instantiationService) {
         this._data = instantiationService.createInstance(NotebookCellOutlineDataSourceReferenceCollection);
@@ -27,8 +25,6 @@ let NotebookCellOutlineDataSourceFactory = class NotebookCellOutlineDataSourceFa
         return this._data.acquire(editor.getId(), editor);
     }
 };
-NotebookCellOutlineDataSourceFactory = ( __decorate([
-    ( __param(0, IInstantiationService))
-], NotebookCellOutlineDataSourceFactory));
+NotebookCellOutlineDataSourceFactory = ( __decorate([( __param(0, IInstantiationService))], NotebookCellOutlineDataSourceFactory));
 
 export { NotebookCellOutlineDataSourceFactory };

package/vscode/src/vs/workbench/contrib/notebook/browser/viewModel/notebookOutlineEntryFactory.js

@@ -10,7 +10,7 @@ import { INotebookExecutionStateService } from '@codingame/monaco-vscode-api/vsc
 import { ITextModelService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/resolverService.service';
 
 var NotebookOutlineConstants;
-(function (NotebookOutlineConstants) {
+(function(NotebookOutlineConstants) {
     NotebookOutlineConstants[NotebookOutlineConstants["NonHeaderOutlineLevel"] = 7] = "NonHeaderOutlineLevel";
 })(NotebookOutlineConstants || (NotebookOutlineConstants = {}));
 function getMarkdownHeadersInCellFallbackToHtmlTags(fullContent) {
@@ -22,7 +22,10 @@ function getMarkdownHeadersInCellFallbackToHtmlTags(fullContent) {
     if (match) {
         const level = parseInt(match[1]);
         const text = match[2].trim();
-        headers.push({ depth: level, text });
+        headers.push({
+            depth: level,
+            text
+        });
     }
     return headers;
 }
@@ -43,13 +46,21 @@ let NotebookOutlineEntryFactory = class NotebookOutlineEntryFactory {
             const fullContent = cell.getText().substring(0, 10000);
             const cache = this.cachedMarkdownOutlineEntries.get(cell);
             const headers = cache?.alternativeId === cell.getAlternativeId() ? cache.headers : Array.from(getMarkdownHeadersInCellFallbackToHtmlTags(fullContent));
-            this.cachedMarkdownOutlineEntries.set(cell, { alternativeId: cell.getAlternativeId(), headers });
-            for (const { depth, text } of headers) {
+            this.cachedMarkdownOutlineEntries.set(cell, {
+                alternativeId: cell.getAlternativeId(),
+                headers
+            });
+            for (const {
+                depth,
+                text
+            } of headers) {
                 hasHeader = true;
                 entries.push(( new OutlineEntry(index++, depth, cell, text, false, false)));
             }
             if (!hasHeader) {
-                content = renderAsPlaintext({ value: content });
+                content = renderAsPlaintext({
+                    value: content
+                });
             }
         }
         if (!hasHeader) {
@@ -66,7 +77,7 @@ let NotebookOutlineEntryFactory = class NotebookOutlineEntryFactory {
                         !!exeState,
                         exeState ? exeState.isPaused : false
                     )));
-                    cached.forEach((entry) => {
+                    cached.forEach(entry => {
                         entries.push(( new OutlineEntry(
                             index++,
                             entry.level,
@@ -82,7 +93,7 @@ let NotebookOutlineEntryFactory = class NotebookOutlineEntryFactory {
             }
             if (entries.length === 0) {
                 if (preview.length === 0) {
-                    preview = ( localize(9724, "empty cell"));
+                    preview = ( localize(10044, "empty cell"));
                 }
                 entries.push(( new OutlineEntry(
                     index++,
@@ -106,21 +117,21 @@ let NotebookOutlineEntryFactory = class NotebookOutlineEntryFactory {
             const outlineModel = await this.outlineModelService.getOrCreate(textModel, cancelToken);
             const entries = createOutlineEntries(outlineModel.getTopLevelSymbols(), 8);
             this.cellOutlineEntryCache[cell.id] = entries;
-        }
-        finally {
+        } finally {
             ref.dispose();
         }
     }
 };
-NotebookOutlineEntryFactory = ( __decorate([
-    ( __param(0, INotebookExecutionStateService)),
-    ( __param(1, IOutlineModelService)),
-    ( __param(2, ITextModelService))
-], NotebookOutlineEntryFactory));
+NotebookOutlineEntryFactory = ( __decorate([( __param(0, INotebookExecutionStateService)), ( __param(1, IOutlineModelService)), ( __param(2, ITextModelService))], NotebookOutlineEntryFactory));
 function createOutlineEntries(symbols, level) {
     const entries = [];
     symbols.forEach(symbol => {
-        entries.push({ name: symbol.name, range: symbol.range, level, kind: symbol.kind });
+        entries.push({
+            name: symbol.name,
+            range: symbol.range,
+            level,
+            kind: symbol.kind
+        });
         if (symbol.children) {
             entries.push(...createOutlineEntries(symbol.children, level + 1));
         }

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

@@ -3,9 +3,17 @@ import { UndoRedoElementType } from '@codingame/monaco-vscode-api/vscode/vs/plat
 
 class MoveCellEdit {
     get label() {
-        return this.length === 1 ? 'Move Cell' : 'Move Cells';
+        return this.length === 1 ? "Move Cell" : "Move Cells";
     }
-    constructor(resource, fromIndex, length, toIndex, editingDelegate, beforedSelections, endSelections) {
+    constructor(
+        resource,
+        fromIndex,
+        length,
+        toIndex,
+        editingDelegate,
+        beforedSelections,
+        endSelections
+    ) {
         this.resource = resource;
         this.fromIndex = fromIndex;
         this.length = length;
@@ -14,30 +22,42 @@ class MoveCellEdit {
         this.beforedSelections = beforedSelections;
         this.endSelections = endSelections;
         this.type = UndoRedoElementType.Resource;
-        this.code = 'undoredo.textBufferEdit';
+        this.code = "undoredo.textBufferEdit";
     }
     undo() {
         if (!this.editingDelegate.moveCell) {
-            throw ( new Error('Notebook Move Cell not implemented for Undo/Redo'));
+            throw ( new Error("Notebook Move Cell not implemented for Undo/Redo"));
         }
-        this.editingDelegate.moveCell(this.toIndex, this.length, this.fromIndex, this.endSelections, this.beforedSelections);
+        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'));
+            throw ( new Error("Notebook Move Cell not implemented for Undo/Redo"));
         }
-        this.editingDelegate.moveCell(this.fromIndex, this.length, this.toIndex, this.beforedSelections, this.endSelections);
+        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';
+            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 this.diffs[0][1].length > 1 ? "Delete Cells" : "Delete Cell";
         }
-        return 'Insert Cell';
+        return "Insert Cell";
     }
     constructor(resource, diffs, editingDelegate, beforeHandles, endHandles) {
         this.resource = resource;
@@ -46,11 +66,11 @@ class SpliceCellsEdit {
         this.beforeHandles = beforeHandles;
         this.endHandles = endHandles;
         this.type = UndoRedoElementType.Resource;
-        this.code = 'undoredo.textBufferEdit';
+        this.code = "undoredo.textBufferEdit";
     }
     undo() {
         if (!this.editingDelegate.replaceCell) {
-            throw ( new Error('Notebook Replace Cell not implemented for Undo/Redo'));
+            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);
@@ -58,7 +78,7 @@ class SpliceCellsEdit {
     }
     redo() {
         if (!this.editingDelegate.replaceCell) {
-            throw ( new Error('Notebook Replace Cell not implemented for Undo/Redo'));
+            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);
@@ -73,8 +93,8 @@ class CellMetadataEdit {
         this.newMetadata = newMetadata;
         this.editingDelegate = editingDelegate;
         this.type = UndoRedoElementType.Resource;
-        this.label = 'Update Cell Metadata';
-        this.code = 'undoredo.textBufferEdit';
+        this.label = "Update Cell Metadata";
+        this.code = "undoredo.textBufferEdit";
     }
     undo() {
         if (!this.editingDelegate.updateCellMetadata) {