@codingame/monaco-editor-wrapper 2.1.2 → 2.2.0

package/dist/configuration/index.d.ts

@@ -1,6 +1,9 @@
 import * as monaco from 'monaco-editor';
-export declare const onConfigurationChanged: monaco.IEvent<monaco.extra.IConfigurationChangeEvent>;
+import { IConfigurationChangeEvent } from 'vscode/services';
+import * as vscode from 'vscode';
+import { updateUserConfiguration } from 'vscode/service-override/configuration';
+export declare function onConfigurationChanged(listener: (e: IConfigurationChangeEvent) => void): vscode.Disposable;
 export declare function getConfiguration<C = Partial<monaco.editor.IEditorOptions>>(language?: string, section?: string): C | undefined;
-export declare function updateUserConfiguration(configurationJson: string): void;
+export { updateUserConfiguration };
 export declare function registerConfigurations(configurations: monaco.extra.IConfigurationNode[], validate?: boolean): void;
 export declare function registerDefaultConfigurations(defaultConfigurations: monaco.extra.IStringDictionary<unknown>[]): void;

package/dist/features/htmlContribution.js

@@ -2,6 +2,8 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import 'monaco-editor/esm/vs/language/html/monaco.contribution';
 import { r as registerConfigurations, g as getConfiguration, o as onConfigurationChanged } from '../index.js';
 import { r as registerWorkerLoader } from '../worker.js';
+import 'vscode/services';
+import 'vscode/service-override/configuration';
 
 const workerLoader = async () => (await import(
 /* webpackChunkName: "MonacoHtmlWorker" */
@@ -30,11 +32,15 @@ registerConfigurations([{
     }
   }
 }]);
