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

package/dist/vscode/vs/workbench/api/browser/mainThreadDocumentContentProviders.js

@@ -0,0 +1,73 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { onUnexpectedError } from 'monaco-editor/esm/vs/base/common/errors.js';
+import { DisposableMap, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { IEditorWorkerService } from 'monaco-editor/esm/vs/editor/common/services/editorWorker.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
+import { ExtHostContext, MainContext } from '../common/extHost.protocol.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+let MainThreadDocumentContentProviders = class MainThreadDocumentContentProviders {
+    constructor(extHostContext, _textModelResolverService, _languageService, _modelService, _editorWorkerService) {
+        this._textModelResolverService = _textModelResolverService;
+        this._languageService = _languageService;
+        this._modelService = _modelService;
+        this._editorWorkerService = _editorWorkerService;
+        this._resourceContentProvider = ( new DisposableMap());
+        this._pendingUpdate = ( new Map());
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocumentContentProviders));
+    }
+    dispose() {
+        this._resourceContentProvider.dispose();
+        dispose(( this._pendingUpdate.values()));
+    }
+    $registerTextContentProvider(handle, scheme) {
+        const registration = this._textModelResolverService.registerTextModelContentProvider(scheme, {
+            provideTextContent: (uri) => {
+                return this._proxy.$provideTextDocumentContent(handle, uri).then(value => {
+                    if (typeof value === 'string') {
+                        const firstLineText = value.substr(0, 1 + value.search(/\r?\n/));
+                        const languageSelection = this._languageService.createByFilepathOrFirstLine(uri, firstLineText);
+                        return this._modelService.createModel(value, languageSelection, uri);
+                    }
+                    return null;
+                });
+            }
+        });
+        this._resourceContentProvider.set(handle, registration);
+    }
+    $unregisterTextContentProvider(handle) {
+        this._resourceContentProvider.deleteAndDispose(handle);
+    }
+    $onVirtualDocumentChange(uri, value) {
+        const model = this._modelService.getModel(URI.revive(uri));
+        if (!model) {
+            return;
+        }
+        const pending = this._pendingUpdate.get(model.id);
+        pending?.cancel();
+        const myToken = ( new CancellationTokenSource());
+        this._pendingUpdate.set(model.id, myToken);
+        this._editorWorkerService.computeMoreMinimalEdits(model.uri, [{ text: value, range: model.getFullModelRange() }]).then(edits => {
+            this._pendingUpdate.delete(model.id);
+            if (myToken.token.isCancellationRequested) {
+                return;
+            }
+            if (edits && edits.length > 0) {
+                model.applyEdits(( edits.map(edit => EditOperation.replace(Range.lift(edit.range), edit.text))));
+            }
+        }).catch(onUnexpectedError);
+    }
+};
+MainThreadDocumentContentProviders = __decorate([
+    extHostNamedCustomer(MainContext.MainThreadDocumentContentProviders),
+    ( __param(1, ITextModelService)),
+    ( __param(2, ILanguageService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IEditorWorkerService))
+], MainThreadDocumentContentProviders);
+export { MainThreadDocumentContentProviders };

package/dist/vscode/vs/workbench/api/browser/mainThreadDocuments.js

