@codingame/monaco-vscode-api 1.83.7 → 1.83.9

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDocumentsAndEditors.js

@@ -1,186 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { diffSets, diffMaps } from 'monaco-editor/esm/vs/base/common/collections.js';
-import { DisposableStore, DisposableMap, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
-import { MainThreadNotebookDocuments } from './mainThreadNotebookDocuments.js';
-import { NotebookDto } from './mainThreadNotebookDto.js';
-import { MainThreadNotebookEditors } from './mainThreadNotebookEditors.js';
-import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { editorGroupToColumn } from '../../services/editor/common/editorGroupColumn.js';
-import { getNotebookEditorFromEditorPane } from '../../contrib/notebook/browser/notebookBrowser.js';
-import { INotebookEditorService } from '../../contrib/notebook/browser/services/notebookEditorService.js';
-import { INotebookService } from '../../contrib/notebook/common/notebookService.js';
-import { IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../services/editor/common/editorService.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { SerializableObjectWithBuffers } from '../../services/extensions/common/proxyIdentifier.js';
-var MainThreadNotebooksAndEditors_1;
-class NotebookAndEditorState {
-    static delta(before, after) {
-        if (!before) {
-            return {
-                addedDocuments: [...after.documents],
-                removedDocuments: [],
-                addedEditors: [...( after.textEditors.values())],
-                removedEditors: [],
-                visibleEditors: ( [...after.visibleEditors].map(editor => editor[0]))
-            };
-        }
-        const documentDelta = diffSets(before.documents, after.documents);
-        const editorDelta = diffMaps(before.textEditors, after.textEditors);
-        const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
-        const visibleEditorDelta = diffMaps(before.visibleEditors, after.visibleEditors);
-        return {
-            addedDocuments: documentDelta.added,
-            removedDocuments: ( documentDelta.removed.map(e => e.uri)),
-            addedEditors: editorDelta.added,
-            removedEditors: ( editorDelta.removed.map(removed => removed.getId())),
-            newActiveEditor: newActiveEditor,
-            visibleEditors: visibleEditorDelta.added.length === 0 && visibleEditorDelta.removed.length === 0
-                ? undefined
-                : ( [...after.visibleEditors].map(editor => editor[0]))
-        };
-    }
-    constructor(documents, textEditors, activeEditor, visibleEditors) {
-        this.documents = documents;
-        this.textEditors = textEditors;
-        this.activeEditor = activeEditor;
-        this.visibleEditors = visibleEditors;
-    }
-}
-let MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = class MainThreadNotebooksAndEditors {
-    constructor(extHostContext, instantiationService, _notebookService, _notebookEditorService, _editorService, _editorGroupService, _logService) {
-        this._notebookService = _notebookService;
-        this._notebookEditorService = _notebookEditorService;
-        this._editorService = _editorService;
-        this._editorGroupService = _editorGroupService;
-        this._logService = _logService;
-        this._disposables = ( new DisposableStore());
-        this._editorListeners = ( new DisposableMap());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebook));
-        this._mainThreadNotebooks = instantiationService.createInstance(MainThreadNotebookDocuments, extHostContext);
-        this._mainThreadEditors = instantiationService.createInstance(MainThreadNotebookEditors, extHostContext);
-        extHostContext.set(MainContext.MainThreadNotebookDocuments, this._mainThreadNotebooks);
-        extHostContext.set(MainContext.MainThreadNotebookEditors, this._mainThreadEditors);
-        this._notebookService.onWillAddNotebookDocument(() => this._updateState(), this, this._disposables);
-        this._notebookService.onDidRemoveNotebookDocument(() => this._updateState(), this, this._disposables);
-        this._editorService.onDidActiveEditorChange(() => this._updateState(), this, this._disposables);
-        this._editorService.onDidVisibleEditorsChange(() => this._updateState(), this, this._disposables);
-        this._notebookEditorService.onDidAddNotebookEditor(this._handleEditorAdd, this, this._disposables);
-        this._notebookEditorService.onDidRemoveNotebookEditor(this._handleEditorRemove, this, this._disposables);
-        this._updateState();
-    }
-    dispose() {
-        this._mainThreadNotebooks.dispose();
-        this._mainThreadEditors.dispose();
-        this._disposables.dispose();
-        this._editorListeners.dispose();
-    }
-    _handleEditorAdd(editor) {
-        this._editorListeners.set(editor.getId(), combinedDisposable(editor.onDidChangeModel(() => this._updateState()), editor.onDidFocusWidget(() => this._updateState(editor))));
-        this._updateState();
-    }
-    _handleEditorRemove(editor) {
-        this._editorListeners.deleteAndDispose(editor.getId());
-        this._updateState();
-    }
-    _updateState(focusedEditor) {
-        const editors = ( new Map());
-        const visibleEditorsMap = ( new Map());
-        for (const editor of this._notebookEditorService.listNotebookEditors()) {
-            if (editor.hasModel()) {
-                editors.set(editor.getId(), editor);
-            }
-        }
-        const activeNotebookEditor = getNotebookEditorFromEditorPane(this._editorService.activeEditorPane);
-        let activeEditor = null;
-        if (activeNotebookEditor) {
-            activeEditor = activeNotebookEditor.getId();
-        }
-        else if (focusedEditor?.textModel) {
-            activeEditor = focusedEditor.getId();
-        }
-        if (activeEditor && !( editors.has(activeEditor))) {
-            this._logService.trace('MainThreadNotebooksAndEditors#_updateState: active editor is not in editors list', activeEditor, ( editors.keys()));
-            activeEditor = null;
-        }
-        for (const editorPane of this._editorService.visibleEditorPanes) {
-            const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
-            if (notebookEditor?.hasModel() && ( editors.has(notebookEditor.getId()))) {
-                visibleEditorsMap.set(notebookEditor.getId(), notebookEditor);
-            }
-        }
-        const newState = ( new NotebookAndEditorState(( new Set(this._notebookService.listNotebookDocuments())), editors, activeEditor, visibleEditorsMap));
-        this._onDelta(NotebookAndEditorState.delta(this._currentState, newState));
-        this._currentState = newState;
-    }
-    _onDelta(delta) {
-        if (MainThreadNotebooksAndEditors_1._isDeltaEmpty(delta)) {
-            return;
-        }
-        const dto = {
-            removedDocuments: delta.removedDocuments,
-            removedEditors: delta.removedEditors,
-            newActiveEditor: delta.newActiveEditor,
-            visibleEditors: delta.visibleEditors,
-            addedDocuments: ( delta.addedDocuments.map(MainThreadNotebooksAndEditors_1._asModelAddData)),
-            addedEditors: ( delta.addedEditors.map(this._asEditorAddData, this)),
-        };
-        this._proxy.$acceptDocumentAndEditorsDelta(( new SerializableObjectWithBuffers(dto)));
-        this._mainThreadEditors.handleEditorsRemoved(delta.removedEditors);
-        this._mainThreadNotebooks.handleNotebooksRemoved(delta.removedDocuments);
-        this._mainThreadNotebooks.handleNotebooksAdded(delta.addedDocuments);
-        this._mainThreadEditors.handleEditorsAdded(delta.addedEditors);
-    }
-    static _isDeltaEmpty(delta) {
-        if (delta.addedDocuments !== undefined && delta.addedDocuments.length > 0) {
-            return false;
-        }
-        if (delta.removedDocuments !== undefined && delta.removedDocuments.length > 0) {
-            return false;
-        }
-        if (delta.addedEditors !== undefined && delta.addedEditors.length > 0) {
-            return false;
-        }
-        if (delta.removedEditors !== undefined && delta.removedEditors.length > 0) {
-            return false;
-        }
-        if (delta.visibleEditors !== undefined && delta.visibleEditors.length > 0) {
-            return false;
-        }
-        if (delta.newActiveEditor !== undefined) {
-            return false;
-        }
-        return true;
-    }
-    static _asModelAddData(e) {
-        return {
-            viewType: e.viewType,
-            uri: e.uri,
-            metadata: e.metadata,
-            versionId: e.versionId,
-            cells: ( e.cells.map(NotebookDto.toNotebookCellDto))
-        };
-    }
-    _asEditorAddData(add) {
-        const pane = this._editorService.visibleEditorPanes.find(pane => getNotebookEditorFromEditorPane(pane) === add);
-        return {
-            id: add.getId(),
-            documentUri: add.textModel.uri,
-            selections: add.getSelections(),
-            visibleRanges: add.visibleRanges,
-            viewColumn: pane && editorGroupToColumn(this._editorGroupService, pane.group)
-        };
-    }
-};
-MainThreadNotebooksAndEditors = MainThreadNotebooksAndEditors_1 = __decorate([
-    extHostCustomer,
-    ( __param(1, IInstantiationService)),
-    ( __param(2, INotebookService)),
-    ( __param(3, INotebookEditorService)),
-    ( __param(4, IEditorService)),
-    ( __param(5, IEditorGroupsService)),
-    ( __param(6, ILogService))
-], MainThreadNotebooksAndEditors);
-export { MainThreadNotebooksAndEditors };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookDto.js

