@codingame/monaco-vscode-api 1.76.2 → 1.76.3-next.0

package/dist/labels.js

@@ -0,0 +1,14 @@
+import { isMacintosh, isWindows } from 'monaco-editor/esm/vs/base/common/platform.js';
+function untildify(path, userHome) {
+    return path.replace(/^~($|\/|\\)/, `${userHome}$1`);
+}
+function mnemonicButtonLabel(label, forceDisableMnemonics) {
+    if (isMacintosh || forceDisableMnemonics) {
+        return label.replace(/\(&&\w\)|&&/g, '');
+    }
+    if (isWindows) {
+        return label.replace(/&&|&/g, m => m === '&' ? '&&' : '&');
+    }
+    return label.replace(/&&/g, '_');
+}
+export { mnemonicButtonLabel as m, untildify as u };

package/dist/languageConfiguration.d.ts

@@ -2,7 +2,6 @@ import * as monaco from 'monaco-editor';
 
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
-declare function setLanguageConfiguration(path: string, getConfiguration: () => Promise<string>): void;
 declare function getServiceOverride(): IEditorOverrideServices;
 
-export { getServiceOverride as default, setLanguageConfiguration };
+export { getServiceOverride as default };

package/dist/languageConfiguration.js

@@ -1,8 +1,8 @@
-import { p as parse, g as getNodeType } from './polyfill.js';
-import { f as ITextMateTokenizationService, c as IExtensionService } from './missing-services.js';
-import { _ as __decorate, a as __param } from './contextkey.js';
+import { o as onServicesInitialized, p as parse, j as getNodeType } from './polyfill.js';
+import { bW as ITextMateTokenizationService, bp as IExtensionService } from './missing-services.js';
+import { _ as __decorate, a as __param } from './services2.js';
 import { g as getParseErrorMessage } from './jsonErrorMessages.js';
-import { r as registerExtensionFile, g as getServiceOverride$1, I as IExtensionResourceLoaderService } from './files.js';
+import { I as IExtensionResourceLoaderService } from './extensionResourceLoader.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { hash } from 'monaco-editor/esm/vs/base/common/hash.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
@@ -12,10 +12,7 @@ import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/commo
 import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
 import { Extensions } from 'monaco-editor/esm/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
 import { IndentAction } from 'monaco-editor/esm/vs/editor/common/languages/languageConfiguration.js';