-let autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
-onConfigurationChanged(e => {
-  if (e.affectsConfiguration('html.autoClosingTags')) {
-    autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
-  }
+let autoClosingTags = false;
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
+  onConfigurationChanged(e => {
+    if (e.affectsConfiguration('html.autoClosingTags')) {
+      autoClosingTags = getConfiguration(undefined, 'html.autoClosingTags');
+    }
+  });
 });
 
 function autoCloseHtmlTags(editor) {
@@ -101,14 +107,17 @@ function autoCloseHtmlTags(editor) {
   return disposableStore;
 }
 
-const codeEditors = monaco.extra.StandaloneServices.get(monaco.extra.ICodeEditorService).listCodeEditors();
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  const codeEditors = monaco.extra.StandaloneServices.get(monaco.extra.ICodeEditorService).listCodeEditors();
 
-for (const editor of codeEditors) {
-  autoCloseHtmlTags(editor);
-}
+  for (const editor of codeEditors) {
+    autoCloseHtmlTags(editor);
+  }
 
-monaco.editor.onDidCreateEditor(editor => {
-  autoCloseHtmlTags(editor);
+  monaco.editor.onDidCreateEditor(editor => {
+    autoCloseHtmlTags(editor);
+  });
 });
 /**
  * End autoclosing html tags

package/dist/index.js

@@ -1,4 +1,6 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { IConfigurationService } from 'vscode/services';
+import 'vscode/service-override/configuration';
 
 var configurationDefaults = {
 	"[go]": {
@@ -1222,23 +1224,24 @@ configurationRegistry.registerDefaultConfigurations([{
     'editor.codeLens': false,
     'editor.fontSize': 12,
     'editor.maxTokenizationLineLength': 1000,
-    'editor.quickSuggestions': false
+    'editor.quickSuggestions': false,
+    'files.eol': '\n'
   }
 }]);
 configurationRegistry.registerDefaultConfigurations([{
   overrides: extensions.configurationDefaults
 }]);
-const simpleConfigurationService = monaco.extra.StandaloneServices.get(monaco.extra.IConfigurationService);
-const onConfigurationChanged = simpleConfigurationService.onDidChangeConfiguration;
+function onConfigurationChanged(listener) {
+  const configurationService = monaco.extra.StandaloneServices.get(IConfigurationService);
+  return configurationService.onDidChangeConfiguration(listener);
+}
 function getConfiguration(language) {
   let section = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'editor';
-  return simpleConfigurationService.getValue(section, {
+  const configurationService = monaco.extra.StandaloneServices.get(IConfigurationService);
+  return configurationService.getValue(section, {
     overrideIdentifier: language
   });
 }
-function updateUserConfiguration(configurationJson) {
-  simpleConfigurationService.updateUserConfiguration(configurationJson);
-}
 function registerConfigurations(configurations, validate) {
   configurationRegistry.registerConfigurations(configurations, validate);
 }
@@ -1248,4 +1251,4 @@ function registerDefaultConfigurations(defaultConfigurations) {
   })));
 }
 
-export { registerDefaultConfigurations as a, extensions as e, getConfiguration as g, onConfigurationChanged as o, registerConfigurations as r, updateUserConfiguration as u };
+export { registerDefaultConfigurations as a, extensions as e, getConfiguration as g, onConfigurationChanged as o, registerConfigurations as r };

package/dist/main.js

@@ -4,10 +4,13 @@ import { _ as _objectSpread2, a as _defineProperty } from './_rollupPluginBabelH
 import onigFile from 'vscode-oniguruma/release/onig.wasm';
 import { loadWASM, createOnigScanner, createOnigString } from 'vscode-oniguruma';
 import { e as extensions, g as getConfiguration$1, o as onConfigurationChanged } from './index.js';
-export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, a as registerDefaultConfigurations, u as updateUserConfiguration } from './index.js';
+export { g as getConfiguration, o as onConfigurationChanged, r as registerConfigurations, a as registerDefaultConfigurations } from './index.js';
 import getModelEditorServiceOverride from 'vscode/service-override/modelEditor';
 import getMessageServiceOverride from 'vscode/service-override/messages';
+import getConfigurationServiceOverride from 'vscode/service-override/configuration';
+export { updateUserConfiguration } from 'vscode/service-override/configuration';
 import './worker.js';
+import { createConfiguredEditor } from 'vscode/monaco';
 import 'monaco-editor/esm/vs/editor/editor.all';
 import 'monaco-editor/esm/vs/editor/standalone/browser/accessibilityHelp/accessibilityHelp';
 import 'monaco-editor/esm/vs/editor/standalone/browser/iPadShowKeyboard/iPadShowKeyboard';
@@ -18,6 +21,7 @@ import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneGot
 import 'monaco-editor/esm/vs/editor/standalone/browser/quickAccess/standaloneCommandsQuickAccess';
 import 'monaco-editor/esm/vs/editor/standalone/browser/referenceSearch/standaloneReferenceSearch';
 import * as shiftCommand from 'monaco-editor/esm/vs/editor/common/commands/shiftCommand';
+import 'vscode/services';
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {
@@ -1852,11 +1856,10 @@ function getOrCreateGrammarFactory() {
   return textMateGrammarFactory;
 }
 
-const languageService$2 = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
-
 async function createTextMateTokensProvider(languageId) {
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
   const grammarFactory = getOrCreateGrammarFactory();
-  const encodedLanguageId = languageService$2.languageIdCodec.encodeLanguageId(languageId);
+  const encodedLanguageId = languageService.languageIdCodec.encodeLanguageId(languageId);
 
   if (!grammarFactory.has(languageId)) {
     return null;
@@ -1875,7 +1878,7 @@ async function createTextMateTokensProvider(languageId) {
   const tokenization = new monaco$2.extra.TMTokenization(grammar, initialState, containsEmbeddedLanguages);
   tokenization.onDidEncounterLanguage(encodedLanguageId => {
     // Force monaco to load this language and trigger the global `onDidEncounterLanguage`
-    languageService$2.createById(languageService$2.languageIdCodec.decodeLanguageId(encodedLanguageId));
+    languageService.createById(languageService.languageIdCodec.decodeLanguageId(encodedLanguageId));
   });
   return new CGTMTokenizationSupport(languageId, encodedLanguageId, tokenization, grammar);
 }
@@ -4108,9 +4111,12 @@ class SimpleSnippetService {
 
 }
 
-const languageService$1 = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
-const languageConfigurationService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageConfigurationService);
-monaco$2.extra.setSnippetSuggestSupport(new monaco$2.extra.SnippetCompletionProvider(languageService$1, new SimpleSnippetService(), languageConfigurationService));
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
+  const languageConfigurationService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageConfigurationService);
+  monaco$2.extra.setSnippetSuggestSupport(new monaco$2.extra.SnippetCompletionProvider(languageService, new SimpleSnippetService(), languageConfigurationService));
+});
 
 /* Add custom blocks parsing (for tech.io):
 // { [autofold]
@@ -4153,7 +4159,6 @@ for (const [languageId, aliases] of Object.entries(customAliases)) {
   });
 }
 
-const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
 const languagesIds = Array.from(new Set([...Object.keys(languageLoader), ...textMateLanguages.map(rawLanguage => rawLanguage.id)]));
 
 for (const textMateLanguage of textMateLanguages) {
@@ -4218,19 +4223,24 @@ async function loadLanguageConfiguration(languageId) {
   }
 }
 
-languageService.onDidEncounterLanguage(async languageId => {
-  if (languageId === 'plaintext') {
-    return;
-  }
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
+  languageService.onDidEncounterLanguage(async languageId => {
+    if (languageId === 'plaintext') {
+      return;
+    }
 
-  loadLanguageConfiguration(languageId).catch(error => {
-    monaco$2.errorHandler.onUnexpectedError(new Error("Unable to load language configuration for language ".concat(languageId), {
-      cause: error
-    }));
+    loadLanguageConfiguration(languageId).catch(error => {
+      monaco$2.errorHandler.onUnexpectedError(new Error("Unable to load language configuration for language ".concat(languageId), {
+        cause: error
+      }));
+    });
   });
 });
 
 function getMonacoLanguage(languageOrModeId) {
+  const languageService = monaco$2.extra.StandaloneServices.get(monaco$2.languages.ILanguageService);
   const modeId = languageService.getLanguageIdByLanguageName(languageOrModeId.toLowerCase());
 
   if (modeId != null) {
@@ -4626,24 +4636,20 @@ class EditorOpenHandlerRegistry {
 }
 
 const editorOpenHandlerRegistry = new EditorOpenHandlerRegistry();
-monaco$2.extra.StandaloneServices.initialize(_objectSpread2(_objectSpread2({}, getModelEditorServiceOverride((model, input, sideBySide) => {
+monaco$2.extra.StandaloneServices.initialize(_objectSpread2(_objectSpread2(_objectSpread2({}, getModelEditorServiceOverride((model, input, sideBySide) => {
   return editorOpenHandlerRegistry.openCodeEditor(model, input, sideBySide);
-})), getMessageServiceOverride(document.body))); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
-
-monaco$2.extra.StandaloneServices.get(monaco$2.editor.IStandaloneThemeService).setAutoDetectHighContrast(false); // Force EOL to be '\n' even on Windows
+})), getMessageServiceOverride(document.body)), getConfigurationServiceOverride())); // Disable high contrast autodetection because it fallbacks on the hc-black no matter what
 
-const configurationService = monaco$2.extra.StandaloneServices.get(monaco$2.extra.IConfigurationService);
-configurationService.updateValue('files.eol', '\n').catch(error => {
-  monaco$2.errorHandler.onUnexpectedError(new Error('Unable to set file eol', {
-    cause: error
-  }));
+setTimeout(() => {
+  // In a timeout so the service can be overriden
+  monaco$2.extra.StandaloneServices.get(monaco$2.editor.IStandaloneThemeService).setAutoDetectHighContrast(false);
 });
 monaco$2.errorHandler.setUnexpectedErrorHandler(error => {
   console.warn('Unexpected error', error);
 });
 
 function createEditor(domElement, options) {
-  const editor = monaco$2.editor.create(domElement, options);
+  const editor = createConfiguredEditor(domElement, options);
   setup(editor);
   return editor;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-editor-wrapper",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "private": false,
   "description": "Enhanced Monaco editor with TextMate grammars and more",
   "scripts": {
@@ -66,7 +66,7 @@
   ],
   "dependencies": {
     "monaco-editor": "npm:@codingame/monaco-editor@^0.33.6",
-    "vscode": "npm:@codingame/monaco-vscode-api@~1.67.9",
+    "vscode": "npm:@codingame/monaco-vscode-api@~1.67.19",
     "vscode-oniguruma": "^1.6.2"
   },
   "devDependencies": {
@@ -88,6 +88,7 @@
     "@types/js-yaml": "^4.0.5",
     "@types/node": "16.11.7",
     "@types/rollup-plugin-node-builtins": "^2.1.2",
+    "@types/vscode": "~1.67.0",
     "@typescript-eslint/eslint-plugin": "5.27.1",
     "@typescript-eslint/parser": "5.27.1",
     "conventional-changelog-conventionalcommits": "^4.6.3",