@codingame/monaco-vscode-model-service-override 3.2.3 → 4.1.0

package/model.js

@@ -1,5 +1,5 @@
 import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { TextModelResolverService } from './vscode/src/vs/workbench/services/textmodelResolver/common/textModelResolverService.js';
+import { TextModelResolverService } from 'vscode/vscode/vs/workbench/services/textmodelResolver/common/textModelResolverService';
 import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
 
 function getServiceOverride() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-model-service-override",
-  "version": "3.2.3",
+  "version": "4.1.0",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@3.2.3"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
   }
 }

package/external/tslib/tslib.es6.js

@@ -1,11 +0,0 @@
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-export { __decorate, __param };

package/vscode/src/vs/editor/common/services/modelUndoRedoParticipant.js

@@ -1,58 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { Disposable, dispose } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IUndoRedoService } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo';
-import { MultiModelEditStackElement } from 'vscode/vscode/vs/editor/common/model/editStack';
-
-let ModelUndoRedoParticipant = class ModelUndoRedoParticipant extends Disposable {
-    constructor(_modelService, _textModelService, _undoRedoService) {
-        super();
-        this._modelService = _modelService;
-        this._textModelService = _textModelService;
-        this._undoRedoService = _undoRedoService;
-        this._register(this._modelService.onModelRemoved((model) => {
-            const elements = this._undoRedoService.getElements(model.uri);
-            if (elements.past.length === 0 && elements.future.length === 0) {
-                return;
-            }
-            for (const element of elements.past) {
-                if (element instanceof MultiModelEditStackElement) {
-                    element.setDelegate(this);
-                }
-            }
-            for (const element of elements.future) {
-                if (element instanceof MultiModelEditStackElement) {
-                    element.setDelegate(this);
-                }
-            }
-        }));
-    }
-    prepareUndoRedo(element) {
-        const missingModels = element.getMissingModels();
-        if (missingModels.length === 0) {
-            return Disposable.None;
-        }
-        const disposablesPromises = ( missingModels.map(async (uri) => {
-            try {
-                const reference = await this._textModelService.createModelReference(uri);
-                return reference;
-            }
-            catch (err) {
-                return Disposable.None;
-            }
-        }));
-        return Promise.all(disposablesPromises).then(disposables => {
-            return {
-                dispose: () => dispose(disposables)
-            };
-        });
-    }
-};
-ModelUndoRedoParticipant = ( __decorate([
-    ( __param(0, IModelService)),
-    ( __param(1, ITextModelService)),
-    ( __param(2, IUndoRedoService))
-], ModelUndoRedoParticipant));
-
-export { ModelUndoRedoParticipant };

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

@@ -1,193 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ReferenceCollection, toDisposable, Disposable, AsyncReferenceCollection } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
-import { TextResourceEditorModel } from 'vscode/vscode/vs/workbench/common/editor/textResourceEditorModel';
-import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isResolvedTextEditorModel } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { TextFileEditorModel } from 'vscode/vscode/vs/workbench/services/textfile/common/textFileEditorModel';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IUndoRedoService } from 'vscode/vscode/vs/platform/undoRedo/common/undoRedo';
-import { ModelUndoRedoParticipant } from '../../../../editor/common/services/modelUndoRedoParticipant.js';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { UntitledTextEditorModel } from 'vscode/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel';
-
-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 };