@codingame/monaco-vscode-api 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/textfile/common/textFileEditorModelManager.js

@@ -0,0 +1,402 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { toErrorMessage } from '../../../../base/common/errorMessage.js';
+import { Emitter, Event } from '../../../../base/common/event.js';
+import { URI } from '../../../../base/common/uri.js';
+import { TextFileEditorModel } from './textFileEditorModel.js';
+import { Disposable, dispose, DisposableStore } from '../../../../base/common/lifecycle.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ResourceMap } from '../../../../base/common/map.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { ResourceQueue, Promises } from '../../../../base/common/async.js';
+import { onUnexpectedError } from '../../../../base/common/errors.js';
+import { TextFileSaveParticipant } from './textFileSaveParticipant.js';
+import { INotificationService } from '../../../../platform/notification/common/notification.js';
+import { IWorkingCopyFileService } from '../../workingCopy/common/workingCopyFileService.js';
+import { joinPath, extname } from '../../../../base/common/resources.js';
+import { createTextBufferFactoryFromSnapshot } from '../../../../editor/common/model/textModel.js';
+import { PLAINTEXT_LANGUAGE_ID, PLAINTEXT_EXTENSION } from '../../../../editor/common/languages/modesRegistry.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+let TextFileEditorModelManager = class TextFileEditorModelManager extends Disposable {
+    get models() {
+        return [...( this.mapResourceToModel.values())];
+    }
+    constructor(instantiationService, fileService, notificationService, workingCopyFileService, uriIdentityService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.fileService = fileService;
+        this.notificationService = notificationService;
+        this.workingCopyFileService = workingCopyFileService;
+        this.uriIdentityService = uriIdentityService;
+        this._onDidCreate = this._register(( new Emitter()));
+        this.onDidCreate = this._onDidCreate.event;
+        this._onDidResolve = this._register(( new Emitter()));
+        this.onDidResolve = this._onDidResolve.event;
+        this._onDidRemove = this._register(( new Emitter()));
+        this.onDidRemove = this._onDidRemove.event;
+        this._onDidChangeDirty = this._register(( new Emitter()));
+        this.onDidChangeDirty = this._onDidChangeDirty.event;
+        this._onDidChangeReadonly = this._register(( new Emitter()));
+        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
+        this._onDidChangeOrphaned = this._register(( new Emitter()));
+        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
+        this._onDidSaveError = this._register(( new Emitter()));
+        this.onDidSaveError = this._onDidSaveError.event;
+        this._onDidSave = this._register(( new Emitter()));
+        this.onDidSave = this._onDidSave.event;
+        this._onDidRevert = this._register(( new Emitter()));
+        this.onDidRevert = this._onDidRevert.event;
+        this._onDidChangeEncoding = this._register(( new Emitter()));
+        this.onDidChangeEncoding = this._onDidChangeEncoding.event;
+        this.mapResourceToModel = ( new ResourceMap());
+        this.mapResourceToModelListeners = ( new ResourceMap());
+        this.mapResourceToDisposeListener = ( new ResourceMap());
+        this.mapResourceToPendingModelResolvers = ( new ResourceMap());
+        this.modelResolveQueue = this._register(( new ResourceQueue()));
+        this.saveErrorHandler = (() => {
+            const notificationService = this.notificationService;
+            return {
+                onSaveError(error, model) {
+                    notificationService.error(( localizeWithPath(
+                        'vs/workbench/services/textfile/common/textFileEditorModelManager',
+                        { key: 'genericSaveError', comment: ['{0} is the resource that failed to save and {1} the error message'] },
+                        "Failed to save '{0}': {1}",
+                        model.name,
+                        toErrorMessage(error, false)
+                    )));
+                }
+            };
+        })();
+        this.mapCorrelationIdToModelsToRestore = ( new Map());
+        this.saveParticipants = this._register(this.instantiationService.createInstance(TextFileSaveParticipant));
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.fileService.onDidFilesChange(e => this.onDidFilesChange(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderCapabilities(e => this.onDidChangeFileSystemProviderCapabilities(e)));
+        this._register(this.fileService.onDidChangeFileSystemProviderRegistrations(e => this.onDidChangeFileSystemProviderRegistrations(e)));
+        this._register(this.workingCopyFileService.onWillRunWorkingCopyFileOperation(e => this.onWillRunWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidFailWorkingCopyFileOperation(e => this.onDidFailWorkingCopyFileOperation(e)));
+        this._register(this.workingCopyFileService.onDidRunWorkingCopyFileOperation(e => this.onDidRunWorkingCopyFileOperation(e)));
+    }
+    onDidFilesChange(e) {
+        for (const model of this.models) {
+            if (model.isDirty()) {
+                continue;
+            }
+            if (e.contains(model.resource, 0 , 1 )) {
+                this.queueModelReload(model);
+            }
+        }
+    }
+    onDidChangeFileSystemProviderCapabilities(e) {
+        this.queueModelReloads(e.scheme);
+    }
+    onDidChangeFileSystemProviderRegistrations(e) {
+        if (!e.added) {
+            return;
+        }
+        this.queueModelReloads(e.scheme);
+    }
+    queueModelReloads(scheme) {
+        for (const model of this.models) {
+            if (model.isDirty()) {
+                continue;
+            }
+            if (scheme === model.resource.scheme) {
+                this.queueModelReload(model);
+            }
+        }
+    }
+    queueModelReload(model) {
+        const queueSize = this.modelResolveQueue.queueSize(model.resource);
+        if (queueSize <= 1) {
+            this.modelResolveQueue.queueFor(model.resource, async () => {
+                try {
+                    await this.reload(model);
+                }
+                catch (error) {
+                    onUnexpectedError(error);
+                }
+            });
+        }
+    }
+    onWillRunWorkingCopyFileOperation(e) {
+        if (e.operation === 2  || e.operation === 3 ) {
+            const modelsToRestore = [];
+            for (const { source, target } of e.files) {
+                if (source) {
+                    if (this.uriIdentityService.extUri.isEqual(source, target)) {
+                        continue;
+                    }
+                    const sourceModels = [];
+                    for (const model of this.models) {
+                        if (this.uriIdentityService.extUri.isEqualOrParent(model.resource, source)) {
+                            sourceModels.push(model);
+                        }
+                    }
+                    for (const sourceModel of sourceModels) {
+                        const sourceModelResource = sourceModel.resource;
+                        let targetModelResource;
+                        if (this.uriIdentityService.extUri.isEqual(sourceModelResource, source)) {
+                            targetModelResource = target;
+                        }
+                        else {
+                            targetModelResource = joinPath(target, sourceModelResource.path.substr(source.path.length + 1));
+                        }
+                        modelsToRestore.push({
+                            source: sourceModelResource,
+                            target: targetModelResource,
+                            languageId: sourceModel.getLanguageId(),
+                            encoding: sourceModel.getEncoding(),
+                            snapshot: sourceModel.isDirty() ? sourceModel.createSnapshot() : undefined
+                        });
+                    }
+                }
+            }
+            this.mapCorrelationIdToModelsToRestore.set(e.correlationId, modelsToRestore);
+        }
+    }
+    onDidFailWorkingCopyFileOperation(e) {
+        if (((e.operation === 2  || e.operation === 3) )) {
+            const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
+            if (modelsToRestore) {
+                this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
+                modelsToRestore.forEach(model => {
+                    if (model.snapshot) {
+                        this.get(model.source)?.setDirty(true);
+                    }
+                });
+            }
+        }
+    }
+    onDidRunWorkingCopyFileOperation(e) {
+        switch (e.operation) {
+            case 0 :
+                e.waitUntil((async () => {
+                    for (const { target } of e.files) {
+                        const model = this.get(target);
+                        if (model && !model.isDisposed()) {
+                            await model.revert();
+                        }
+                    }
+                })());
+                break;
+            case 2 :
+            case 3 :
+                e.waitUntil((async () => {
+                    const modelsToRestore = this.mapCorrelationIdToModelsToRestore.get(e.correlationId);
+                    if (modelsToRestore) {
+                        this.mapCorrelationIdToModelsToRestore.delete(e.correlationId);
+                        await Promises.settled(( modelsToRestore.map(async (modelToRestore) => {
+                            const restoredModel = await this.resolve(modelToRestore.target, {
+                                reload: { async: false },
+                                contents: modelToRestore.snapshot ? createTextBufferFactoryFromSnapshot(modelToRestore.snapshot) : undefined,
+                                encoding: modelToRestore.encoding
+                            });
+                            if (modelToRestore.languageId &&
+                                modelToRestore.languageId !== PLAINTEXT_LANGUAGE_ID &&
+                                restoredModel.getLanguageId() === PLAINTEXT_LANGUAGE_ID &&
+                                extname(modelToRestore.target) !== PLAINTEXT_EXTENSION) {
+                                restoredModel.updateTextEditorModel(undefined, modelToRestore.languageId);
+                            }
+                        })));
+                    }
+                })());
+                break;
+        }
+    }
+    get(resource) {
+        return this.mapResourceToModel.get(resource);
+    }
+    has(resource) {
+        return ( this.mapResourceToModel.has(resource));
+    }
+    async reload(model) {
+        await this.joinPendingResolves(model.resource);
+        if (model.isDirty() || model.isDisposed() || !( this.has(model.resource))) {
+            return;
+        }
+        await this.doResolve(model, { reload: { async: false } });
+    }
+    async resolve(resource, options) {
+        const pendingResolve = this.joinPendingResolves(resource);
+        if (pendingResolve) {
+            await pendingResolve;
+        }
+        return this.doResolve(resource, options);
+    }
+    async doResolve(resourceOrModel, options) {
+        let model;
+        let resource;
+        if (URI.isUri(resourceOrModel)) {
+            resource = resourceOrModel;
+            model = this.get(resource);
+        }
+        else {
+            resource = resourceOrModel.resource;
+            model = resourceOrModel;
+        }
+        let modelResolve;
+        let didCreateModel = false;
+        if (model) {
+            if (options?.contents) {
+                modelResolve = model.resolve(options);
+            }
+            else if (options?.reload) {
+                if (options.reload.async) {
+                    modelResolve = Promise.resolve();
+                    (async () => {
+                        try {
+                            await model.resolve(options);
+                        }
+                        catch (error) {
+                            onUnexpectedError(error);
+                        }
+                    })();
+                }
+                else {
+                    modelResolve = model.resolve(options);
+                }
+            }
+            else {
+                modelResolve = Promise.resolve();
+            }
+        }
+        else {
+            didCreateModel = true;
+            const newModel = model = this.instantiationService.createInstance(TextFileEditorModel, resource, options ? options.encoding : undefined, options ? options.languageId : undefined);
+            modelResolve = model.resolve(options);
+            this.registerModel(newModel);
+        }
+        this.mapResourceToPendingModelResolvers.set(resource, modelResolve);
+        this.add(resource, model);
+        if (didCreateModel) {
+            this._onDidCreate.fire(model);
+            if (model.isDirty()) {
+                this._onDidChangeDirty.fire(model);
+            }
+        }
+        try {
+            await modelResolve;
+        }
+        catch (error) {
+            if (didCreateModel) {
+                model.dispose();
+            }
+            throw error;
+        }
+        finally {
+            this.mapResourceToPendingModelResolvers.delete(resource);
+        }
+        if (options?.languageId) {
+            model.setLanguageId(options.languageId);
+        }
+        if (didCreateModel && model.isDirty()) {
+            this._onDidChangeDirty.fire(model);
+        }
+        return model;
+    }
+    joinPendingResolves(resource) {
+        const pendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
+        if (!pendingModelResolve) {
+            return;
+        }
+        return this.doJoinPendingResolves(resource);
+    }
+    async doJoinPendingResolves(resource) {
+        let currentModelCopyResolve;
+        while (( this.mapResourceToPendingModelResolvers.has(resource))) {
+            const nextPendingModelResolve = this.mapResourceToPendingModelResolvers.get(resource);
+            if (nextPendingModelResolve === currentModelCopyResolve) {
+                return;
+            }
+            currentModelCopyResolve = nextPendingModelResolve;
+            try {
+                await nextPendingModelResolve;
+            }
+            catch (error) {
+            }
+        }
+    }
+    registerModel(model) {
+        const modelListeners = ( new DisposableStore());
+        modelListeners.add(model.onDidResolve(reason => this._onDidResolve.fire({ model, reason })));
+        modelListeners.add(model.onDidChangeDirty(() => this._onDidChangeDirty.fire(model)));
+        modelListeners.add(model.onDidChangeReadonly(() => this._onDidChangeReadonly.fire(model)));
+        modelListeners.add(model.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire(model)));
+        modelListeners.add(model.onDidSaveError(() => this._onDidSaveError.fire(model)));
+        modelListeners.add(model.onDidSave(e => this._onDidSave.fire({ model, ...e })));
+        modelListeners.add(model.onDidRevert(() => this._onDidRevert.fire(model)));
+        modelListeners.add(model.onDidChangeEncoding(() => this._onDidChangeEncoding.fire(model)));
+        this.mapResourceToModelListeners.set(model.resource, modelListeners);
+    }
+    add(resource, model) {
+        const knownModel = this.mapResourceToModel.get(resource);
+        if (knownModel === model) {
+            return;
+        }
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        disposeListener?.dispose();
+        this.mapResourceToModel.set(resource, model);
+        this.mapResourceToDisposeListener.set(resource, model.onWillDispose(() => this.remove(resource)));
+    }
+    remove(resource) {
+        const removed = this.mapResourceToModel.delete(resource);
+        const disposeListener = this.mapResourceToDisposeListener.get(resource);
+        if (disposeListener) {
+            dispose(disposeListener);
+            this.mapResourceToDisposeListener.delete(resource);
+        }
+        const modelListener = this.mapResourceToModelListeners.get(resource);
+        if (modelListener) {
+            dispose(modelListener);
+            this.mapResourceToModelListeners.delete(resource);
+        }
+        if (removed) {
+            this._onDidRemove.fire(resource);
+        }
+    }
+    addSaveParticipant(participant) {
+        return this.saveParticipants.addSaveParticipant(participant);
+    }
+    runSaveParticipants(model, context, token) {
+        return this.saveParticipants.participate(model, context, token);
+    }
+    canDispose(model) {
+        if (model.isDisposed() ||
+            (!( this.mapResourceToPendingModelResolvers.has(model.resource)) && !model.isDirty())) {
+            return true;
+        }
+        return this.doCanDispose(model);
+    }
+    async doCanDispose(model) {
+        const pendingResolve = this.joinPendingResolves(model.resource);
+        if (pendingResolve) {
+            await pendingResolve;
+            return this.canDispose(model);
+        }
+        if (model.isDirty()) {
+            await Event.toPromise(model.onDidChangeDirty);
+            return this.canDispose(model);
+        }
+        return true;
+    }
+    dispose() {
+        super.dispose();
+        this.mapResourceToModel.clear();
+        this.mapResourceToPendingModelResolvers.clear();
+        dispose(( this.mapResourceToDisposeListener.values()));
+        this.mapResourceToDisposeListener.clear();
+        dispose(( this.mapResourceToModelListeners.values()));
+        this.mapResourceToModelListeners.clear();
+    }
+};
+TextFileEditorModelManager = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, INotificationService)),
+    ( __param(3, IWorkingCopyFileService)),
+    ( __param(4, IUriIdentityService))
+], TextFileEditorModelManager));
+export { TextFileEditorModelManager };

