@codingame/monaco-vscode-keybindings-service-override 1.83.9 → 1.83.10

package/monaco.js

@@ -2,7 +2,7 @@ import { __decorate, __param } from './external/tslib/tslib.es6.js';
 import { StandaloneKeybindingService } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
 import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { StandaloneEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+import { StandaloneEditor, StandaloneDiffEditor2 } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
 import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
 import { distinct, deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
 export { errorHandler } from 'monaco-editor/esm/vs/base/common/errors.js';
@@ -67,25 +67,40 @@ ExtensionPoints = __decorate([
     ( __param(0, IInstantiationService))
 ], ExtensionPoints);
 ( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(ExtensionPoints, 1 );
-function computeConfiguration(configuration, isDiffEditor, overrides) {
+function computeConfiguration(configuration, overrides) {
     const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
-    if (isDiffEditor && isObject(configuration.diffEditor)) {
-        Object.assign(editorConfiguration, deepClone(configuration.diffEditor));
+    Object.assign(editorConfiguration, deepClone(overrides));
+    return editorConfiguration;
+}
+function computeDiffConfiguration(configuration, overrides) {
+    const editorConfiguration = computeConfiguration(configuration);
+    if (isObject(configuration.diffEditor)) {
+        const diffEditorConfiguration = deepClone(configuration.diffEditor);
+        diffEditorConfiguration.diffCodeLens = diffEditorConfiguration.codeLens;
+        delete diffEditorConfiguration.codeLens;
+        diffEditorConfiguration.diffWordWrap = diffEditorConfiguration.wordWrap;
+        delete diffEditorConfiguration.wordWrap;
+        Object.assign(editorConfiguration, diffEditorConfiguration);
     }
+    editorConfiguration.accessibilityVerbose = configuration.accessibility?.verbosity?.diffEditor ?? false;
     Object.assign(editorConfiguration, deepClone(overrides));
     return editorConfiguration;
 }
 let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends createInjectedClass(StandaloneEditor) {
-    constructor(domElement, isDiffEditor, _options = {}, instantiationService, textResourceConfigurationService) {
+    constructor(domElement, _options = {}, instantiationService, textResourceConfigurationService) {
         const { theme, autoDetectHighContrast, model, value, language, accessibilityHelpUrl, ariaContainerElement, overflowWidgetsDomNode, dimension, ...options } = _options;
-        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options.model?.uri), isDiffEditor, options);
+        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options.model?.uri), options);
         super(instantiationService, domElement, { ...computedOptions, overflowWidgetsDomNode, dimension, theme, autoDetectHighContrast, model, value, language, accessibilityHelpUrl, ariaContainerElement });
-        this.isDiffEditor = isDiffEditor;
         this.textResourceConfigurationService = textResourceConfigurationService;
         this.optionsOverrides = {};
         this.lastAppliedEditorOptions = computedOptions;
         this.optionsOverrides = options;
-        this._register(textResourceConfigurationService.onDidChangeConfiguration(() => this.updateEditorConfiguration()));
+        this._register(textResourceConfigurationService.onDidChangeConfiguration((e) => {
+            const resource = this.getModel()?.uri;
+            if (resource != null && e.affectsConfiguration(resource, 'editor')) {
+                this.updateEditorConfiguration();
+            }
+        }));
         this._register(this.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
         this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
         this.updateEditorConfiguration();
@@ -99,7 +114,7 @@ let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends create
         if (configuration == null) {
             return;
         }
-        const editorConfiguration = computeConfiguration(configuration, this.isDiffEditor, this.optionsOverrides);
+        const editorConfiguration = computeConfiguration(configuration, this.optionsOverrides);
         let editorSettingsToApply = editorConfiguration;
         if (this.lastAppliedEditorOptions != null) {
             editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
@@ -119,9 +134,63 @@ let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends create
     }
 };
 ConfiguredStandaloneEditor = __decorate([
-    ( __param(3, IInstantiationService)),
-    ( __param(4, ITextResourceConfigurationService))
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextResourceConfigurationService))
 ], ConfiguredStandaloneEditor);
+let ConfiguredStandaloneDiffEditor = class ConfiguredStandaloneDiffEditor extends createInjectedClass(StandaloneDiffEditor2) {
+    constructor(domElement, _options = {}, instantiationService, textResourceConfigurationService) {
+        const { theme, autoDetectHighContrast, modifiedAriaLabel, originalAriaLabel, overflowWidgetsDomNode, dimension, ...options } = _options;
+        const computedOptions = computeDiffConfiguration(textResourceConfigurationService.getValue(undefined), options);
+        super(instantiationService, domElement, { ...computedOptions, overflowWidgetsDomNode, dimension, theme, autoDetectHighContrast, modifiedAriaLabel, originalAriaLabel });
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.optionsOverrides = {};
+        this.lastAppliedEditorOptions = computedOptions;
+        this.optionsOverrides = options;
+        this._register(textResourceConfigurationService.onDidChangeConfiguration((e) => {
+            const resource = this._targetEditor.getModel()?.uri;
+            if (resource != null && (e.affectsConfiguration(resource, 'editor') || e.affectsConfiguration(resource, 'diffEditor') || e.affectsConfiguration(resource, 'accessibility.verbosity.diffEditor'))) {
+                this.updateEditorConfiguration();
+            }
+        }));
+        this._register(this._targetEditor.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
+        this.updateEditorConfiguration();
+    }
+    updateEditorConfiguration() {
+        if (this.getModel() == null || this.textResourceConfigurationService == null) {
+            return;
+        }
+        const resource = this._targetEditor.getModel()?.uri;
+        const configuration = this.textResourceConfigurationService.getValue(resource);
+        if (configuration == null) {
+            return;
+        }
+        const editorConfiguration = computeDiffConfiguration(configuration, this.optionsOverrides);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions != null) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (( Object.keys(editorSettingsToApply)).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            super.updateOptions(editorSettingsToApply);
+        }
+    }
+    updateOptions(newOptions) {
+        this.optionsOverrides ?? (this.optionsOverrides = {});
+        this.optionsOverrides = {
+            ...this.optionsOverrides,
+            ...newOptions
+        };
+        this.updateEditorConfiguration();
+    }
+    _createInnerEditor(instantiationService, container, options) {
+        return instantiationService.createInstance(ConfiguredStandaloneEditor, container, options);
+    }
+};
+ConfiguredStandaloneDiffEditor = __decorate([
+    ( __param(2, IInstantiationService)),
+    ( __param(3, ITextResourceConfigurationService))
+], ConfiguredStandaloneDiffEditor);
 let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingService extends StandaloneKeybindingService {
     constructor(delegate, contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
         super(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-keybindings-service-override",
-  "version": "1.83.9",
+  "version": "1.83.10",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,8 +18,8 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.83.9",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.83.10",
     "monaco-editor": "0.44.0",
-    "@codingame/monaco-vscode-files-service-override": "1.83.9"
+    "@codingame/monaco-vscode-files-service-override": "1.83.10"
   }
 }