register tokenizers early (with promises)

src/_.contribution.ts

@@ -16,31 +16,61 @@ interface ILangImpl {
 	language: monaco.languages.IMonarchLanguage;
 }
 
-let languageDefinitions: { [languageId: string]: ILang } = {};
+const languageDefinitions: { [languageId: string]: ILang; } = {};
+const lazyLanguageLoaders: { [languageId: string]: LazyLanguageLoader; } = {};
 
-function _loadLanguage(languageId: string): Promise<void> {
+class LazyLanguageLoader {
-	const loader = languageDefinitions[languageId].loader;
+
-	return loader().then((mod) => {
+	public static getOrCreate(languageId: string): LazyLanguageLoader {
-		_monaco.languages.setMonarchTokensProvider(languageId, mod.language);
+		if (!lazyLanguageLoaders[languageId]) {
-		_monaco.languages.setLanguageConfiguration(languageId, mod.conf);
+			lazyLanguageLoaders[languageId] = new LazyLanguageLoader(languageId);
-	});
+		}
-}
+		return lazyLanguageLoaders[languageId];
+	}
+
+	private readonly _languageId: string;
+	private _loadingTriggered: boolean;
+	private _lazyLoadPromise: Promise<ILangImpl>;
+	private _lazyLoadPromiseResolve!: (value: ILangImpl) => void;
+	private _lazyLoadPromiseReject!: (err: any) => void;
 
-let languagePromises: { [languageId: string]: Promise<void> } = {};
+	constructor(languageId: string) {
+		this._languageId = languageId;
+		this._loadingTriggered = false;
+		this._lazyLoadPromise = new Promise((resolve, reject) => {
+			this._lazyLoadPromiseResolve = resolve;
+			this._lazyLoadPromiseReject = reject;
+		});
+	}
 
-export function loadLanguage(languageId: string): Promise<void> {
+	public whenLoaded(): Promise<ILangImpl> {
-	if (!languagePromises[languageId]) {
+		return this._lazyLoadPromise;
-		languagePromises[languageId] = _loadLanguage(languageId);
+	}
+
+	public load(): Promise<ILangImpl> {
+		if (!this._loadingTriggered) {
+			this._loadingTriggered = true;
+			languageDefinitions[this._languageId].loader().then(mod => this._lazyLoadPromiseResolve(mod), err => this._lazyLoadPromiseReject(err));
+		}
+		return this._lazyLoadPromise;
 	}
-	return languagePromises[languageId];
+}
+
+export function loadLanguage(languageId: string): Promise<ILangImpl> {
+	return LazyLanguageLoader.getOrCreate(languageId).load();
 }
 
 export function registerLanguage(def: ILang): void {
-	let languageId = def.id;
+	const languageId = def.id;
 
 	languageDefinitions[languageId] = def;
 	_monaco.languages.register(def);
+
+	const lazyLanguageLoader = LazyLanguageLoader.getOrCreate(languageId);
+	_monaco.languages.setMonarchTokensProvider(languageId, lazyLanguageLoader.whenLoaded().then(mod => mod.language));
 	_monaco.languages.onLanguage(languageId, () => {
-		loadLanguage(languageId);
+		lazyLanguageLoader.load().then(mod => {
+			_monaco.languages.setLanguageConfiguration(languageId, mod.conf);
+		});
 	});
 }