@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/services/textMate/common/TMGrammarFactory.js

@@ -1,118 +0,0 @@
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { TMScopeRegistry } from './TMScopeRegistry.js';
-const missingTMGrammarErrorMessage = 'No TM Grammar registered for this language.';
-class TMGrammarFactory extends Disposable {
-    constructor(host, grammarDefinitions, vscodeTextmate, onigLib) {
-        super();
-        this._host = host;
-        this._initialState = vscodeTextmate.INITIAL;
-        this._scopeRegistry = ( new TMScopeRegistry());
-        this._injections = {};
-        this._injectedEmbeddedLanguages = {};
-        this._languageToScope = ( new Map());
-        this._grammarRegistry = this._register(new vscodeTextmate.Registry({
-            onigLib: onigLib,
-            loadGrammar: async (scopeName) => {
-                const grammarDefinition = this._scopeRegistry.getGrammarDefinition(scopeName);
-                if (!grammarDefinition) {
-                    this._host.logTrace(`No grammar found for scope ${scopeName}`);
-                    return null;
-                }
-                const location = grammarDefinition.location;
-                try {
-                    const content = await this._host.readFile(location);
-                    return vscodeTextmate.parseRawGrammar(content, location.path);
-                }
-                catch (e) {
-                    this._host.logError(`Unable to load and parse grammar for scope ${scopeName} from ${location}`, e);
-                    return null;
-                }
-            },
-            getInjections: (scopeName) => {
-                const scopeParts = scopeName.split('.');
-                let injections = [];
-                for (let i = 1; i <= scopeParts.length; i++) {
-                    const subScopeName = scopeParts.slice(0, i).join('.');
-                    injections = [...injections, ...(this._injections[subScopeName] || [])];
-                }
-                return injections;
-            }
-        }));
-        for (const validGrammar of grammarDefinitions) {
-            this._scopeRegistry.register(validGrammar);
-            if (validGrammar.injectTo) {
-                for (const injectScope of validGrammar.injectTo) {
-                    let injections = this._injections[injectScope];
-                    if (!injections) {
-                        this._injections[injectScope] = injections = [];
-                    }
-                    injections.push(validGrammar.scopeName);
-                }
-                if (validGrammar.embeddedLanguages) {
-                    for (const injectScope of validGrammar.injectTo) {
-                        let injectedEmbeddedLanguages = this._injectedEmbeddedLanguages[injectScope];
-                        if (!injectedEmbeddedLanguages) {
-                            this._injectedEmbeddedLanguages[injectScope] = injectedEmbeddedLanguages = [];
-                        }
-                        injectedEmbeddedLanguages.push(validGrammar.embeddedLanguages);
-                    }
-                }
-            }
-            if (validGrammar.language) {
-                this._languageToScope.set(validGrammar.language, validGrammar.scopeName);
-            }
-        }
-    }
-    has(languageId) {
-        return ( this._languageToScope.has(languageId));
-    }
-    setTheme(theme, colorMap) {
-        this._grammarRegistry.setTheme(theme, colorMap);
-    }
-    getColorMap() {
-        return this._grammarRegistry.getColorMap();
-    }
-    async createGrammar(languageId, encodedLanguageId) {
-        const scopeName = this._languageToScope.get(languageId);
-        if (typeof scopeName !== 'string') {
-            throw new Error(missingTMGrammarErrorMessage);
-        }
-        const grammarDefinition = this._scopeRegistry.getGrammarDefinition(scopeName);
-        if (!grammarDefinition) {
-            throw new Error(missingTMGrammarErrorMessage);
-        }
-        const embeddedLanguages = grammarDefinition.embeddedLanguages;
-        if (this._injectedEmbeddedLanguages[scopeName]) {
-            const injectedEmbeddedLanguages = this._injectedEmbeddedLanguages[scopeName];
-            for (const injected of injectedEmbeddedLanguages) {
-                for (const scope of ( Object.keys(injected))) {
-                    embeddedLanguages[scope] = injected[scope];
-                }
-            }
-        }
-        const containsEmbeddedLanguages = (( Object.keys(embeddedLanguages)).length > 0);
-        let grammar;
-        try {
-            grammar = await this._grammarRegistry.loadGrammarWithConfiguration(scopeName, encodedLanguageId, {
-                embeddedLanguages,
-                tokenTypes: grammarDefinition.tokenTypes,
-                balancedBracketSelectors: grammarDefinition.balancedBracketSelectors,
-                unbalancedBracketSelectors: grammarDefinition.unbalancedBracketSelectors,
-            });
-        }
-        catch (err) {
-            if (err.message && err.message.startsWith('No grammar provided for')) {
-                throw new Error(missingTMGrammarErrorMessage);
-            }
-            throw err;
-        }
-        return {
-            languageId: languageId,
-            grammar: grammar,
-            initialState: this._initialState,
-            containsEmbeddedLanguages: containsEmbeddedLanguages,
-            sourceExtensionId: grammarDefinition.sourceExtensionId,
-        };
-    }
-}
-export { TMGrammarFactory, missingTMGrammarErrorMessage };