@@ -0,0 +1,246 @@
+import { __decorate, __param } from '../../../../../node_modules/tslib/tslib.es6.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import { Disposable, dispose } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.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 { ExtHostContext } from '../common/extHost.protocol.js';
+import { ITextFileService } from '../../services/textfile/common/textfiles.js';
+import { IWorkbenchEnvironmentService } from '../../services/environment/common/environmentService.js';
+import { extUri, toLocalResource } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IWorkingCopyFileService } from '../../services/workingCopy/common/workingCopyFileService.js';
+import { IUriIdentityService } from '../../../platform/uriIdentity/common/uriIdentity.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { IPathService } from '../../services/path/common/pathService.js';
+import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+class BoundModelReferenceCollection {
+    constructor(_extUri, _maxAge = 1000 * 60 * 3,
+    _maxLength = 1024 * 1024 * 80,
+    _maxSize = 50
+    ) {
+        this._extUri = _extUri;
+        this._maxAge = _maxAge;
+        this._maxLength = _maxLength;
+        this._maxSize = _maxSize;
+        this._data = ( new Array());
+        this._length = 0;
+    }
+    dispose() {
+        this._data = dispose(this._data);
+    }
+    remove(uri) {
+        for (const entry of [...this._data] ) {
+            if (this._extUri.isEqualOrParent(entry.uri, uri)) {
+                entry.dispose();
+            }
+        }
+    }
+    add(uri, ref, length = 0) {
+        const dispose = () => {
+            const idx = this._data.indexOf(entry);
+            if (idx >= 0) {
+                this._length -= length;
+                ref.dispose();
+                clearTimeout(handle);
+                this._data.splice(idx, 1);
+            }
+        };
+        const handle = setTimeout(dispose, this._maxAge);
+        const entry = { uri, length, dispose };
+        this._data.push(entry);
+        this._length += length;
+        this._cleanup();
+    }
+    _cleanup() {
+        while (this._length > this._maxLength) {
+            this._data[0].dispose();
+        }
+        const extraSize = Math.ceil(this._maxSize * 1.2);
+        if (this._data.length >= extraSize) {
+            dispose(this._data.slice(0, extraSize - this._maxSize));
+        }
+    }
+}
+class ModelTracker extends Disposable {
+    constructor(_model, _onIsCaughtUpWithContentChanges, _proxy, _textFileService) {
+        super();
+        this._model = _model;
+        this._onIsCaughtUpWithContentChanges = _onIsCaughtUpWithContentChanges;
+        this._proxy = _proxy;
+        this._textFileService = _textFileService;
+        this._knownVersionId = this._model.getVersionId();
+        this._store.add(this._model.onDidChangeContent((e) => {
+            this._knownVersionId = e.versionId;
+            this._proxy.$acceptModelChanged(this._model.uri, e, this._textFileService.isDirty(this._model.uri));
+            if (this.isCaughtUpWithContentChanges()) {
+                this._onIsCaughtUpWithContentChanges.fire(this._model.uri);
+            }
+        }));
+    }
+    isCaughtUpWithContentChanges() {
+        return (this._model.getVersionId() === this._knownVersionId);
+    }
+}
+let MainThreadDocuments = class MainThreadDocuments extends Disposable {
+    constructor(extHostContext, _modelService, _textFileService, _fileService, _textModelResolverService, _environmentService, _uriIdentityService, workingCopyFileService, _pathService) {
+        super();
+        this._modelService = _modelService;
+        this._textFileService = _textFileService;
+        this._fileService = _fileService;
+        this._textModelResolverService = _textModelResolverService;
+        this._environmentService = _environmentService;
+        this._uriIdentityService = _uriIdentityService;
+        this._pathService = _pathService;
+        this._onIsCaughtUpWithContentChanges = this._store.add(( new Emitter()));
+        this.onIsCaughtUpWithContentChanges = this._onIsCaughtUpWithContentChanges.event;
+        this._modelTrackers = ( new ResourceMap());
+        this._modelReferenceCollection = this._store.add(( new BoundModelReferenceCollection(_uriIdentityService.extUri)));
+        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostDocuments));
+        this._store.add(_modelService.onModelLanguageChanged(this._onModelModeChanged, this));
+        this._store.add(_textFileService.files.onDidSave(e => {
+            if (this._shouldHandleFileEvent(e.model.resource)) {
+                this._proxy.$acceptModelSaved(e.model.resource);
+            }
+        }));
+        this._store.add(_textFileService.files.onDidChangeDirty(m => {
+            if (this._shouldHandleFileEvent(m.resource)) {
+                this._proxy.$acceptDirtyStateChanged(m.resource, m.isDirty());
+            }
+        }));
+        this._store.add(workingCopyFileService.onDidRunWorkingCopyFileOperation(e => {
+            const isMove = e.operation === 2 ;
+            if (isMove || e.operation === 1 ) {
+                for (const pair of e.files) {
+                    const removed = isMove ? pair.source : pair.target;
+                    if (removed) {
+                        this._modelReferenceCollection.remove(removed);
+                    }
+                }
+            }
+        }));
+    }
+    dispose() {
+        dispose(( this._modelTrackers.values()));
+        this._modelTrackers.clear();
+        super.dispose();
+    }
+    isCaughtUpWithContentChanges(resource) {
+        const tracker = this._modelTrackers.get(resource);
+        if (tracker) {
+            return tracker.isCaughtUpWithContentChanges();
+        }
+        return true;
+    }
+    _shouldHandleFileEvent(resource) {
+        const model = this._modelService.getModel(resource);
+        return !!model && shouldSynchronizeModel(model);
+    }
+    handleModelAdded(model) {
+        if (!shouldSynchronizeModel(model)) {
+            return;
+        }
+        this._modelTrackers.set(model.uri, ( new ModelTracker(
+            model,
+            this._onIsCaughtUpWithContentChanges,
+            this._proxy,
+            this._textFileService
+        )));
+    }
+    _onModelModeChanged(event) {
+        const { model } = event;
+        if (!this._modelTrackers.has(model.uri)) {
+            return;
+        }
+        this._proxy.$acceptModelLanguageChanged(model.uri, model.getLanguageId());
+    }
+    handleModelRemoved(modelUrl) {
+        if (!this._modelTrackers.has(modelUrl)) {
+            return;
+        }
+        this._modelTrackers.get(modelUrl).dispose();
+        this._modelTrackers.delete(modelUrl);
+    }
+    async $trySaveDocument(uri) {
+        const target = await this._textFileService.save(URI.revive(uri));
+        return Boolean(target);
+    }
+    async $tryOpenDocument(uriData) {
+        const inputUri = URI.revive(uriData);
+        if (!inputUri.scheme || !(inputUri.fsPath || inputUri.authority)) {
+            throw new Error(`Invalid uri. Scheme and authority or path must be set.`);
+        }
+        const canonicalUri = this._uriIdentityService.asCanonicalUri(inputUri);
+        let promise;
+        switch (canonicalUri.scheme) {
+            case Schemas.untitled:
+                promise = this._handleUntitledScheme(canonicalUri);
+                break;
+            case Schemas.file:
+            default:
+                promise = this._handleAsResourceInput(canonicalUri);
+                break;
+        }
+        let documentUri;
+        try {
+            documentUri = await promise;
+        }
+        catch (err) {
+            throw new Error(`cannot open ${canonicalUri.toString()}. Detail: ${toErrorMessage(err)}`);
+        }
+        if (!documentUri) {
+            throw new Error(`cannot open ${canonicalUri.toString()}`);
+        }
+        else if (!extUri.isEqual(documentUri, canonicalUri)) {
+            throw new Error(`cannot open ${canonicalUri.toString()}. Detail: Actual document opened as ${documentUri.toString()}`);
+        }
+        else if (!this._modelTrackers.has(canonicalUri)) {
+            throw new Error(`cannot open ${canonicalUri.toString()}. Detail: Files above 50MB cannot be synchronized with extensions.`);
+        }
+        else {
+            return canonicalUri;
+        }
+    }
+    $tryCreateDocument(options) {
+        return this._doCreateUntitled(undefined, options ? options.language : undefined, options ? options.content : undefined);
+    }
+    async _handleAsResourceInput(uri) {
+        const ref = await this._textModelResolverService.createModelReference(uri);
+        this._modelReferenceCollection.add(uri, ref, ref.object.textEditorModel.getValueLength());
+        return ref.object.textEditorModel.uri;
+    }
+    async _handleUntitledScheme(uri) {
+        const asLocalUri = toLocalResource(uri, this._environmentService.remoteAuthority, this._pathService.defaultUriScheme);
+        const exists = await this._fileService.exists(asLocalUri);
+        if (exists) {
+            return Promise.reject(( new Error('file already exists')));
+        }
+        return await this._doCreateUntitled(Boolean(uri.path) ? uri : undefined);
+    }
+    async _doCreateUntitled(associatedResource, languageId, initialValue) {
+        const model = await this._textFileService.untitled.resolve({
+            associatedResource,
+            languageId,
+            initialValue
+        });
+        const resource = model.resource;
+        if (!this._modelTrackers.has(resource)) {
+            throw new Error(`expected URI ${resource.toString()} to have come to LIFE`);
+        }
+        this._proxy.$acceptDirtyStateChanged(resource, true);
+        return resource;
+    }
+};
+MainThreadDocuments = ( __decorate([
+    ( __param(1, IModelService)),
+    ( __param(2, ITextFileService)),
+    ( __param(3, IFileService)),
+    ( __param(4, ITextModelService)),
+    ( __param(5, IWorkbenchEnvironmentService)),
+    ( __param(6, IUriIdentityService)),
+    ( __param(7, IWorkingCopyFileService)),
+    ( __param(8, IPathService))
+], MainThreadDocuments));
+export { BoundModelReferenceCollection, MainThreadDocuments };