Merge pull request #28 from CodinGame/improve-configuration-service-override

Improve configuration service override

Author: CGNonofr

README.md

@@ -28,6 +28,8 @@ Services.install({
 })
 ```
 
+## Monaco standalone services
+
 Also, monaco-editor use `standalone` versions or the vscode services, which are much simpler.
 
 You may want to provide your custom implementations of them, especially for: `textModelService`, `codeEditorService` and `notificationService`. To do so, you can provide them as the third parameter while creating your first editor.
@@ -64,12 +66,40 @@ StandaloneServices.initialize({
     // It will be called when for instance the user ctrl+click on an import
   }),
   ...getMessageServiceOverride(document.body),
-  ...getConfigurationServiceOverride(readConfiguration, configurationChangeEvent)
+  ...getConfigurationServiceOverride(() => userConfigurationJson, configurationChangeEvent)
 })
 ```
 
 Note: using `vscode/service-override/modelEditor`, you'll be able to use the `vscode.workspace.registerTextDocumentContentProvider` api
 
+### Troubleshoot
+
+`StandaloneServices.initialize` can only be called once (note that `monaco.editor.create` calls `StandaloneServices.initialize`).
+
+Also, a service that is used cannot be overriden anymore. So `StandaloneServices.initialize` should be called as soon as possible to prevent most of the issues.
+
+## Editor configuration
+
+The editors created using `monaco.editor.create` don't use the configuration from the configurationService.
+
+This library exposes functions to create editors binded on the configuration:
+
+before:
+```typescript
+import * as monaco from 'monaco-editor'
+monaco.editor.create(...)
+```
+
+after:
+```typescript
+import { createConfiguredEditor } from 'vscode/monaco'
+
+createConfiguredEditor(...)
+```
+
+`createConfiguredEditor` returns a subclass of what is returned by `monaco.editor.create`, the `updateOptions` method can still be used.
+The only difference is that is will use the `configurationService` as a default configuration
+
 ### Installation
 
 ```bash

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)
+}

src/service-override/configuration.ts

@@ -9,6 +9,9 @@ import { FileChangeType, FileSystemProviderCapabilities, FileType, IFileChange,
 import { FileService } from 'vs/platform/files/common/fileService'
 import { ILogService } from 'vs/platform/log/common/log'
 import { Schemas } from 'vs/base/common/network'
+import { ITextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfiguration'
+import { TextResourceConfigurationService } from 'vs/editor/common/services/textResourceConfigurationService'
+import { SyncDescriptor } from 'vs/platform/instantiation/common/descriptors'
 import { unsupported } from '../tools'
 
 function createConfigurationFileSystemProvider (settingsResource: URI, readConfiguration: () => string, onChange: Event<void>) {
@@ -69,6 +72,7 @@ export default function getServiceOverride (readConfiguration: () => string, onC
   })
 
   return {
-    [IConfigurationService.toString()]: configurationService
+    [IConfigurationService.toString()]: configurationService,
+    [ITextResourceConfigurationService.toString()]: new SyncDescriptor(TextResourceConfigurationService)
   }
 }

src/tools/injection.ts

@@ -0,0 +1,25 @@
+import { BrandedService, IInstantiationService, _util } from 'vs/platform/instantiation/common/instantiation'
+
+function getInjectedParameters<Ctor extends new (...args: any[]) => InstanceType<Ctor>> (instantiationService: IInstantiationService, ctor: Ctor) {
+  return instantiationService.invokeFunction((accessor) => {
+    return _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index).map(d => accessor.get(d.id))
+  })
+}
+
+declare type GetLeadingNonServiceArgs<Args> = Args extends [...BrandedService[]] ? [] : Args extends [infer A, ...BrandedService[]] ? [A] : Args extends [infer A, ...infer R] ? [A, ...GetLeadingNonServiceArgs<R>] : never
+
+/**
+ * Takes a class with injected services as parameters and returns a child class that only takes the injector as parameter
+ * @param ctor The class to inject
+ * @returns A class that only needs the injector
+ */
+export function createInjectedClass<Ctor extends new (...args: any[]) => InstanceType<Ctor>>(ctor: Ctor): new (instantiationService: IInstantiationService, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>) => InstanceType<Ctor> {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const _ctor = (ctor as (new (...args: any[]) => any))
+  return class extends _ctor {
+    constructor (...args: any[]) {
+      super(...args.slice(1), ...getInjectedParameters(args[0], ctor))
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } as any
+}

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"]
 }