@codingame/monaco-vscode-api 1.78.4 → 1.78.5-next.0

package/dist/vscode/vs/workbench/api/common/extHostDocumentSaveParticipant.js

@@ -0,0 +1,126 @@
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { illegalState } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { TextEdit } from './extHostTypes.js';
+import { TextDocumentSaveReason, Range, EndOfLine } from './extHostTypeConverters.js';
+import { LinkedList } from 'monaco-editor/esm/vs/base/common/linkedList.js';
+class ExtHostDocumentSaveParticipant {
+    constructor(_logService, _documents, _mainThreadBulkEdits, _thresholds = { timeout: 1500, errors: 3 }) {
+        this._logService = _logService;
+        this._documents = _documents;
+        this._mainThreadBulkEdits = _mainThreadBulkEdits;
+        this._thresholds = _thresholds;
+        this._callbacks = ( new LinkedList());
+        this._badListeners = ( new WeakMap());
+    }
+    dispose() {
+        this._callbacks.clear();
+    }
+    getOnWillSaveTextDocumentEvent(extension) {
+        return (listener, thisArg, disposables) => {
+            const remove = this._callbacks.push([listener, thisArg, extension]);
+            const result = { dispose: remove };
+            if (Array.isArray(disposables)) {
+                disposables.push(result);
+            }
+            return result;
+        };
+    }
+    async $participateInSave(data, reason) {
+        const resource = URI.revive(data);
+        let didTimeout = false;
+        const didTimeoutHandle = setTimeout(() => didTimeout = true, this._thresholds.timeout);
+        const results = [];
+        try {
+            for (const listener of [...this._callbacks]) {
+                if (didTimeout) {
+                    break;
+                }
+                const document = this._documents.getDocument(resource);
+                const success = await this._deliverEventAsyncAndBlameBadListeners(listener, { document, reason: TextDocumentSaveReason.to(reason) });
+                results.push(success);
+            }
+        }
+        finally {
+            clearTimeout(didTimeoutHandle);
+        }
+        return results;
+    }
+    _deliverEventAsyncAndBlameBadListeners([listener, thisArg, extension], stubEvent) {
+        const errors = this._badListeners.get(listener);
+        if (typeof errors === 'number' && errors > this._thresholds.errors) {
+            return Promise.resolve(false);
+        }
+        return this._deliverEventAsync(extension, listener, thisArg, stubEvent).then(() => {
+            return true;
+        }, err => {
+            this._logService.error(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' threw ERROR`);
+            this._logService.error(err);
+            if (!(err instanceof Error) || err.message !== 'concurrent_edits') {
+                const errors = this._badListeners.get(listener);
+                this._badListeners.set(listener, !errors ? 1 : errors + 1);
+                if (typeof errors === 'number' && errors > this._thresholds.errors) {
+                    this._logService.info(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' will now be IGNORED because of timeouts and/or errors`);
+                }
+            }
+            return false;
+        });
+    }
+    _deliverEventAsync(extension, listener, thisArg, stubEvent) {
+        const promises = [];
+        const t1 = Date.now();
+        const { document, reason } = stubEvent;
+        const { version } = document;
+        const event = ( Object.freeze({
+            document,
+            reason,
+            waitUntil(p) {
+                if (Object.isFrozen(promises)) {
+                    throw illegalState('waitUntil can not be called async');
+                }
+                promises.push(Promise.resolve(p));
+            }
+        }));
+        try {
+            listener.apply(thisArg, [event]);
+        }
+        catch (err) {
+            return Promise.reject(err);
+        }
+        return ( new Promise((resolve, reject) => {
+            const handle = setTimeout(() => reject(( new Error('timeout'))), this._thresholds.timeout);
+            return Promise.all(promises).then(edits => {
+                this._logService.debug(`onWillSaveTextDocument-listener from extension '${extension.identifier.value}' finished after ${(Date.now() - t1)}ms`);
+                clearTimeout(handle);
+                resolve(edits);
+            }).catch(err => {
+                clearTimeout(handle);
+                reject(err);
+            });
+        })).then(values => {
+            const dto = { edits: [] };
+            for (const value of values) {
+                if (Array.isArray(value) && value.every(e => e instanceof TextEdit)) {
+                    for (const { newText, newEol, range } of value) {
+                        dto.edits.push({
+                            resource: document.uri,
+                            versionId: undefined,
+                            textEdit: {
+                                range: range && Range.from(range),
+                                text: newText,
+                                eol: newEol && EndOfLine.from(newEol),
+                            }
+                        });
+                    }
+                }
+            }
+            if (dto.edits.length === 0) {
+                return undefined;
+            }
+            if (version === document.version) {
+                return this._mainThreadBulkEdits.$tryApplyWorkspaceEdit(dto);
+            }
+            return Promise.reject(( new Error('concurrent_edits')));
+        });
+    }
+}
+export { ExtHostDocumentSaveParticipant };

package/dist/vscode/vs/workbench/api/common/extHostDocuments.js

@@ -0,0 +1,144 @@
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { MainContext } from './extHost.protocol.js';
+import { setWordDefinitionFor } from './extHostDocumentData.js';
+import { Range } from './extHostTypeConverters.js';
+import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
+import { deepFreeze } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { TextDocumentChangeReason } from './extHostTypes.js';
+class ExtHostDocuments {
+    constructor(mainContext, documentsAndEditors) {
+        this._onDidAddDocument = ( new Emitter());
+        this._onDidRemoveDocument = ( new Emitter());
+        this._onDidChangeDocument = ( new Emitter());
+        this._onDidSaveDocument = ( new Emitter());
+        this.onDidAddDocument = this._onDidAddDocument.event;
+        this.onDidRemoveDocument = this._onDidRemoveDocument.event;
+        this.onDidChangeDocument = this._onDidChangeDocument.event;
+        this.onDidSaveDocument = this._onDidSaveDocument.event;
+        this._toDispose = ( new DisposableStore());
+        this._documentLoader = ( new Map());
+        this._proxy = ( mainContext.getProxy(MainContext.MainThreadDocuments));
+        this._documentsAndEditors = documentsAndEditors;
+        this._documentsAndEditors.onDidRemoveDocuments(documents => {
+            for (const data of documents) {
+                this._onDidRemoveDocument.fire(data.document);
+            }
+        }, undefined, this._toDispose);
+        this._documentsAndEditors.onDidAddDocuments(documents => {
+            for (const data of documents) {
+                this._onDidAddDocument.fire(data.document);
+            }
+        }, undefined, this._toDispose);
+    }
+    dispose() {
+        this._toDispose.dispose();
+    }
+    getAllDocumentData() {
+        return [...this._documentsAndEditors.allDocuments()];
+    }
+    getDocumentData(resource) {
+        if (!resource) {
+            return undefined;
+        }
+        const data = this._documentsAndEditors.getDocument(resource);
+        if (data) {
+            return data;
+        }
+        return undefined;
+    }
+    getDocument(resource) {
+        const data = this.getDocumentData(resource);
+        if (!data?.document) {
+            throw new Error(`Unable to retrieve document from URI '${resource}'`);
+        }
+        return data.document;
+    }
+    ensureDocumentData(uri) {
+        const cached = this._documentsAndEditors.getDocument(uri);
+        if (cached) {
+            return Promise.resolve(cached);
+        }
+        let promise = this._documentLoader.get(( uri.toString()));
+        if (!promise) {
+            promise = this._proxy.$tryOpenDocument(uri).then(uriData => {
+                this._documentLoader.delete(( uri.toString()));
+                const canonicalUri = URI.revive(uriData);
+                return assertIsDefined(this._documentsAndEditors.getDocument(canonicalUri));
+            }, err => {
+                this._documentLoader.delete(( uri.toString()));
+                return Promise.reject(err);
+            });
+            this._documentLoader.set(( uri.toString()), promise);
+        }
+        return promise;
+    }
+    createDocumentData(options) {
+        return this._proxy.$tryCreateDocument(options).then(data => URI.revive(data));
+    }
+    $acceptModelLanguageChanged(uriComponents, newLanguageId) {
+        const uri = URI.revive(uriComponents);
+        const data = this._documentsAndEditors.getDocument(uri);
+        if (!data) {
+            throw new Error('unknown document');
+        }
+        this._onDidRemoveDocument.fire(data.document);
+        data._acceptLanguageId(newLanguageId);
+        this._onDidAddDocument.fire(data.document);
+    }
+    $acceptModelSaved(uriComponents) {
+        const uri = URI.revive(uriComponents);
+        const data = this._documentsAndEditors.getDocument(uri);
+        if (!data) {
+            throw new Error('unknown document');
+        }
+        this.$acceptDirtyStateChanged(uriComponents, false);
+        this._onDidSaveDocument.fire(data.document);
+    }
+    $acceptDirtyStateChanged(uriComponents, isDirty) {
+        const uri = URI.revive(uriComponents);
+        const data = this._documentsAndEditors.getDocument(uri);
+        if (!data) {
+            throw new Error('unknown document');
+        }
+        data._acceptIsDirty(isDirty);
+        this._onDidChangeDocument.fire({
+            document: data.document,
+            contentChanges: [],
+            reason: undefined
+        });
+    }
+    $acceptModelChanged(uriComponents, events, isDirty) {
+        const uri = URI.revive(uriComponents);
+        const data = this._documentsAndEditors.getDocument(uri);
+        if (!data) {
+            throw new Error('unknown document');
+        }
+        data._acceptIsDirty(isDirty);
+        data.onEvents(events);
+        let reason = undefined;
+        if (events.isUndoing) {
+            reason = TextDocumentChangeReason.Undo;
+        }
+        else if (events.isRedoing) {
+            reason = TextDocumentChangeReason.Redo;
+        }
+        this._onDidChangeDocument.fire(deepFreeze({
+            document: data.document,
+            contentChanges: ( events.changes.map((change) => {
+                return {
+                    range: Range.to(change.range),
+                    rangeOffset: change.rangeOffset,
+                    rangeLength: change.rangeLength,
+                    text: change.text
+                };
+            })),
+            reason
+        }));
+    }
+    setWordDefinitionFor(languageId, wordDefinition) {
+        setWordDefinitionFor(languageId, wordDefinition);
+    }
+}
+export { ExtHostDocuments };

package/dist/vscode/vs/workbench/api/common/extHostDocumentsAndEditors.js

@@ -0,0 +1,147 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import * as assert from 'monaco-editor/esm/vs/base/common/assert.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { MainContext } from './extHost.protocol.js';
+import { ExtHostDocumentData } from './extHostDocumentData.js';
+import { IExtHostRpcService } from './extHostRpcService.js';
+import { ExtHostTextEditor } from './extHostTextEditor.js';
+import { Selection, Range, ViewColumn } from './extHostTypeConverters.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+import { Lazy } from 'monaco-editor/esm/vs/base/common/lazy.js';
+class Reference {
+    constructor(value) {
+        this.value = value;
+        this._count = 0;
+    }
+    ref() {
+        this._count++;
+    }
+    unref() {
+        return --this._count === 0;
+    }
+}
+let ExtHostDocumentsAndEditors = class ExtHostDocumentsAndEditors {
+    constructor(_extHostRpc, _logService) {
+        this._extHostRpc = _extHostRpc;
+        this._logService = _logService;
+        this._activeEditorId = null;
+        this._editors = ( new Map());
+        this._documents = ( new ResourceMap());
+        this._onDidAddDocuments = ( new Emitter());
+        this._onDidRemoveDocuments = ( new Emitter());
+        this._onDidChangeVisibleTextEditors = ( new Emitter());
+        this._onDidChangeActiveTextEditor = ( new Emitter());
+        this.onDidAddDocuments = this._onDidAddDocuments.event;
+        this.onDidRemoveDocuments = this._onDidRemoveDocuments.event;
+        this.onDidChangeVisibleTextEditors = this._onDidChangeVisibleTextEditors.event;
+        this.onDidChangeActiveTextEditor = this._onDidChangeActiveTextEditor.event;
+    }
+    $acceptDocumentsAndEditorsDelta(delta) {
+        this.acceptDocumentsAndEditorsDelta(delta);
+    }
+    acceptDocumentsAndEditorsDelta(delta) {
+        const removedDocuments = [];
+        const addedDocuments = [];
+        const removedEditors = [];
+        if (delta.removedDocuments) {
+            for (const uriComponent of delta.removedDocuments) {
+                const uri = URI.revive(uriComponent);
+                const data = this._documents.get(uri);
+                if (data?.unref()) {
+                    this._documents.delete(uri);
+                    removedDocuments.push(data.value);
+                }
+            }
+        }
+        if (delta.addedDocuments) {
+            for (const data of delta.addedDocuments) {
+                const resource = URI.revive(data.uri);
+                let ref = this._documents.get(resource);
+                if (ref) {
+                    if (resource.scheme !== Schemas.vscodeNotebookCell && resource.scheme !== Schemas.vscodeInteractiveInput) {
+                        throw new Error(`document '${resource} already exists!'`);
+                    }
+                }
+                if (!ref) {
+                    ref = ( new Reference(( new ExtHostDocumentData(( this._extHostRpc.getProxy(MainContext.MainThreadDocuments)), resource, data.lines, data.EOL, data.versionId, data.languageId, data.isDirty, data.notebook))));
+                    this._documents.set(resource, ref);
+                    addedDocuments.push(ref.value);
+                }
+                ref.ref();
+            }
+        }
+        if (delta.removedEditors) {
+            for (const id of delta.removedEditors) {
+                const editor = this._editors.get(id);
+                this._editors.delete(id);
+                if (editor) {
+                    removedEditors.push(editor);
+                }
+            }
+        }
+        if (delta.addedEditors) {
+            for (const data of delta.addedEditors) {
+                const resource = URI.revive(data.documentUri);
+                assert.ok(this._documents.has(resource), `document '${resource}' does not exist`);
+                assert.ok(!this._editors.has(data.id), `editor '${data.id}' already exists!`);
+                const documentData = this._documents.get(resource).value;
+                const editor = ( new ExtHostTextEditor(data.id, ( this._extHostRpc.getProxy(MainContext.MainThreadTextEditors)), this._logService, ( new Lazy(() => documentData.document)), ( data.selections.map(Selection.to)), data.options, ( data.visibleRanges.map(range => Range.to(range))), typeof data.editorPosition === 'number' ? ViewColumn.to(data.editorPosition) : undefined));
+                this._editors.set(data.id, editor);
+            }
+        }
+        if (delta.newActiveEditor !== undefined) {
+            assert.ok(delta.newActiveEditor === null || this._editors.has(delta.newActiveEditor), `active editor '${delta.newActiveEditor}' does not exist`);
+            this._activeEditorId = delta.newActiveEditor;
+        }
+        dispose(removedDocuments);
+        dispose(removedEditors);
+        if (delta.removedDocuments) {
+            this._onDidRemoveDocuments.fire(removedDocuments);
+        }
+        if (delta.addedDocuments) {
+            this._onDidAddDocuments.fire(addedDocuments);
+        }
+        if (delta.removedEditors || delta.addedEditors) {
+            this._onDidChangeVisibleTextEditors.fire(( this.allEditors().map(editor => editor.value)));
+        }
+        if (delta.newActiveEditor !== undefined) {
+            this._onDidChangeActiveTextEditor.fire(this.activeEditor());
+        }
+    }
+    getDocument(uri) {
+        return this._documents.get(uri)?.value;
+    }
+    allDocuments() {
+        return ( Iterable.map(( this._documents.values()), ref => ref.value));
+    }
+    getEditor(id) {
+        return this._editors.get(id);
+    }
+    activeEditor(internal) {
+        if (!this._activeEditorId) {
+            return undefined;
+        }
+        const editor = this._editors.get(this._activeEditorId);
+        if (internal) {
+            return editor;
+        }
+        else {
+            return editor?.value;
+        }
+    }
+    allEditors() {
+        return [...( this._editors.values())];
+    }
+};
+ExtHostDocumentsAndEditors = ( __decorate([
+    ( __param(0, IExtHostRpcService)),
+    ( __param(1, ILogService))
+], ExtHostDocumentsAndEditors));
+const IExtHostDocumentsAndEditors = ( createDecorator('IExtHostDocumentsAndEditors'));
+export { ExtHostDocumentsAndEditors, IExtHostDocumentsAndEditors };