@@ -1,127 +0,0 @@
-import { CellExecutionUpdateType } from '../../contrib/notebook/common/notebookExecutionService.js';
-var NotebookDto;
-( (function(NotebookDto) {
-    function toNotebookOutputItemDto(item) {
-        return {
-            mime: item.mime,
-            valueBytes: item.data
-        };
-    }
-    NotebookDto.toNotebookOutputItemDto = toNotebookOutputItemDto;
-    function toNotebookOutputDto(output) {
-        return {
-            outputId: output.outputId,
-            metadata: output.metadata,
-            items: ( output.outputs.map(toNotebookOutputItemDto))
-        };
-    }
-    NotebookDto.toNotebookOutputDto = toNotebookOutputDto;
-    function toNotebookCellDataDto(cell) {
-        return {
-            cellKind: cell.cellKind,
-            language: cell.language,
-            mime: cell.mime,
-            source: cell.source,
-            internalMetadata: cell.internalMetadata,
-            metadata: cell.metadata,
-            outputs: ( cell.outputs.map(toNotebookOutputDto))
-        };
-    }
-    NotebookDto.toNotebookCellDataDto = toNotebookCellDataDto;
-    function toNotebookDataDto(data) {
-        return {
-            metadata: data.metadata,
-            cells: ( data.cells.map(toNotebookCellDataDto))
-        };
-    }
-    NotebookDto.toNotebookDataDto = toNotebookDataDto;
-    function fromNotebookOutputItemDto(item) {
-        return {
-            mime: item.mime,
-            data: item.valueBytes
-        };
-    }
-    NotebookDto.fromNotebookOutputItemDto = fromNotebookOutputItemDto;
-    function fromNotebookOutputDto(output) {
-        return {
-            outputId: output.outputId,
-            metadata: output.metadata,
-            outputs: ( output.items.map(fromNotebookOutputItemDto))
-        };
-    }
-    NotebookDto.fromNotebookOutputDto = fromNotebookOutputDto;
-    function fromNotebookCellDataDto(cell) {
-        return {
-            cellKind: cell.cellKind,
-            language: cell.language,
-            mime: cell.mime,
-            source: cell.source,
-            outputs: ( cell.outputs.map(fromNotebookOutputDto)),
-            metadata: cell.metadata,
-            internalMetadata: cell.internalMetadata
-        };
-    }
-    NotebookDto.fromNotebookCellDataDto = fromNotebookCellDataDto;
-    function fromNotebookDataDto(data) {
-        return {
-            metadata: data.metadata,
-            cells: ( data.cells.map(fromNotebookCellDataDto))
-        };
-    }
-    NotebookDto.fromNotebookDataDto = fromNotebookDataDto;
-    function toNotebookCellDto(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(toNotebookOutputDto)),
-            metadata: cell.metadata,
-            internalMetadata: cell.internalMetadata,
-        };
-    }
-    NotebookDto.toNotebookCellDto = toNotebookCellDto;
-    function fromCellExecuteUpdateDto(data) {
-        if (data.editType === CellExecutionUpdateType.Output) {
-            return {
-                editType: data.editType,
-                cellHandle: data.cellHandle,
-                append: data.append,
-                outputs: ( data.outputs.map(fromNotebookOutputDto))
-            };
-        }
-        else if (data.editType === CellExecutionUpdateType.OutputItems) {
-            return {
-                editType: data.editType,
-                append: data.append,
-                outputId: data.outputId,
-                items: ( data.items.map(fromNotebookOutputItemDto))
-            };
-        }
-        else {
-            return data;
-        }
-    }
-    NotebookDto.fromCellExecuteUpdateDto = fromCellExecuteUpdateDto;
-    function fromCellExecuteCompleteDto(data) {
-        return data;
-    }
-    NotebookDto.fromCellExecuteCompleteDto = fromCellExecuteCompleteDto;
-    function fromCellEditOperationDto(edit) {
-        if (edit.editType === 1 ) {
-            return {
-                editType: edit.editType,
-                index: edit.index,
-                count: edit.count,
-                cells: ( edit.cells.map(fromNotebookCellDataDto))
-            };
-        }
-        else {
-            return edit;
-        }
-    }
-    NotebookDto.fromCellEditOperationDto = fromCellEditOperationDto;
-})(NotebookDto || (NotebookDto = {})));
-export { NotebookDto };

