@codingame/monaco-vscode-api 1.85.0 → 1.85.2

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorInput.js

@@ -0,0 +1,296 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import { SimpleNotebookProviderInfo, INotebookService } from './notebookService.js';
+import { joinPath, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
+import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
+import { INotebookEditorModelResolverService } from './notebookEditorModelResolverService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { AbstractResourceEditorInput } from '../../../common/editor/resourceEditorInput.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+import { IExtensionService } from '../../../services/extensions/common/extensions.js';
+import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
+var NotebookEditorInput_1;
+let NotebookEditorInput = class NotebookEditorInput extends AbstractResourceEditorInput {
+    static { NotebookEditorInput_1 = this; }
+    static { this.EditorCache = {}; }
+    static getOrCreate(instantiationService, resource, preferredResource, viewType, options = {}) {
+        const cacheId = `${( resource.toString())}|${viewType}|${options._workingCopy?.typeId}`;
+        let editor = NotebookEditorInput_1.EditorCache[cacheId];
+        if (!editor) {
+            editor = instantiationService.createInstance(NotebookEditorInput_1, resource, preferredResource, viewType, options);
+            NotebookEditorInput_1.EditorCache[cacheId] = editor;
+            editor.onWillDispose(() => {
+                delete NotebookEditorInput_1.EditorCache[cacheId];
+            });
+        }
+        else if (preferredResource) {
+            editor.setPreferredResource(preferredResource);
+        }
+        return editor;
+    }
+    static { this.ID = 'workbench.input.notebook'; }
+    constructor(resource, preferredResource, viewType, options, _notebookService, _notebookModelResolverService, _fileDialogService, labelService, fileService, filesConfigurationService, extensionService, editorService) {
+        super(resource, preferredResource, labelService, fileService, filesConfigurationService);
+        this.viewType = viewType;
+        this.options = options;
+        this._notebookService = _notebookService;
+        this._notebookModelResolverService = _notebookModelResolverService;
+        this._fileDialogService = _fileDialogService;
+        this._editorModelReference = null;
+        this._defaultDirtyState = false;
+        this._defaultDirtyState = !!options.startDirty;
+        this._sideLoadedListener = _notebookService.onDidAddNotebookDocument(e => {
+            if (e.viewType === this.viewType && ( e.uri.toString()) === ( this.resource.toString())) {
+                this.resolve().catch(onUnexpectedError);
+            }
+        });
+        this._register(extensionService.onWillStop(e => {
+            if (!this.isDirty()) {
+                return;
+            }
+            e.veto((async () => {
+                const editors = editorService.findEditors(this);
+                if (editors.length > 0) {
+                    const result = await editorService.save(editors[0]);
+                    if (result.success) {
+                        return false;
+                    }
+                }
+                return true;
+            })(), ( localizeWithPath(
+                'vs/workbench/contrib/notebook/common/notebookEditorInput',
+                'vetoExtHostRestart',
+                "Notebook '{0}' could not be saved.",
+                this.resource.path
+            )));
+        }));
+    }
+    dispose() {
+        this._sideLoadedListener.dispose();
+        this._editorModelReference?.dispose();
+        this._editorModelReference = null;
+        super.dispose();
+    }
+    get typeId() {
+        return NotebookEditorInput_1.ID;
+    }
+    get editorId() {
+        return this.viewType;
+    }
+    get capabilities() {
+        let capabilities = 1024 ;
+        if (this.resource.scheme === Schemas.untitled) {
+            capabilities |= 4 ;
+        }
+        if (this._editorModelReference) {
+            if (this._editorModelReference.object.isReadonly()) {
+                capabilities |= 2 ;
+            }
+        }
+        else {
+            if (this.filesConfigurationService.isReadonly(this.resource)) {
+                capabilities |= 2 ;
+            }
+        }
+        if (!((capabilities & 2) )) {
+            capabilities |= 128 ;
+        }
+        return capabilities;
+    }
+    getDescription(verbosity = 1 ) {
+        if (!this.hasCapability(4 ) || this._editorModelReference?.object.hasAssociatedFilePath()) {
+            return super.getDescription(verbosity);
+        }
+        return undefined;
+    }
+    isReadonly() {
+        if (!this._editorModelReference) {
+            return this.filesConfigurationService.isReadonly(this.resource);
+        }
+        return this._editorModelReference.object.isReadonly();
+    }
+    isDirty() {
+        if (!this._editorModelReference) {
+            return this._defaultDirtyState;
+        }
+        return this._editorModelReference.object.isDirty();
+    }
+    isSaving() {
+        const model = this._editorModelReference?.object;
+        if (!model || !model.isDirty() || model.hasErrorState || this.hasCapability(4 )) {
+            return false;
+        }
+        return this.filesConfigurationService.getAutoSaveMode() === 1 ;
+    }
+    async save(group, options) {
+        if (this._editorModelReference) {
+            if (this.hasCapability(4 )) {
+                return this.saveAs(group, options);
+            }
+            else {
+                await this._editorModelReference.object.save(options);
+            }
+            return this;
+        }
+        return undefined;
+    }
+    async saveAs(group, options) {
+        if (!this._editorModelReference) {
+            return undefined;
+        }
+        const provider = this._notebookService.getContributedNotebookType(this.viewType);
+        if (!provider) {
+            return undefined;
+        }
+        const pathCandidate = this.hasCapability(4 ) ? await this._suggestName(provider, this.labelService.getUriBasenameLabel(this.resource)) : this._editorModelReference.object.resource;
+        let target;
+        if (this._editorModelReference.object.hasAssociatedFilePath()) {
+            target = pathCandidate;
+        }
+        else {
+            target = await this._fileDialogService.pickFileToSave(pathCandidate, options?.availableFileSystems);
+            if (!target) {
+                return undefined;
+            }
+        }
+        if (!provider.matches(target)) {
+            const patterns = ( provider.selectors.map(pattern => {
+                if (typeof pattern === 'string') {
+                    return pattern;
+                }
+                if (glob.isRelativePattern(pattern)) {
+                    return `${pattern} (base ${pattern.base})`;
+                }
+                if (pattern.exclude) {
+                    return `${pattern.include} (exclude: ${pattern.exclude})`;
+                }
+                else {
+                    return `${pattern.include}`;
+                }
+            })).join(', ');
+            throw new Error(`File name ${target} is not supported by ${provider.providerDisplayName}.\n\nPlease make sure the file name matches following patterns:\n${patterns}`);
+        }
+        return await this._editorModelReference.object.saveAs(target);
+    }
+    async _suggestName(provider, suggestedFilename) {
+        const firstSelector = provider.selectors[0];
+        let selectorStr = firstSelector && typeof firstSelector === 'string' ? firstSelector : undefined;
+        if (!selectorStr && firstSelector) {
+            const include = firstSelector.include;
+            if (typeof include === 'string') {
+                selectorStr = include;
+            }
+        }
+        if (selectorStr) {
+            const matches = /^\*\.([A-Za-z_-]*)$/.exec(selectorStr);
+            if (matches && matches.length > 1) {
+                const fileExt = matches[1];
+                if (!suggestedFilename.endsWith(fileExt)) {
+                    return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename + '.' + fileExt);
+                }
+            }
+        }
+        return joinPath(await this._fileDialogService.defaultFilePath(), suggestedFilename);
+    }
+    async rename(group, target) {
+        if (this._editorModelReference) {
+            return { editor: { resource: target }, options: { override: this.viewType } };
+        }
+        return undefined;
+    }
+    async revert(_group, options) {
+        if (this._editorModelReference && this._editorModelReference.object.isDirty()) {
+            await this._editorModelReference.object.revert(options);
+        }
+    }
+    async resolve(_options, perf) {
+        if (!(await this._notebookService.canResolve(this.viewType))) {
+            return null;
+        }
+        perf?.mark('extensionActivated');
+        this._sideLoadedListener.dispose();
+        if (!this._editorModelReference) {
+            const ref = await this._notebookModelResolverService.resolve(this.resource, this.viewType);
+            if (this._editorModelReference) {
+                ref.dispose();
+                return this._editorModelReference.object;
+            }
+            this._editorModelReference = ref;
+            if (this.isDisposed()) {
+                this._editorModelReference.dispose();
+                this._editorModelReference = null;
+                return null;
+            }
+            this._register(this._editorModelReference.object.onDidChangeDirty(() => this._onDidChangeDirty.fire()));
+            this._register(this._editorModelReference.object.onDidChangeReadonly(() => this._onDidChangeCapabilities.fire()));
+            this._register(this._editorModelReference.object.onDidRevertUntitled(() => this.dispose()));
+            if (this._editorModelReference.object.isDirty()) {
+                this._onDidChangeDirty.fire();
+            }
+        }
+        else {
+            this._editorModelReference.object.load();
+        }
+        if (this.options._backupId) {
+            const info = await this._notebookService.withNotebookDataProvider(this._editorModelReference.object.notebook.viewType);
+            if (!(info instanceof SimpleNotebookProviderInfo)) {
+                throw new Error('CANNOT open file notebook with this provider');
+            }
+            const data = await info.serializer.dataToNotebook(VSBuffer.fromString(JSON.stringify({ __webview_backup: this.options._backupId })));
+            this._editorModelReference.object.notebook.applyEdits([
+                {
+                    editType: 1 ,
+                    index: 0,
+                    count: this._editorModelReference.object.notebook.length,
+                    cells: data.cells
+                }
+            ], true, undefined, () => undefined, undefined, false);
+            if (this.options._workingCopy) {
+                this.options._backupId = undefined;
+                this.options._workingCopy = undefined;
+                this.options.startDirty = undefined;
+            }
+        }
+        return this._editorModelReference.object;
+    }
+    toUntyped() {
+        return {
+            resource: this.resource,
+            options: {
+                override: this.viewType
+            }
+        };
+    }
+    matches(otherInput) {
+        if (super.matches(otherInput)) {
+            return true;
+        }
+        if (otherInput instanceof NotebookEditorInput_1) {
+            return this.viewType === otherInput.viewType && isEqual(this.resource, otherInput.resource);
+        }
+        return false;
+    }
+};
+NotebookEditorInput = NotebookEditorInput_1 = ( __decorate([
+    ( __param(4, INotebookService)),
+    ( __param(5, INotebookEditorModelResolverService)),
+    ( __param(6, IFileDialogService)),
+    ( __param(7, ILabelService)),
+    ( __param(8, IFileService)),
+    ( __param(9, IFilesConfigurationService)),
+    ( __param(10, IExtensionService)),
+    ( __param(11, IEditorService))
+], NotebookEditorInput));
+function isCompositeNotebookEditorInput(thing) {
+    return !!thing
+        && typeof thing === 'object'
+        && Array.isArray(thing.editorInputs)
+        && (thing.editorInputs.every(input => input instanceof NotebookEditorInput));
+}
+export { NotebookEditorInput, isCompositeNotebookEditorInput };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookEditorModel.js

