@codingame/monaco-vscode-api 1.83.8 → 1.83.9

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

@@ -1,368 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
-import { DisposableStore, DisposableMap, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { isCodeEditor, isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
-import { shouldSynchronizeModel } from 'monaco-editor/esm/vs/editor/common/model.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
-import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
-import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainThreadDocuments } from './mainThreadDocuments.js';
-import { MainThreadTextEditor } from './mainThreadEditor.js';
-import { MainThreadTextEditors } from './mainThreadEditors.js';
-import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
-import { AbstractTextEditor as FakeAbstractTextEditor } from '../../../../../../override/vs/workbench/browser/parts/editor/textEditor.weak.js';
-import { editorGroupToColumn } from '../../services/editor/common/editorGroupColumn.js';
-import { IEditorService } from '../../services/editor/common/editorService.js';
-import { IEditorGroupsService } from '../../services/editor/common/editorGroupsService.js';
-import { ITextFileService } from '../../services/textfile/common/textfiles.js';
-import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
-import { IWorkingCopyFileService } from '../../services/workingCopy/common/workingCopyFileService.js';
-import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
-import { IClipboardService } from 'monaco-editor/esm/vs/platform/clipboard/common/clipboardService.js';
-import { IPathService } from '../../services/path/common/pathService.js';
-import { diffSets, diffMaps } from 'monaco-editor/esm/vs/base/common/collections.js';
-import { IPaneCompositePartService } from '../../services/panecomposite/browser/panecomposite.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-class TextEditorSnapshot {
-    constructor(editor) {
-        this.editor = editor;
-        this.id = `${editor.getId()},${editor.getModel().id}`;
-    }
-}
-class DocumentAndEditorStateDelta {
-    constructor(removedDocuments, addedDocuments, removedEditors, addedEditors, oldActiveEditor, newActiveEditor) {
-        this.removedDocuments = removedDocuments;
-        this.addedDocuments = addedDocuments;
-        this.removedEditors = removedEditors;
-        this.addedEditors = addedEditors;
-        this.oldActiveEditor = oldActiveEditor;
-        this.newActiveEditor = newActiveEditor;
-        this.isEmpty = this.removedDocuments.length === 0
-            && this.addedDocuments.length === 0
-            && this.removedEditors.length === 0
-            && this.addedEditors.length === 0
-            && oldActiveEditor === newActiveEditor;
-    }
-    toString() {
-        let ret = 'DocumentAndEditorStateDelta\n';
-        ret += `\tRemoved Documents: [${( this.removedDocuments.map(d => ( d.uri.toString(true)))).join(', ')}]\n`;
-        ret += `\tAdded Documents: [${( this.addedDocuments.map(d => ( d.uri.toString(true)))).join(', ')}]\n`;
-        ret += `\tRemoved Editors: [${( this.removedEditors.map(e => e.id)).join(', ')}]\n`;
-        ret += `\tAdded Editors: [${( this.addedEditors.map(e => e.id)).join(', ')}]\n`;
-        ret += `\tNew Active Editor: ${this.newActiveEditor}\n`;
-        return ret;
-    }
-}
-class DocumentAndEditorState {
-    static compute(before, after) {
-        if (!before) {
-            return ( new DocumentAndEditorStateDelta([], [...( after.documents.values())], [], [...( after.textEditors.values())], undefined, after.activeEditor));
-        }
-        const documentDelta = diffSets(before.documents, after.documents);
-        const editorDelta = diffMaps(before.textEditors, after.textEditors);
-        const oldActiveEditor = before.activeEditor !== after.activeEditor ? before.activeEditor : undefined;
-        const newActiveEditor = before.activeEditor !== after.activeEditor ? after.activeEditor : undefined;
-        return ( new DocumentAndEditorStateDelta(
-            documentDelta.removed,
-            documentDelta.added,
-            editorDelta.removed,
-            editorDelta.added,
-            oldActiveEditor,
-            newActiveEditor
-        ));
-    }
-    constructor(documents, textEditors, activeEditor) {
-        this.documents = documents;
-        this.textEditors = textEditors;
-        this.activeEditor = activeEditor;
-    }
-}
-let MainThreadDocumentAndEditorStateComputer = class MainThreadDocumentAndEditorStateComputer {
-    constructor(_onDidChangeState, _modelService, _codeEditorService, _editorService, _paneCompositeService) {
-        this._onDidChangeState = _onDidChangeState;
-        this._modelService = _modelService;
-        this._codeEditorService = _codeEditorService;
-        this._editorService = _editorService;
-        this._paneCompositeService = _paneCompositeService;
-        this._toDispose = ( new DisposableStore());
-        this._toDisposeOnEditorRemove = ( new DisposableMap());
-        this._activeEditorOrder = 0 ;
-        this._modelService.onModelAdded(this._updateStateOnModelAdd, this, this._toDispose);
-        this._modelService.onModelRemoved(_ => this._updateState(), this, this._toDispose);
-        this._editorService.onDidActiveEditorChange(_ => this._updateState(), this, this._toDispose);
-        this._codeEditorService.onCodeEditorAdd(this._onDidAddEditor, this, this._toDispose);
-        this._codeEditorService.onCodeEditorRemove(this._onDidRemoveEditor, this, this._toDispose);
-        this._codeEditorService.listCodeEditors().forEach(this._onDidAddEditor, this);
-        Event.filter(this._paneCompositeService.onDidPaneCompositeOpen, event => event.viewContainerLocation === 1 )(_ => this._activeEditorOrder = 1 , undefined, this._toDispose);
-        Event.filter(this._paneCompositeService.onDidPaneCompositeClose, event => event.viewContainerLocation === 1 )(_ => this._activeEditorOrder = 0 , undefined, this._toDispose);
-        this._editorService.onDidVisibleEditorsChange(_ => this._activeEditorOrder = 0 , undefined, this._toDispose);
-        this._updateState();
-    }
-    dispose() {
-        this._toDispose.dispose();
-        this._toDisposeOnEditorRemove.dispose();
-    }
-    _onDidAddEditor(e) {
-        this._toDisposeOnEditorRemove.set(e.getId(), combinedDisposable(e.onDidChangeModel(() => this._updateState()), e.onDidFocusEditorText(() => this._updateState()), e.onDidFocusEditorWidget(() => this._updateState(e))));
-        this._updateState();
-    }
-    _onDidRemoveEditor(e) {
-        const id = e.getId();
-        if (( this._toDisposeOnEditorRemove.has(id))) {
-            this._toDisposeOnEditorRemove.deleteAndDispose(id);
-            this._updateState();
-        }
-    }
-    _updateStateOnModelAdd(model) {
-        if (!shouldSynchronizeModel(model)) {
-            return;
-        }
-        if (!this._currentState) {
-            this._updateState();
-            return;
-        }
-        this._currentState = ( new DocumentAndEditorState(
-            this._currentState.documents.add(model),
-            this._currentState.textEditors,
-            this._currentState.activeEditor
-        ));
-        this._onDidChangeState(( new DocumentAndEditorStateDelta([], [model], [], [], undefined, undefined)));
-    }
-    _updateState(widgetFocusCandidate) {
-        const models = ( new Set());
-        for (const model of this._modelService.getModels()) {
-            if (shouldSynchronizeModel(model)) {
-                models.add(model);
-            }
-        }
-        const editors = ( new Map());
-        let activeEditor = null;
-        for (const editor of this._codeEditorService.listCodeEditors()) {
-            if (editor.isSimpleWidget) {
-                continue;
-            }
-            const model = editor.getModel();
-            if (editor.hasModel() && model && shouldSynchronizeModel(model)
-                && !model.isDisposed()
-                && Boolean(this._modelService.getModel(model.uri))
-            ) {
-                const apiEditor = ( new TextEditorSnapshot(editor));
-                editors.set(apiEditor.id, apiEditor);
-                if (editor.hasTextFocus() || (widgetFocusCandidate === editor && editor.hasWidgetFocus())) {
-                    activeEditor = apiEditor.id;
-                }
-            }
-        }
-        if (!activeEditor) {
-            let candidate;
-            if (this._activeEditorOrder === 0 ) {
-                candidate = this._getActiveEditorFromEditorPart() || this._getActiveEditorFromPanel();
-            }
-            else {
-                candidate = this._getActiveEditorFromPanel() || this._getActiveEditorFromEditorPart();
-            }
-            if (candidate) {
-                for (const snapshot of ( editors.values())) {
-                    if (candidate === snapshot.editor) {
-                        activeEditor = snapshot.id;
-                    }
-                }
-            }
-        }
-        const newState = ( new DocumentAndEditorState(models, editors, activeEditor));
-        const delta = DocumentAndEditorState.compute(this._currentState, newState);
-        if (!delta.isEmpty) {
-            this._currentState = newState;
-            this._onDidChangeState(delta);
-        }
-    }
-    _getActiveEditorFromPanel() {
-        const panel = this._paneCompositeService.getActivePaneComposite(1 );
-        if (panel instanceof FakeAbstractTextEditor) {
-            const control = panel.getControl();
-            if (isCodeEditor(control)) {
-                return control;
-            }
-        }
-        return undefined;
-    }
-    _getActiveEditorFromEditorPart() {
-        let activeTextEditorControl = this._editorService.activeTextEditorControl;
-        if (isDiffEditor(activeTextEditorControl)) {
-            activeTextEditorControl = activeTextEditorControl.getModifiedEditor();
-        }
-        return activeTextEditorControl;
-    }
-};
-MainThreadDocumentAndEditorStateComputer = ( __decorate([
-    ( __param(1, IModelService)),
-    ( __param(2, ICodeEditorService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, IPaneCompositePartService))
-], MainThreadDocumentAndEditorStateComputer));
-let MainThreadDocumentsAndEditors = class MainThreadDocumentsAndEditors {
-    constructor(extHostContext, _modelService, _textFileService, _editorService, codeEditorService, fileService, textModelResolverService, _editorGroupService, paneCompositeService, environmentService, workingCopyFileService, uriIdentityService, _clipboardService, pathService, configurationService) {
-        this._modelService = _modelService;
-        this._textFileService = _textFileService;
-        this._editorService = _editorService;
-        this._editorGroupService = _editorGroupService;
-        this._clipboardService = _clipboardService;
-        this._toDispose = ( new DisposableStore());
-        this._textEditors = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentsAndEditors));
-        this._mainThreadDocuments = this._toDispose.add(( new MainThreadDocuments(
-            extHostContext,
-            this._modelService,
-            this._textFileService,
-            fileService,
-            textModelResolverService,
-            environmentService,
-            uriIdentityService,
-            workingCopyFileService,
-            pathService
-        )));
-        extHostContext.set(MainContext.MainThreadDocuments, this._mainThreadDocuments);
-        this._mainThreadEditors = this._toDispose.add(( new MainThreadTextEditors(
-            this,
-            extHostContext,
-            codeEditorService,
-            this._editorService,
-            this._editorGroupService,
-            configurationService
-        )));
-        extHostContext.set(MainContext.MainThreadTextEditors, this._mainThreadEditors);
-        this._toDispose.add(( new MainThreadDocumentAndEditorStateComputer(
-            delta => this._onDelta(delta),
-            _modelService,
-            codeEditorService,
-            this._editorService,
-            paneCompositeService
-        )));
-    }
-    dispose() {
-        this._toDispose.dispose();
-    }
-    _onDelta(delta) {
-        const removedEditors = [];
-        const addedEditors = [];
-        const removedDocuments = ( delta.removedDocuments.map(m => m.uri));
-        for (const apiEditor of delta.addedEditors) {
-            const mainThreadEditor = ( new MainThreadTextEditor(
-                apiEditor.id,
-                apiEditor.editor.getModel(),
-                apiEditor.editor,
-                { onGainedFocus() { }, onLostFocus() { } },
-                this._mainThreadDocuments,
-                this._modelService,
-                this._clipboardService
-            ));
-            this._textEditors.set(apiEditor.id, mainThreadEditor);
-            addedEditors.push(mainThreadEditor);
-        }
-        for (const { id } of delta.removedEditors) {
-            const mainThreadEditor = this._textEditors.get(id);
-            if (mainThreadEditor) {
-                mainThreadEditor.dispose();
-                this._textEditors.delete(id);
-                removedEditors.push(id);
-            }
-        }
-        const extHostDelta = Object.create(null);
-        let empty = true;
-        if (delta.newActiveEditor !== undefined) {
-            empty = false;
-            extHostDelta.newActiveEditor = delta.newActiveEditor;
-        }
-        if (removedDocuments.length > 0) {
-            empty = false;
-            extHostDelta.removedDocuments = removedDocuments;
-        }
-        if (removedEditors.length > 0) {
-            empty = false;
-            extHostDelta.removedEditors = removedEditors;
-        }
-        if (delta.addedDocuments.length > 0) {
-            empty = false;
-            extHostDelta.addedDocuments = ( delta.addedDocuments.map(m => this._toModelAddData(m)));
-        }
-        if (delta.addedEditors.length > 0) {
-            empty = false;
-            extHostDelta.addedEditors = ( addedEditors.map(e => this._toTextEditorAddData(e)));
-        }
-        if (!empty) {
-            this._proxy.$acceptDocumentsAndEditorsDelta(extHostDelta);
-            removedDocuments.forEach(this._mainThreadDocuments.handleModelRemoved, this._mainThreadDocuments);
-            delta.addedDocuments.forEach(this._mainThreadDocuments.handleModelAdded, this._mainThreadDocuments);
-            removedEditors.forEach(this._mainThreadEditors.handleTextEditorRemoved, this._mainThreadEditors);
-            addedEditors.forEach(this._mainThreadEditors.handleTextEditorAdded, this._mainThreadEditors);
-        }
-    }
-    _toModelAddData(model) {
-        return {
-            uri: model.uri,
-            versionId: model.getVersionId(),
-            lines: model.getLinesContent(),
-            EOL: model.getEOL(),
-            languageId: model.getLanguageId(),
-            isDirty: this._textFileService.isDirty(model.uri)
-        };
-    }
-    _toTextEditorAddData(textEditor) {
-        const props = textEditor.getProperties();
-        return {
-            id: textEditor.getId(),
-            documentUri: textEditor.getModel().uri,
-            options: props.options,
-            selections: props.selections,
-            visibleRanges: props.visibleRanges,
-            editorPosition: this._findEditorPosition(textEditor)
-        };
-    }
-    _findEditorPosition(editor) {
-        for (const editorPane of this._editorService.visibleEditorPanes) {
-            if (editor.matches(editorPane)) {
-                return editorGroupToColumn(this._editorGroupService, editorPane.group);
-            }
-        }
-        return undefined;
-    }
-    findTextEditorIdFor(editorPane) {
-        for (const [id, editor] of this._textEditors) {
-            if (editor.matches(editorPane)) {
-                return id;
-            }
-        }
-        return undefined;
-    }
-    getIdOfCodeEditor(codeEditor) {
-        for (const [id, editor] of this._textEditors) {
-            if (editor.getCodeEditor() === codeEditor) {
-                return id;
-            }
-        }
-        return undefined;
-    }
-    getEditor(id) {
-        return this._textEditors.get(id);
-    }
-};
-MainThreadDocumentsAndEditors = __decorate([
-    extHostCustomer,
-    ( __param(1, IModelService)),
-    ( __param(2, ITextFileService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, ICodeEditorService)),
-    ( __param(5, IFileService)),
-    ( __param(6, ITextModelService)),
-    ( __param(7, IEditorGroupsService)),
-    ( __param(8, IPaneCompositePartService)),
-    ( __param(9, IWorkbenchEnvironmentService)),
-    ( __param(10, IWorkingCopyFileService)),
-    ( __param(11, IUriIdentityService)),
-    ( __param(12, IClipboardService)),
-    ( __param(13, IPathService)),
-    ( __param(14, IConfigurationService))
-], MainThreadDocumentsAndEditors);
-export { MainThreadDocumentsAndEditors };

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