package/vscode/src/vs/workbench/api/browser/mainThreadNotebookEditors.js

@@ -1,129 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { DisposableStore, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { equals } from 'monaco-editor/esm/vs/base/common/objects.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { EditorActivation } from 'monaco-editor/esm/vs/platform/editor/common/editor.js';
-import { getNotebookEditorFromEditorPane } from '../../contrib/notebook/browser/notebookBrowser.js';
-import { INotebookEditorService } from '../../contrib/notebook/browser/services/notebookEditorService.js';
-import { editorGroupToColumn, columnToEditorGroup } from '../../services/editor/common/editorGroupColumn.js';
-import { IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
-import { IEditorService } from '../../services/editor/common/editorService.js';
-import { ExtHostContext, NotebookEditorRevealType } from '../common/extHost.protocol.js';
-class MainThreadNotebook {
-    constructor(editor, disposables) {
-        this.editor = editor;
-        this.disposables = disposables;
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-}
-let MainThreadNotebookEditors = class MainThreadNotebookEditors {
-    constructor(extHostContext, _editorService, _notebookEditorService, _editorGroupService, _configurationService) {
-        this._editorService = _editorService;
-        this._notebookEditorService = _notebookEditorService;
-        this._editorGroupService = _editorGroupService;
-        this._configurationService = _configurationService;
-        this._disposables = ( new DisposableStore());
-        this._mainThreadEditors = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostNotebookEditors));
-        this._editorService.onDidActiveEditorChange(() => this._updateEditorViewColumns(), this, this._disposables);
-        this._editorGroupService.onDidRemoveGroup(() => this._updateEditorViewColumns(), this, this._disposables);
-        this._editorGroupService.onDidMoveGroup(() => this._updateEditorViewColumns(), this, this._disposables);
-    }
-    dispose() {
-        this._disposables.dispose();
-        dispose(( this._mainThreadEditors.values()));
-    }
-    handleEditorsAdded(editors) {
-        for (const editor of editors) {
-            const editorDisposables = ( new DisposableStore());
-            editorDisposables.add(editor.onDidChangeVisibleRanges(() => {
-                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { visibleRanges: { ranges: editor.visibleRanges } });
-            }));
-            editorDisposables.add(editor.onDidChangeSelection(() => {
-                this._proxy.$acceptEditorPropertiesChanged(editor.getId(), { selections: { selections: editor.getSelections() } });
-            }));
-            const wrapper = ( new MainThreadNotebook(editor, editorDisposables));
-            this._mainThreadEditors.set(editor.getId(), wrapper);
-        }
-    }
-    handleEditorsRemoved(editorIds) {
-        for (const id of editorIds) {
-            this._mainThreadEditors.get(id)?.dispose();
-            this._mainThreadEditors.delete(id);
-        }
-    }
-    _updateEditorViewColumns() {
-        const result = Object.create(null);
-        for (const editorPane of this._editorService.visibleEditorPanes) {
-            const candidate = getNotebookEditorFromEditorPane(editorPane);
-            if (candidate && ( this._mainThreadEditors.has(candidate.getId()))) {
-                result[candidate.getId()] = editorGroupToColumn(this._editorGroupService, editorPane.group);
-            }
-        }
-        if (!equals(result, this._currentViewColumnInfo)) {
-            this._currentViewColumnInfo = result;
-            this._proxy.$acceptEditorViewColumns(result);
-        }
-    }
-    async $tryShowNotebookDocument(resource, viewType, options) {
-        const editorOptions = {
-            cellSelections: options.selections,
-            preserveFocus: options.preserveFocus,
-            pinned: options.pinned,
-            activation: options.preserveFocus ? EditorActivation.RESTORE : undefined,
-            override: viewType
-        };
-        const editorPane = await this._editorService.openEditor({ resource: URI.revive(resource), options: editorOptions }, columnToEditorGroup(this._editorGroupService, this._configurationService, options.position));
-        const notebookEditor = getNotebookEditorFromEditorPane(editorPane);
-        if (notebookEditor) {
-            return notebookEditor.getId();
-        }
-        else {
-            throw new Error(`Notebook Editor creation failure for document ${JSON.stringify(resource)}`);
-        }
-    }
-    async $tryRevealRange(id, range, revealType) {
-        const editor = this._notebookEditorService.getNotebookEditor(id);
-        if (!editor) {
-            return;
-        }
-        const notebookEditor = editor;
-        if (!notebookEditor.hasModel()) {
-            return;
-        }
-        if (range.start >= notebookEditor.getLength()) {
-            return;
-        }
-        const cell = notebookEditor.cellAt(range.start);
-        switch (revealType) {
-            case NotebookEditorRevealType.Default:
-                return notebookEditor.revealCellRangeInView(range);
-            case NotebookEditorRevealType.InCenter:
-                return notebookEditor.revealInCenter(cell);
-            case NotebookEditorRevealType.InCenterIfOutsideViewport:
-                return notebookEditor.revealInCenterIfOutsideViewport(cell);
-            case NotebookEditorRevealType.AtTop:
-                return notebookEditor.revealInViewAtTop(cell);
-        }
-    }
-    $trySetSelections(id, ranges) {
-        const editor = this._notebookEditorService.getNotebookEditor(id);
-        if (!editor) {
-            return;
-        }
-        editor.setSelections(ranges);
-        if (ranges.length) {
-            editor.setFocus({ start: ranges[0].start, end: ranges[0].start + 1 });
-        }
-    }
-};
-MainThreadNotebookEditors = ( __decorate([
-    ( __param(1, IEditorService)),
-    ( __param(2, INotebookEditorService)),
-    ( __param(3, IEditorGroupsService)),
-    ( __param(4, IConfigurationService))
-], MainThreadNotebookEditors));
-export { MainThreadNotebookEditors };