@@ -0,0 +1,261 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { bufferToStream, streamToBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { filter } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { assertType } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { EditorModel } from '../../../common/editor/editorModel.js';
+import { NotebookCellsChangeType, NotebookSetting } from './notebookCommon.js';
+import { SimpleNotebookProviderInfo, INotebookService } from './notebookService.js';
+import { IFilesConfigurationService } from '../../../services/filesConfiguration/common/filesConfigurationService.js';
+var SimpleNotebookEditorModel_1;
+let SimpleNotebookEditorModel = SimpleNotebookEditorModel_1 = class SimpleNotebookEditorModel extends EditorModel {
+    constructor(resource, _hasAssociatedFilePath, viewType, _workingCopyManager, _filesConfigurationService) {
+        super();
+        this.resource = resource;
+        this._hasAssociatedFilePath = _hasAssociatedFilePath;
+        this.viewType = viewType;
+        this._workingCopyManager = _workingCopyManager;
+        this._filesConfigurationService = _filesConfigurationService;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this._onDidSave = this._register(( new Emitter()));
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this._onDidRevertUntitled = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this.onDidSave = this._onDidSave.event;
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this.onDidRevertUntitled = this._onDidRevertUntitled.event;
+        this._workingCopyListeners = this._register(( new DisposableStore()));
+        this.scratchPad = viewType === 'interactive';
+    }
+    dispose() {
+        this._workingCopy?.dispose();
+        super.dispose();
+    }
+    get notebook() {
+        return this._workingCopy?.model?.notebookModel;
+    }
+    isResolved() {
+        return Boolean(this._workingCopy?.model?.notebookModel);
+    }
+    async canDispose() {
+        if (!this._workingCopy) {
+            return true;
+        }
+        if (SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy)) {
+            return this._workingCopyManager.stored.canDispose(this._workingCopy);
+        }
+        else {
+            return true;
+        }
+    }
+    isDirty() {
+        return this._workingCopy?.isDirty() ?? false;
+    }
+    isModified() {
+        return this._workingCopy?.isModified() ?? false;
+    }
+    isOrphaned() {
+        return SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy) && this._workingCopy.hasState(4 );
+    }
+    hasAssociatedFilePath() {
+        return !SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy) && !!this._workingCopy?.hasAssociatedFilePath;
+    }
+    isReadonly() {
+        if (SimpleNotebookEditorModel_1._isStoredFileWorkingCopy(this._workingCopy)) {
+            return this._workingCopy?.isReadonly();
+        }
+        else {
+            return this._filesConfigurationService.isReadonly(this.resource);
+        }
+    }
+    get hasErrorState() {
+        if (this._workingCopy && 'hasState' in this._workingCopy) {
+            return this._workingCopy.hasState(5 );
+        }
+        return false;
+    }
+    revert(options) {
+        assertType(this.isResolved());
+        return this._workingCopy.revert(options);
+    }
+    save(options) {
+        assertType(this.isResolved());
+        return this._workingCopy.save(options);
+    }
+    async load(options) {
+        if (!this._workingCopy || !this._workingCopy.model) {
+            if (this.resource.scheme === Schemas.untitled) {
+                if (this._hasAssociatedFilePath) {
+                    this._workingCopy = await this._workingCopyManager.resolve({ associatedResource: this.resource });
+                }
+                else {
+                    this._workingCopy = await this._workingCopyManager.resolve({ untitledResource: this.resource, isScratchpad: this.scratchPad });
+                }
+                this._workingCopy.onDidRevert(() => this._onDidRevertUntitled.fire());
+            }
+            else {
+                this._workingCopy = await this._workingCopyManager.resolve(this.resource, options?.forceReadFromFile ? { reload: { async: false, force: true } } : undefined);
+                this._workingCopyListeners.add(this._workingCopy.onDidSave(e => this._onDidSave.fire(e)));
+                this._workingCopyListeners.add(this._workingCopy.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
+                this._workingCopyListeners.add(this._workingCopy.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
+            }
+            this._workingCopyListeners.add(this._workingCopy.onDidChangeDirty(() => this._onDidChangeDirty.fire(), undefined));
+            this._workingCopyListeners.add(this._workingCopy.onWillDispose(() => {
+                this._workingCopyListeners.clear();
+                this._workingCopy?.model?.dispose();
+            }));
+        }
+        else {
+            await this._workingCopyManager.resolve(this.resource, {
+                reload: {
+                    async: !options?.forceReadFromFile,
+                    force: options?.forceReadFromFile
+                }
+            });
+        }
+        assertType(this.isResolved());
+        return this;
+    }
+    async saveAs(target) {
+        const newWorkingCopy = await this._workingCopyManager.saveAs(this.resource, target);
+        if (!newWorkingCopy) {
+            return undefined;
+        }
+        return { resource: newWorkingCopy.resource };
+    }
+    static _isStoredFileWorkingCopy(candidate) {
+        const isUntitled = candidate && candidate.capabilities & 2 ;
+        return !isUntitled;
+    }
+};
+SimpleNotebookEditorModel = SimpleNotebookEditorModel_1 = ( __decorate([
+    ( __param(4, IFilesConfigurationService))
+], SimpleNotebookEditorModel));
+class NotebookFileWorkingCopyModel extends Disposable {
+    constructor(_notebookModel, _notebookService, _configurationService) {
+        super();
+        this._notebookModel = _notebookModel;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+        this._onDidChangeContent = this._register(( new Emitter()));
+        this.onDidChangeContent = this._onDidChangeContent.event;
+        this.configuration = undefined;
+        this.onWillDispose = _notebookModel.onWillDispose.bind(_notebookModel);
+        this._register(_notebookModel.onDidChangeContent(e => {
+            for (const rawEvent of e.rawEvents) {
+                if (rawEvent.kind === NotebookCellsChangeType.Initialize) {
+                    continue;
+                }
+                if (rawEvent.transient) {
+                    continue;
+                }
+                this._onDidChangeContent.fire({
+                    isRedoing: false,
+                    isUndoing: false,
+                    isInitial: false,
+                });
+                break;
+            }
+        }));
+        if (_notebookModel.uri.scheme === Schemas.vscodeRemote) {
+            this.configuration = {
+                backupDelay: 10000
+            };
+            if (this._configurationService.getValue(NotebookSetting.remoteSaving)) {
+                this.save = async (options, token) => {
+                    const serializer = await this.getNotebookSerializer();
+                    if (token.isCancellationRequested) {
+                        throw new CancellationError();
+                    }
+                    const stat = await serializer.save(this._notebookModel.uri, this._notebookModel.versionId, options, token);
+                    return stat;
+                };
+            }
+        }
+    }
+    dispose() {
+        this._notebookModel.dispose();
+        super.dispose();
+    }
+    get notebookModel() {
+        return this._notebookModel;
+    }
+    async snapshot(token) {
+        const serializer = await this.getNotebookSerializer();
+        const data = {
+            metadata: filter(this._notebookModel.metadata, key => !serializer.options.transientDocumentMetadata[key]),
+            cells: [],
+        };
+        for (const cell of this._notebookModel.cells) {
+            const cellData = {
+                cellKind: cell.cellKind,
+                language: cell.language,
+                mime: cell.mime,
+                source: cell.getValue(),
+                outputs: [],
+                internalMetadata: cell.internalMetadata
+            };
+            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);
+        if (token.isCancellationRequested) {
+            throw new CancellationError();
+        }
+        return bufferToStream(bytes);
+    }
+    async update(stream, token) {
+        const serializer = await this.getNotebookSerializer();
+        const bytes = await streamToBuffer(stream);
+        const data = await serializer.dataToNotebook(bytes);
+        if (token.isCancellationRequested) {
+            throw new CancellationError();
+        }
+        this._notebookModel.reset(data.cells, data.metadata, serializer.options);
+    }
+    async getNotebookSerializer() {
+        const info = await this._notebookService.withNotebookDataProvider(this.notebookModel.viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            throw new Error('CANNOT open file notebook with this provider');
+        }
+        return info.serializer;
+    }
+    get versionId() {
+        return this._notebookModel.alternativeVersionId;
+    }
+    pushStackElement() {
+        this._notebookModel.pushStackElement('save', undefined, undefined);
+    }
+}
+let NotebookFileWorkingCopyModelFactory = class NotebookFileWorkingCopyModelFactory {
+    constructor(_viewType, _notebookService, _configurationService) {
+        this._viewType = _viewType;
+        this._notebookService = _notebookService;
+        this._configurationService = _configurationService;
+    }
+    async createModel(resource, stream, token) {
+        const info = await this._notebookService.withNotebookDataProvider(this._viewType);
+        if (!(info instanceof SimpleNotebookProviderInfo)) {
+            throw new Error('CANNOT open file notebook with this provider');
+        }
+        const bytes = await streamToBuffer(stream);
+        const data = await info.serializer.dataToNotebook(bytes);
+        if (token.isCancellationRequested) {
+            throw new CancellationError();
+        }
+        const notebookModel = this._notebookService.createNotebookTextModel(info.viewType, resource, data, info.serializer.options);
+        return ( new NotebookFileWorkingCopyModel(notebookModel, this._notebookService, this._configurationService));
+    }
+};
+NotebookFileWorkingCopyModelFactory = ( __decorate([
+    ( __param(1, INotebookService)),
+    ( __param(2, IConfigurationService))
+], NotebookFileWorkingCopyModelFactory));
+export { NotebookFileWorkingCopyModel, NotebookFileWorkingCopyModelFactory, SimpleNotebookEditorModel };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookExecutionService.js

@@ -1,7 +1,9 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 var CellExecutionUpdateType;
 ( (function(CellExecutionUpdateType) {
     CellExecutionUpdateType[CellExecutionUpdateType["Output"] = 1] = "Output";
     CellExecutionUpdateType[CellExecutionUpdateType["OutputItems"] = 2] = "OutputItems";
     CellExecutionUpdateType[CellExecutionUpdateType["ExecutionState"] = 3] = "ExecutionState";
 })(CellExecutionUpdateType || (CellExecutionUpdateType = {})));
-export { CellExecutionUpdateType };
+const INotebookExecutionService = ( createDecorator('INotebookExecutionService'));
+export { CellExecutionUpdateType, INotebookExecutionService };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookKernelService.js

@@ -1,3 +1,4 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const INotebookKernelService = ( createDecorator('INotebookKernelService'));
-export { INotebookKernelService };
+const INotebookKernelHistoryService = ( createDecorator('INotebookKernelHistoryService'));
+export { INotebookKernelHistoryService, INotebookKernelService };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookKeymapService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const INotebookKeymapService = ( createDecorator('notebookKeymapService'));
+export { INotebookKeymapService };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookLoggingService.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const INotebookLoggingService = ( createDecorator('INotebookLoggingService'));
+export { INotebookLoggingService };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookPerformance.js

@@ -0,0 +1,16 @@
+class NotebookPerfMarks {
+    constructor() {
+        this._marks = {};
+    }
+    get value() {
+        return { ...this._marks };
+    }
+    mark(name) {
+        if (this._marks[name]) {
+            console.error(`Skipping overwrite of notebook perf value: ${name}`);
+            return;
+        }
+        this._marks[name] = Date.now();
+    }
+}
+export { NotebookPerfMarks };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookRange.js

@@ -0,0 +1,66 @@
+function isICellRange(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    return typeof candidate.start === 'number'
+        && typeof candidate.end === 'number';
+}
+function cellIndexesToRanges(indexes) {
+    indexes.sort((a, b) => a - b);
+    const first = indexes.shift();
+    if (first === undefined) {
+        return [];
+    }
+    return ( indexes.reduce(function (ranges, num) {
+        if (num <= ranges[0][1]) {
+            ranges[0][1] = num + 1;
+        }
+        else {
+            ranges.unshift([num, num + 1]);
+        }
+        return ranges;
+    }, [[first, first + 1]]).reverse().map(val => ({ start: val[0], end: val[1] })));
+}
+function cellRangesToIndexes(ranges) {
+    const indexes = ranges.reduce((a, b) => {
+        for (let i = b.start; i < b.end; i++) {
+            a.push(i);
+        }
+        return a;
+    }, []);
+    return indexes;
+}
+function reduceCellRanges(ranges) {
+    const sorted = ranges.sort((a, b) => a.start - b.start);
+    const first = sorted[0];
+    if (!first) {
+        return [];
+    }
+    return sorted.reduce((prev, curr) => {
+        const last = prev[prev.length - 1];
+        if (last.end >= curr.start) {
+            last.end = Math.max(last.end, curr.end);
+        }
+        else {
+            prev.push(curr);
+        }
+        return prev;
+    }, [first]);
+}
+function cellRangesEqual(a, b) {
+    a = reduceCellRanges(a);
+    b = reduceCellRanges(b);
+    if (a.length !== b.length) {
+        return false;
+    }
+    for (let i = 0; i < a.length; i++) {
+        if (a[i].start !== b[i].start || a[i].end !== b[i].end) {
+            return false;
+        }
+    }
+    return true;
+}
+function cellRangeContains(range, other) {
+    return other.start >= range.start && other.end <= range.end;
+}
+export { cellIndexesToRanges, cellRangeContains, cellRangesEqual, cellRangesToIndexes, isICellRange, reduceCellRanges };

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

@@ -0,0 +1,4 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ID_NOTEBOOK_EDITOR_WORKER_SERVICE = 'notebookEditorWorkerService';
+const INotebookEditorWorkerService = ( createDecorator(ID_NOTEBOOK_EDITOR_WORKER_SERVICE));
+export { ID_NOTEBOOK_EDITOR_WORKER_SERVICE, INotebookEditorWorkerService };