-import { o as onServicesInitialized } from './tools.js';
-import { S as Services } from './services2.js';
-import { bj as DEFAULT_EXTENSION } from './extHost.js';
-import { joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { g as getServiceOverride$1 } from './files.js';
 function isStringArr(something) {
     if (!Array.isArray(something)) {
         return false;
@@ -55,12 +52,12 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
     }
     async _loadConfigurationsForMode(languageId) {
         const configurationFiles = this._languageService.getConfigurationFiles(languageId);
-        const configurationHash = hash(configurationFiles.map(uri => ( uri.toString())));
+        const configurationHash = hash(( configurationFiles.map(uri => ( uri.toString()))));
         if (this._done.get(languageId) === configurationHash) {
             return;
         }
         this._done.set(languageId, configurationHash);
-        const configs = await Promise.all(configurationFiles.map(configFile => this._readConfigFile(configFile)));
+        const configs = await Promise.all(( configurationFiles.map(configFile => this._readConfigFile(configFile))));
         for (const config of configs) {
             this._handleConfig(languageId, config);
         }
@@ -71,7 +68,7 @@ let LanguageConfigurationFileHandler = class LanguageConfigurationFileHandler ex
             const errors = [];
             let configuration = parse(contents, errors);
             if (errors.length) {
-                console.error(( localize('parseErrors', "Errors parsing {0}: {1}", ( configFileLocation.toString()), errors.map(e => (`[${e.offset}, ${e.length}] ${getParseErrorMessage(e.error)}`)).join('\n'))));
+                console.error(( localize('parseErrors', "Errors parsing {0}: {1}", ( configFileLocation.toString()), ( errors.map(e => (`[${e.offset}, ${e.length}] ${getParseErrorMessage(e.error)}`))).join('\n'))));
             }
             if (getNodeType(configuration) !== 'object') {
                 console.error(( localize(
@@ -910,10 +907,6 @@ const schema = {
 };
 const schemaRegistry = ( Registry.as(Extensions.JSONContribution));
 schemaRegistry.registerSchema(schemaId, schema);
-function setLanguageConfiguration(path, getConfiguration) {
-    const extension = Services.get().extension ?? DEFAULT_EXTENSION;
-    registerExtensionFile(joinPath(extension.extensionLocation, path), getConfiguration);
-}
 function initialize(instantiationService) {
     instantiationService.createInstance(LanguageConfigurationFileHandler);
 }
@@ -923,4 +916,4 @@ function getServiceOverride() {
         ...getServiceOverride$1()
     };
 }
-export { getServiceOverride as default, setLanguageConfiguration };
+export { getServiceOverride as default };

package/dist/languageService.js

@@ -1,16 +1,20 @@
-import { _ as __decorate, a as __param } from './contextkey.js';
-import { c as IExtensionService } from './missing-services.js';
-import { E as ExtensionsRegistry } from './tools.js';
-import { O as FILES_ASSOCIATIONS_CONFIG } from './services2.js';
+import { aS as FILES_ASSOCIATIONS_CONFIG, _ as __decorate, a as __param } from './services2.js';
+import { bp as IExtensionService } from './missing-services.js';
+import { E as ExtensionsRegistry } from './extensionsRegistry.js';
 import { parse } from 'monaco-editor/esm/vs/base/common/glob.js';
-import { posix } from 'monaco-editor/esm/vs/base/common/path.js';
+import { posix, basename } from 'monaco-editor/esm/vs/base/common/path.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { joinPath, DataUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { Mimes } from 'monaco-editor/esm/vs/base/common/mime.js';
+import { PLAINTEXT_LANGUAGE_ID } from 'monaco-editor/esm/vs/editor/common/languages/modesRegistry.js';
+import { startsWithUTF8BOM } from 'monaco-editor/esm/vs/base/common/strings.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 nonUserRegisteredAssociations = [];
 let userRegisteredAssociations = [];
 function registerConfiguredLanguageAssociation(association) {
     _registerLanguageAssociation(association, true, false);
@@ -18,7 +22,9 @@ function registerConfiguredLanguageAssociation(association) {
 function _registerLanguageAssociation(association, userConfigured, warnOnOverwrite) {
     const associationItem = toLanguageAssociationItem(association, userConfigured);
     registeredAssociations.push(associationItem);
-    if (!associationItem.userConfigured) ;
+    if (!associationItem.userConfigured) {
+        nonUserRegisteredAssociations.push(associationItem);
+    }
     else {
         userRegisteredAssociations.push(associationItem);
     }
@@ -61,6 +67,104 @@ function clearConfiguredLanguageAssociations() {
     registeredAssociations = registeredAssociations.filter(a => !a.userConfigured);
     userRegisteredAssociations = [];
 }
+function getMimeTypes(resource, firstLine) {
+    return ( getAssociations(resource, firstLine).map(item => item.mime));
+}
+function getAssociations(resource, firstLine) {
+    let path;
+    if (resource) {
+        switch (resource.scheme) {
+            case Schemas.file:
+                path = resource.fsPath;
+                break;
+            case Schemas.data: {
+                const metadata = DataUri.parseMetaData(resource);
+                path = metadata.get(DataUri.META_DATA_LABEL);
+                break;
+            }
+            case Schemas.vscodeNotebookCell:
+                path = undefined;
+                break;
+            default:
+                path = resource.path;
+        }
+    }
+    if (!path) {
+        return [{ id: 'unknown', mime: Mimes.unknown }];
+    }
+    path = path.toLowerCase();
+    const filename = basename(path);
+    const configuredLanguage = getAssociationByPath(path, filename, userRegisteredAssociations);
+    if (configuredLanguage) {
+        return [configuredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+    }
+    const registeredLanguage = getAssociationByPath(path, filename, nonUserRegisteredAssociations);
+    if (registeredLanguage) {
+        return [registeredLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+    }
+    if (firstLine) {
+        const firstlineLanguage = getAssociationByFirstline(firstLine);
+        if (firstlineLanguage) {
+            return [firstlineLanguage, { id: PLAINTEXT_LANGUAGE_ID, mime: Mimes.text }];
+        }
+    }
+    return [{ id: 'unknown', mime: Mimes.unknown }];
+}
+function getAssociationByPath(path, filename, associations) {
+    let filenameMatch = undefined;
+    let patternMatch = undefined;
+    let extensionMatch = undefined;
+    for (let i = associations.length - 1; i >= 0; i--) {
+        const association = associations[i];
+        if (filename === association.filenameLowercase) {
+            filenameMatch = association;
+            break;
+        }
+        if (association.filepattern) {
+            if (!patternMatch || association.filepattern.length > patternMatch.filepattern.length) {
+                const target = association.filepatternOnPath ? path : filename;
+                if (association.filepatternLowercase?.(target)) {
+                    patternMatch = association;
+                }
+            }
+        }
+        if (association.extension) {
+            if (!extensionMatch || association.extension.length > extensionMatch.extension.length) {
+                if (filename.endsWith(association.extensionLowercase)) {
+                    extensionMatch = association;
+                }
+            }
+        }
+    }
+    if (filenameMatch) {
+        return filenameMatch;
+    }
+    if (patternMatch) {
+        return patternMatch;
+    }
+    if (extensionMatch) {
+        return extensionMatch;
+    }
+    return undefined;
+}
+function getAssociationByFirstline(firstLine) {
+    if (startsWithUTF8BOM(firstLine)) {
+        firstLine = firstLine.substr(1);
+    }
+    if (firstLine.length > 0) {
+        for (let i = registeredAssociations.length - 1; i >= 0; i--) {
+            const association = registeredAssociations[i];
+            if (!association.firstline) {
+                continue;
+            }
+            const matches = firstLine.match(association.firstline);
+            if (matches && matches.length > 0) {
+                return association;
+            }
+        }
+    }
+    return undefined;
+}
 const languagesExtPoint = ( ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: 'languages',
     jsonSchema: {
@@ -346,4 +450,4 @@ function isValidLanguageExtensionPoint(value, extension, collector) {
     }
     return true;
 }
-export { WorkbenchLanguageService as W, languagesExtPoint as l };
+export { WorkbenchLanguageService as W, getMimeTypes as g, languagesExtPoint as l };