package/vscode/src/vs/workbench/services/textfile/common/textFileSaveParticipant.js

@@ -0,0 +1,62 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { localizeWithPath } from '../../../../nls.js';
+import { raceCancellation } from '../../../../base/common/async.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
+import { ILogService } from '../../../../platform/log/common/log.js';
+import { IProgressService } from '../../../../platform/progress/common/progress.js';
+import { Disposable, toDisposable } from '../../../../base/common/lifecycle.js';
+import { insert } from '../../../../base/common/arrays.js';
+let TextFileSaveParticipant = class TextFileSaveParticipant extends Disposable {
+    constructor(progressService, logService) {
+        super();
+        this.progressService = progressService;
+        this.logService = logService;
+        this.saveParticipants = [];
+    }
+    addSaveParticipant(participant) {
+        const remove = insert(this.saveParticipants, participant);
+        return toDisposable(() => remove());
+    }
+    participate(model, context, token) {
+        const cts = ( new CancellationTokenSource(token));
+        return this.progressService.withProgress({
+            title: ( localizeWithPath(
+                'vs/workbench/services/textfile/common/textFileSaveParticipant',
+                'saveParticipants',
+                "Saving '{0}'",
+                model.name
+            )),
+            location: 15 ,
+            cancellable: true,
+            delay: model.isDirty() ? 3000 : 5000
+        }, async (progress) => {
+            model.textEditorModel?.pushStackElement();
+            for (const saveParticipant of this.saveParticipants) {
+                if (cts.token.isCancellationRequested || !model.textEditorModel ) {
+                    break;
+                }
+                try {
+                    const promise = saveParticipant.participate(model, context, progress, cts.token);
+                    await raceCancellation(promise, cts.token);
+                }
+                catch (err) {
+                    this.logService.error(err);
+                }
+            }
+            model.textEditorModel?.pushStackElement();
+        }, () => {
+            cts.cancel();
+        }).finally(() => {
+            cts.dispose();
+        });
+    }
+    dispose() {
+        this.saveParticipants.splice(0, this.saveParticipants.length);
+        super.dispose();
+    }
+};
+TextFileSaveParticipant = ( __decorate([
+    ( __param(0, IProgressService)),
+    ( __param(1, ILogService))
+], TextFileSaveParticipant));
+export { TextFileSaveParticipant };