@@ -1,20 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { MainContext } from '../common/extHost.protocol.js';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { IDownloadService } from '../../../platform/download/common/download.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-let MainThreadDownloadService = class MainThreadDownloadService extends Disposable {
-    constructor(extHostContext, downloadService) {
-        super();
-        this.downloadService = downloadService;
-    }
-    $download(uri, to) {
-        return this.downloadService.download(URI.revive(uri), URI.revive(to));
-    }
-};
-MainThreadDownloadService = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadDownloadService),
-    ( __param(1, IDownloadService))
-], MainThreadDownloadService);
-export { MainThreadDownloadService };

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

@@ -1,39 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'monaco-editor/esm/vs/nls.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { extHostCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { raceCancellationError } from 'monaco-editor/esm/vs/base/common/async.js';
-import { IEditSessionIdentityService } from '../../../platform/workspace/common/editSessions.js';
-import { ExtHostContext } from '../common/extHost.protocol.js';
-class ExtHostEditSessionIdentityCreateParticipant {
-    constructor(extHostContext) {
-        this.timeout = 10000;
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
-    }
-    async participate(workspaceFolder, token) {
-        const p = ( new Promise((resolve, reject) => {
-            setTimeout(() => reject(( new Error(( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadEditSessionIdentityParticipant',
-                'timeout.onWillCreateEditSessionIdentity',
-                "Aborted onWillCreateEditSessionIdentity-event after 10000ms"
-            ))))), this.timeout);
-            this._proxy.$onWillCreateEditSessionIdentity(workspaceFolder.uri, token, this.timeout).then(resolve, reject);
-        }));
-        return raceCancellationError(p, token);
-    }
-}
-let EditSessionIdentityCreateParticipant = class EditSessionIdentityCreateParticipant {
-    constructor(extHostContext, instantiationService, _editSessionIdentityService) {
-        this._editSessionIdentityService = _editSessionIdentityService;
-        this._saveParticipantDisposable = this._editSessionIdentityService.addEditSessionIdentityCreateParticipant(instantiationService.createInstance(ExtHostEditSessionIdentityCreateParticipant, extHostContext));
-    }
-    dispose() {
-        this._saveParticipantDisposable.dispose();
-    }
-};
-EditSessionIdentityCreateParticipant = __decorate([
-    extHostCustomer,
-    ( __param(1, IInstantiationService)),
-    ( __param(2, IEditSessionIdentityService))
-], EditSessionIdentityCreateParticipant);
-export { EditSessionIdentityCreateParticipant };