package/vscode/src/vs/workbench/services/textMate/common/TMGrammars.js

@@ -1,93 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ExtensionsRegistry } from '../../extensions/common/extensionsRegistry.js';
-import { languagesExtPoint } from '../../language/common/languageService.js';
-const grammarsExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'grammars',
-    deps: [languagesExtPoint],
-    jsonSchema: {
-        description: ( nls.localize(
-            'vscode.extension.contributes.grammars',
-            'Contributes textmate tokenizers.'
-        )),
-        type: 'array',
-        defaultSnippets: [{ body: [{ language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' }] }],
-        items: {
-            type: 'object',
-            defaultSnippets: [{ body: { language: '${1:id}', scopeName: 'source.${2:id}', path: './syntaxes/${3:id}.tmLanguage.' } }],
-            properties: {
-                language: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.language',
-                        'Language identifier for which this syntax is contributed to.'
-                    )),
-                    type: 'string'
-                },
-                scopeName: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.scopeName',
-                        'Textmate scope name used by the tmLanguage file.'
-                    )),
-                    type: 'string'
-                },
-                path: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.path',
-                        'Path of the tmLanguage file. The path is relative to the extension folder and typically starts with \'./syntaxes/\'.'
-                    )),
-                    type: 'string'
-                },
-                embeddedLanguages: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.embeddedLanguages',
-                        'A map of scope name to language id if this grammar contains embedded languages.'
-                    )),
-                    type: 'object'
-                },
-                tokenTypes: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.tokenTypes',
-                        'A map of scope name to token types.'
-                    )),
-                    type: 'object',
-                    additionalProperties: {
-                        enum: ['string', 'comment', 'other']
-                    }
-                },
-                injectTo: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.injectTo',
-                        'List of language scope names to which this grammar is injected to.'
-                    )),
-                    type: 'array',
-                    items: {
-                        type: 'string'
-                    }
-                },
-                balancedBracketScopes: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.balancedBracketScopes',
-                        'Defines which scope names contain balanced brackets.'
-                    )),
-                    type: 'array',
-                    items: {
-                        type: 'string'
-                    },
-                    default: ['*'],
-                },
-                unbalancedBracketScopes: {
-                    description: ( nls.localize(
-                        'vscode.extension.contributes.grammars.unbalancedBracketScopes',
-                        'Defines which scope names do not contain balanced brackets.'
-                    )),
-                    type: 'array',
-                    items: {
-                        type: 'string'
-                    },
-                    default: [],
-                },
-            },
-            required: ['scopeName', 'path']
-        }
-    }
-}));
-export { grammarsExtPoint };

package/vscode/src/vs/workbench/services/textMate/common/TMScopeRegistry.js

@@ -1,24 +0,0 @@
-import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-class TMScopeRegistry {
-    constructor() {
-        this._scopeNameToLanguageRegistration = Object.create(null);
-    }
-    reset() {
-        this._scopeNameToLanguageRegistration = Object.create(null);
-    }
-    register(def) {
-        if (this._scopeNameToLanguageRegistration[def.scopeName]) {
-            const existingRegistration = this._scopeNameToLanguageRegistration[def.scopeName];
-            if (!resources.isEqual(existingRegistration.location, def.location)) {
-                console.warn(`Overwriting grammar scope name to file mapping for scope ${def.scopeName}.\n` +
-                    `Old grammar file: ${( ( existingRegistration.location.toString()))}.\n` +
-                    `New grammar file: ${( ( def.location.toString()))}`);
-            }
-        }
-        this._scopeNameToLanguageRegistration[def.scopeName] = def;
-    }
-    getGrammarDefinition(scopeName) {
-        return this._scopeNameToLanguageRegistration[scopeName] || null;
-    }
-}
-export { TMScopeRegistry };

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

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