package/vscode/src/vs/workbench/services/textmodelResolver/common/textModelResolverService.js

@@ -0,0 +1,191 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { URI } from '../../../../base/common/uri.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { Disposable, AsyncReferenceCollection, ReferenceCollection, toDisposable } from '../../../../base/common/lifecycle.js';
+import { IModelService } from '../../../../editor/common/services/model.js';
+import { TextResourceEditorModel } from '../../../common/editor/textResourceEditorModel.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { Schemas } from '../../../../base/common/network.js';
+import { isResolvedTextEditorModel } from '../../../../editor/common/services/resolverService.js';
+import { TextFileEditorModel } from '../../textfile/common/textFileEditorModel.js';
+import { IFileService } from '../../../../platform/files/common/files.js';
+import { IUndoRedoService } from '../../../../platform/undoRedo/common/undoRedo.js';
+import { ModelUndoRedoParticipant } from '../../../../editor/common/services/modelUndoRedoParticipant.js';
+import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
+import { UntitledTextEditorModel } from '../../untitled/common/untitledTextEditorModel.js';
+let ResourceModelCollection = class ResourceModelCollection extends ReferenceCollection {
+    constructor(instantiationService, textFileService, fileService, modelService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.textFileService = textFileService;
+        this.fileService = fileService;
+        this.modelService = modelService;
+        this.providers = ( new Map());
+        this.modelsToDispose = ( new Set());
+    }
+    createReferencedObject(key) {
+        return this.doCreateReferencedObject(key);
+    }
+    async doCreateReferencedObject(key, skipActivateProvider) {
+        this.modelsToDispose.delete(key);
+        const resource = ( URI.parse(key));
+        if (resource.scheme === Schemas.inMemory) {
+            const cachedModel = this.modelService.getModel(resource);
+            if (!cachedModel) {
+                throw new Error(`Unable to resolve inMemory resource ${key}`);
+            }
+            const model = this.instantiationService.createInstance(TextResourceEditorModel, resource);
+            if (this.ensureResolvedModel(model, key)) {
+                return model;
+            }
+        }
+        if (resource.scheme === Schemas.untitled) {
+            const model = await this.textFileService.untitled.resolve({ untitledResource: resource });
+            if (this.ensureResolvedModel(model, key)) {
+                return model;
+            }
+        }
+        if (this.fileService.hasProvider(resource)) {
+            const model = await this.textFileService.files.resolve(resource, { reason: 2  });
+            if (this.ensureResolvedModel(model, key)) {
+                return model;
+            }
+        }
+        if (( this.providers.has(resource.scheme))) {
+            await this.resolveTextModelContent(key);
+            const model = this.instantiationService.createInstance(TextResourceEditorModel, resource);
+            if (this.ensureResolvedModel(model, key)) {
+                return model;
+            }
+        }
+        if (!skipActivateProvider) {
+            await this.fileService.activateProvider(resource.scheme);
+            return this.doCreateReferencedObject(key, true);
+        }
+        throw new Error(`Unable to resolve resource ${key}`);
+    }
+    ensureResolvedModel(model, key) {
+        if (isResolvedTextEditorModel(model)) {
+            return true;
+        }
+        throw new Error(`Unable to resolve resource ${key}`);
+    }
+    destroyReferencedObject(key, modelPromise) {
+        const resource = ( URI.parse(key));
+        if (resource.scheme === Schemas.inMemory) {
+            return;
+        }
+        this.modelsToDispose.add(key);
+        (async () => {
+            try {
+                const model = await modelPromise;
+                if (!( this.modelsToDispose.has(key))) {
+                    return;
+                }
+                if (model instanceof TextFileEditorModel) {
+                    await this.textFileService.files.canDispose(model);
+                }
+                else if (model instanceof UntitledTextEditorModel) {
+                    await this.textFileService.untitled.canDispose(model);
+                }
+                if (!( this.modelsToDispose.has(key))) {
+                    return;
+                }
+                model.dispose();
+            }
+            catch (error) {
+            }
+            finally {
+                this.modelsToDispose.delete(key);
+            }
+        })();
+    }
+    registerTextModelContentProvider(scheme, provider) {
+        let providers = this.providers.get(scheme);
+        if (!providers) {
+            providers = [];
+            this.providers.set(scheme, providers);
+        }
+        providers.unshift(provider);
+        return toDisposable(() => {
+            const providersForScheme = this.providers.get(scheme);
+            if (!providersForScheme) {
+                return;
+            }
+            const index = providersForScheme.indexOf(provider);
+            if (index === -1) {
+                return;
+            }
+            providersForScheme.splice(index, 1);
+            if (providersForScheme.length === 0) {
+                this.providers.delete(scheme);
+            }
+        });
+    }
+    hasTextModelContentProvider(scheme) {
+        return this.providers.get(scheme) !== undefined;
+    }
+    async resolveTextModelContent(key) {
+        const resource = ( URI.parse(key));
+        const providersForScheme = this.providers.get(resource.scheme) || [];
+        for (const provider of providersForScheme) {
+            const value = await provider.provideTextContent(resource);
+            if (value) {
+                return value;
+            }
+        }
+        throw new Error(`Unable to resolve text model content for resource ${key}`);
+    }
+};
+ResourceModelCollection = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IModelService))
+], ResourceModelCollection));
+let TextModelResolverService = class TextModelResolverService extends Disposable {
+    get resourceModelCollection() {
+        if (!this._resourceModelCollection) {
+            this._resourceModelCollection = this.instantiationService.createInstance(ResourceModelCollection);
+        }
+        return this._resourceModelCollection;
+    }
+    get asyncModelCollection() {
+        if (!this._asyncModelCollection) {
+            this._asyncModelCollection = ( new AsyncReferenceCollection(this.resourceModelCollection));
+        }
+        return this._asyncModelCollection;
+    }
+    constructor(instantiationService, fileService, undoRedoService, modelService, uriIdentityService) {
+        super();
+        this.instantiationService = instantiationService;
+        this.fileService = fileService;
+        this.undoRedoService = undoRedoService;
+        this.modelService = modelService;
+        this.uriIdentityService = uriIdentityService;
+        this._resourceModelCollection = undefined;
+        this._asyncModelCollection = undefined;
+        this._register(( new ModelUndoRedoParticipant(this.modelService, this, this.undoRedoService)));
+    }
+    async createModelReference(resource) {
+        resource = this.uriIdentityService.asCanonicalUri(resource);
+        return await this.asyncModelCollection.acquire(( resource.toString()));
+    }
+    registerTextModelContentProvider(scheme, provider) {
+        return this.resourceModelCollection.registerTextModelContentProvider(scheme, provider);
+    }
+    canHandleResource(resource) {
+        if (this.fileService.hasProvider(resource) || resource.scheme === Schemas.untitled || resource.scheme === Schemas.inMemory) {
+            return true;
+        }
+        return this.resourceModelCollection.hasTextModelContentProvider(resource.scheme);
+    }
+};
+TextModelResolverService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IFileService)),
+    ( __param(2, IUndoRedoService)),
+    ( __param(3, IModelService)),
+    ( __param(4, IUriIdentityService))
+], TextModelResolverService));
+export { TextModelResolverService };