feat: Add 2 methods to get editors plugged on the configuration service

Author: CGNonofr

package.json

@@ -35,6 +35,10 @@
     "./service-override/configuration": {
       "types": "./dist/configuration.d.ts",
       "default": "./dist/configuration.js"
+    },
+    "./monaco": {
+      "types": "./dist/monaco.d.ts",
+      "default": "./dist/monaco.js"
     }
   },
   "typesVersions": {
@@ -50,6 +54,9 @@
       ],
       "service-override/configuration": [
         "./dist/configuration.d.ts"
+      ],
+      "monaco": [
+        "./dist/monaco.d.ts"
       ]
     }
   },

rollup/rollup.config.ts

@@ -85,7 +85,8 @@ export default (args: Record<string, string>): rollup.RollupOptions => {
       services: './src/services.ts',
       messages: './src/service-override/messages.ts',
       modelEditor: './src/service-override/modelEditor.ts',
-      configuration: './src/service-override/configuration.ts'
+      configuration: './src/service-override/configuration.ts',
+      monaco: './src/monaco'
     },
     plugins: [
       {

rollup/rollup.types.config.ts

@@ -16,7 +16,8 @@ export default rollup.defineConfig([
   './dist/types/src/services.d.ts',
   './dist/types/src/service-override/messages.d.ts',
   './dist/types/src/service-override/modelEditor.d.ts',
-  './dist/types/src/service-override/configuration.d.ts'
+  './dist/types/src/service-override/configuration.d.ts',
+  './dist/types/src/monaco.d.ts'
 ].map((input): rollup.RollupOptions => ({
   input,
   output: {

src/monaco.ts

@@ -0,0 +1,103 @@
+import { StandaloneServices } from 'vs/editor/standalone/browser/standaloneServices'
+import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfiguration'
+import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation'
+import { IStandaloneEditorConstructionOptions, StandaloneDiffEditor, StandaloneEditor } from 'vs/editor/standalone/browser/standaloneCodeEditor'
+import { IEditorOptions } from 'vs/editor/common/config/editorOptions'
+import { IEditorConfiguration } from 'vs/workbench/browser/parts/editor/textEditor'
+import { isObject } from 'vs/base/common/types'
+import { deepClone, distinct } from 'vs/base/common/objects'
+import { CodeEditorWidget } from 'vs/editor/browser/widget/codeEditorWidget'
+import type { create as createEditor, createDiffEditor } from 'vs/editor/standalone/browser/standaloneEditor'
+import { createInjectedClass } from './tools/injection'
+
+function computeConfiguration (configuration: IEditorConfiguration, isDiffEditor: boolean, overrides?: Readonly<IEditorOptions>): IEditorOptions {
+  const editorConfiguration: IEditorOptions = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null)
+  if (isDiffEditor && isObject(configuration.diffEditor)) {
+    Object.assign(editorConfiguration, configuration.diffEditor)
+  }
+  if (isObject(configuration.diffEditor)) {
+    Object.assign(editorConfiguration, overrides)
+  }
+  return editorConfiguration
+}
+
+/**
+ * A StandaloneEditor which is plugged on the `textResourceConfigurationService` for its options
+ * So instead of just taking the options given by the user via the `updateOptions` method,
+ * it fallbacks on the current configurationService configuration
+ */
+class ConfiguredStandaloneEditor extends createInjectedClass(StandaloneEditor) {
+  // use createInjectedClass because StandaloneEditor has a lot of injected services and it would be a pain to inject them all here to be able to forward them
+  // Also, the injected services may vary so relying on the annotations is more robust (and useful for @codingame/monaco-editor which removes a service from the list)
+
+  private optionsOverrides?: Readonly<IEditorOptions>
+  private lastAppliedEditorOptions?: IEditorOptions
+
+  constructor (
+    domElement: HTMLElement,
+    private isDiffEditor: boolean,
+    _options: Readonly<IStandaloneEditorConstructionOptions> | undefined,
+    @IInstantiationService instantiationService: IInstantiationService,
+    @ITextResourceConfigurationService private textResourceConfigurationService: ITextResourceConfigurationService
+  ) {
+    const computedOptions = computeConfiguration(textResourceConfigurationService.getValue<IEditorConfiguration>(_options?.model?.uri), isDiffEditor, _options)
+    super(instantiationService, domElement, computedOptions)
+    this.lastAppliedEditorOptions = computedOptions
+
+    this.optionsOverrides = _options
+    this._register(textResourceConfigurationService.onDidChangeConfiguration(() => this.updateEditorConfiguration()))
+    this._register(this.onDidChangeModelLanguage(() => this.updateEditorConfiguration()))
+    this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()))
+  }
+
+  /**
+   * This method is widely inspired from vs/workbench/browser/parts/editor/textEditor
+   */
+  private updateEditorConfiguration (): void {
+    const resource = this.getModel()?.uri
+    if (resource == null) {
+      return
+    }
+    const configuration = this.textResourceConfigurationService.getValue<IEditorConfiguration | undefined>(resource)
+    if (configuration == null) {
+      return
+    }
+
+    const editorConfiguration = computeConfiguration(configuration, this.isDiffEditor, this.optionsOverrides)
+
+    // Try to figure out the actual editor options that changed from the last time we updated the editor.
+    // We do this so that we are not overwriting some dynamic editor settings (e.g. word wrap) that might
+    // have been applied to the editor directly.
+    let editorSettingsToApply = editorConfiguration
+    if (this.lastAppliedEditorOptions != null) {
+      editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply)
+    }
+
+    if (Object.keys(editorSettingsToApply).length > 0) {
+      this.lastAppliedEditorOptions = editorConfiguration
+
+      super.updateOptions(editorSettingsToApply)
+    }
+  }
+
+  override updateOptions (newOptions: Readonly<IEditorOptions>): void {
+    this.optionsOverrides = newOptions
+    this.updateEditorConfiguration()
+  }
+}
+
+class ConfiguredStandaloneDiffEditor extends StandaloneDiffEditor {
+  protected override _createInnerEditor (instantiationService: IInstantiationService, container: HTMLElement, options: Readonly<IEditorOptions>): CodeEditorWidget {
+    return instantiationService.createInstance(ConfiguredStandaloneEditor, container, true, options)
+  }
+}
+
+export const createConfiguredEditor: typeof createEditor = (domElement, options, override) => {
+  const instantiationService = StandaloneServices.initialize(override ?? {})
+  return instantiationService.createInstance(ConfiguredStandaloneEditor, domElement, false, options)
+}
+
+export const createConfiguredDiffEditor: typeof createDiffEditor = (domElement, options, override) => {
+  const instantiationService = StandaloneServices.initialize(override ?? {})
+  return instantiationService.createInstance(ConfiguredStandaloneDiffEditor, domElement, options)
+}

tsconfig.types.json

@@ -52,5 +52,5 @@
 	"emitDeclarationOnly": true,
 	"skipLibCheck": true
   },
-  "include": ["src/services.ts", "src/types.d.ts", "src/service-override/messages.ts", "src/service-override/modelEditor.ts", "src/service-override/configuration.ts"]
+  "include": ["src/services.ts", "src/types.d.ts", "src/service-override/messages.ts", "src/service-override/modelEditor.ts", "src/service-override/configuration.ts", "src/monaco.ts"]
 }