@codingame/monaco-vscode-api 1.68.7 → 1.69.2

package/dist/languageService.js

@@ -0,0 +1,340 @@
+import { _ as __decorate, a as __param } from './tslib.es6.js';
+import { h as ExtensionsRegistry, I as IExtensionService } from './missing-services.js';
+import { Y as FILES_ASSOCIATIONS_CONFIG } from './services2.js';
+import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
+import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { LanguageService } from 'monaco-editor/esm/vs/editor/common/services/languageService.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+let registeredAssociations = [];
+let userRegisteredAssociations = [];
+function registerConfiguredLanguageAssociation(association) {
+    _registerLanguageAssociation(association, true, false);
+}
+function _registerLanguageAssociation(association, userConfigured, warnOnOverwrite) {
+    const associationItem = toLanguageAssociationItem(association, userConfigured);
+    registeredAssociations.push(associationItem);
+    if (!associationItem.userConfigured) ;
+    else {
+        userRegisteredAssociations.push(associationItem);
+    }
+    if (warnOnOverwrite && !associationItem.userConfigured) {
+        registeredAssociations.forEach(a => {
+            if (a.mime === associationItem.mime || a.userConfigured) {
+                return;
+            }
+            if (associationItem.extension && a.extension === associationItem.extension) {
+                console.warn(`Overwriting extension <<${associationItem.extension}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.filename && a.filename === associationItem.filename) {
+                console.warn(`Overwriting filename <<${associationItem.filename}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.filepattern && a.filepattern === associationItem.filepattern) {
+                console.warn(`Overwriting filepattern <<${associationItem.filepattern}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+            if (associationItem.firstline && a.firstline === associationItem.firstline) {
+                console.warn(`Overwriting firstline <<${associationItem.firstline}>> to now point to mime <<${associationItem.mime}>>`);
+            }
+        });
+    }
+}
+function toLanguageAssociationItem(association, userConfigured) {
+    return {
+        id: association.id,
+        mime: association.mime,
+        filename: association.filename,
+        extension: association.extension,
+        filepattern: association.filepattern,
+        firstline: association.firstline,
+        userConfigured: userConfigured,
+        filenameLowercase: association.filename ? association.filename.toLowerCase() : undefined,
+        extensionLowercase: association.extension ? association.extension.toLowerCase() : undefined,
+        filepatternLowercase: association.filepattern ? parse(association.filepattern.toLowerCase()) : undefined,
+        filepatternOnPath: association.filepattern ? association.filepattern.indexOf(posix.sep) >= 0 : false
+    };
+}
+function clearConfiguredLanguageAssociations() {
+    registeredAssociations = registeredAssociations.filter(a => !a.userConfigured);
+    userRegisteredAssociations = [];
+}
+const languagesExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
+    extensionPoint: 'languages',
+    jsonSchema: {
+        description: ( localize(
+            'vscode.extension.contributes.languages',
+            'Contributes language declarations.'
+        )),
+        type: 'array',
+        items: {
+            type: 'object',
+            defaultSnippets: [{ body: { id: '${1:languageId}', aliases: ['${2:label}'], extensions: ['${3:extension}'], configuration: './language-configuration.json' } }],
+            properties: {
+                id: {
+                    description: ( localize('vscode.extension.contributes.languages.id', 'ID of the language.')),
+                    type: 'string'
+                },
+                aliases: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.aliases',
+                        'Name aliases for the language.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                extensions: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.extensions',
+                        'File extensions associated to the language.'
+                    )),
+                    default: ['.foo'],
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                filenames: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.filenames',
+                        'File names associated to the language.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                filenamePatterns: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.filenamePatterns',
+                        'File name glob patterns associated to the language.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                mimetypes: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.mimetypes',
+                        'Mime types associated to the language.'
+                    )),
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    }
+                },
+                firstLine: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.firstLine',
+                        'A regular expression matching the first line of a file of the language.'
+                    )),
+                    type: 'string'
+                },
+                configuration: {
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.configuration',
+                        'A relative path to a file containing configuration options for the language.'
+                    )),
+                    type: 'string',
+                    default: './language-configuration.json'
+                },
+                icon: {
+                    type: 'object',
+                    description: ( localize(
+                        'vscode.extension.contributes.languages.icon',
+                        'A icon to use as file icon, if no icon theme provides one for the language.'
+                    )),
+                    properties: {
+                        light: {
+                            description: ( localize(
+                                'vscode.extension.contributes.languages.icon.light',
+                                'Icon path when a light theme is used'
+                            )),
+                            type: 'string'
+                        },
+                        dark: {
+                            description: ( localize(
+                                'vscode.extension.contributes.languages.icon.dark',
+                                'Icon path when a dark theme is used'
+                            )),
+                            type: 'string'
+                        }
+                    }
+                }
+            }
+        }
+    }
+}));
+let WorkbenchLanguageService = class WorkbenchLanguageService extends LanguageService {
+    constructor(extensionService, configurationService, environmentService, logService) {
+        super(environmentService.verbose || environmentService.isExtensionDevelopment || !environmentService.isBuilt);
+        this.logService = logService;
+        this._configurationService = configurationService;
+        this._extensionService = extensionService;
+        languagesExtPoint.setHandler((extensions) => {
+            const allValidLanguages = [];
+            for (let i = 0, len = extensions.length; i < len; i++) {
+                const extension = extensions[i];
+                if (!Array.isArray(extension.value)) {
+                    extension.collector.error(( localize(
+                        'invalid',
+                        "Invalid `contributes.{0}`. Expected an array.",
+                        languagesExtPoint.name
+                    )));
+                    continue;
+                }
+                for (let j = 0, lenJ = extension.value.length; j < lenJ; j++) {
+                    const ext = extension.value[j];
+                    if (isValidLanguageExtensionPoint(ext, extension.description, extension.collector)) {
+                        let configuration = undefined;
+                        if (ext.configuration) {
+                            configuration = joinPath(extension.description.extensionLocation, ext.configuration);
+                        }
+                        allValidLanguages.push({
+                            id: ext.id,
+                            extensions: ext.extensions,
+                            filenames: ext.filenames,
+                            filenamePatterns: ext.filenamePatterns,
+                            firstLine: ext.firstLine,
+                            aliases: ext.aliases,
+                            mimetypes: ext.mimetypes,
+                            configuration: configuration,
+                            icon: ext.icon && {
+                                light: joinPath(extension.description.extensionLocation, ext.icon.light),
+                                dark: joinPath(extension.description.extensionLocation, ext.icon.dark)
+                            }
+                        });
+                    }
+                }
+            }
+            this._registry.setDynamicLanguages(allValidLanguages);
+        });
+        this.updateMime();
+        this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(FILES_ASSOCIATIONS_CONFIG)) {
+                this.updateMime();
+            }
+        });
+        this._extensionService.whenInstalledExtensionsRegistered().then(() => {
+            this.updateMime();
+        });
+        this.onDidEncounterLanguage((languageId) => {
+            this._extensionService.activateByEvent(`onLanguage:${languageId}`);
+        });
+    }
+    updateMime() {
+        const configuration = this._configurationService.getValue();
+        clearConfiguredLanguageAssociations();
+        if (configuration.files?.associations) {
+            ( Object.keys(configuration.files.associations)).forEach(pattern => {
+                const langId = configuration.files.associations[pattern];
+                if (typeof langId !== 'string') {
+                    this.logService.warn(`Ingnoing configured 'files.associations' for '${pattern}' because its type is not a string but '${typeof langId}'`);
+                    return;
+                }
+                const mimeType = this.getMimeType(langId) || `text/x-${langId}`;
+                registerConfiguredLanguageAssociation({ id: langId, mime: mimeType, filepattern: pattern });
+            });
+        }
+        this._onDidChange.fire();
+    }
+};
+WorkbenchLanguageService = ( __decorate([
+    ( __param(0, IExtensionService)),
+    ( __param(1, IConfigurationService)),
+    ( __param(2, IEnvironmentService)),
+    ( __param(3, ILogService))
+], WorkbenchLanguageService));
+function isUndefinedOrStringArray(value) {
+    if (typeof value === 'undefined') {
+        return true;
+    }
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every(item => typeof item === 'string');
+}
+function isValidLanguageExtensionPoint(value, extension, collector) {
+    if (!value) {
+        collector.error(( localize(
+            'invalid.empty',
+            "Empty value for `contributes.{0}`",
+            languagesExtPoint.name
+        )));
+        return false;
+    }
+    if (typeof value.id !== 'string') {
+        collector.error(( localize(
+            'require.id',
+            "property `{0}` is mandatory and must be of type `string`",
+            'id'
+        )));
+        return false;
+    }
+    if (!isUndefinedOrStringArray(value.extensions)) {
+        collector.error(( localize(
+            'opt.extensions',
+            "property `{0}` can be omitted and must be of type `string[]`",
+            'extensions'
+        )));
+        return false;
+    }
+    if (!isUndefinedOrStringArray(value.filenames)) {
+        collector.error(( localize(
+            'opt.filenames',
+            "property `{0}` can be omitted and must be of type `string[]`",
+            'filenames'
+        )));
+        return false;
+    }
+    if (typeof value.firstLine !== 'undefined' && typeof value.firstLine !== 'string') {
+        collector.error(( localize(
+            'opt.firstLine',
+            "property `{0}` can be omitted and must be of type `string`",
+            'firstLine'
+        )));
+        return false;
+    }
+    if (typeof value.configuration !== 'undefined' && typeof value.configuration !== 'string') {
+        collector.error(( localize(
+            'opt.configuration',
+            "property `{0}` can be omitted and must be of type `string`",
+            'configuration'
+        )));
+        return false;
+    }
+    if (!isUndefinedOrStringArray(value.aliases)) {
+        collector.error(( localize(
+            'opt.aliases',
+            "property `{0}` can be omitted and must be of type `string[]`",
+            'aliases'
+        )));
+        return false;
+    }
+    if (!isUndefinedOrStringArray(value.mimetypes)) {
+        collector.error(( localize(
+            'opt.mimetypes',
+            "property `{0}` can be omitted and must be of type `string[]`",
+            'mimetypes'
+        )));
+        return false;
+    }
+    if (typeof value.icon !== 'undefined') {
+        if (typeof value.icon !== 'object' || typeof value.icon.light !== 'string' || typeof value.icon.dark !== 'string') {
+            collector.error(( localize(
+                'opt.icon',
+                "property `{0}` can be omitted and must be of type `object` with properties `{1}` and `{2}` of type `string`",
+                'icon',
+                'light',
+                'dark'
+            )));
+            return false;
+        }
+    }
+    return true;
+}
+export { WorkbenchLanguageService as W, languagesExtPoint as l };