@theia/monaco 1.45.1 → 1.46.0-next.72

package/src/browser/monaco-init.ts

@@ -0,0 +1,114 @@
+// *****************************************************************************
+// Copyright (C) 2023 STMicroelectronics and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+/*
+ * The code in this file is responsible for overriding service implementations in the Monaco editor with our own Theia-based implementations.
+ * Since we only get a single chance to call `StandaloneServies.initialize()` with our overrides, we need to make sure that intialize is called before the first call to
+ * `StandaloneServices.get()` or `StandaloneServies.initialize()`. As we do not control the mechanics of Inversify instance constructions, the approach here is to call
+ * `MonacoInit.init()` from the `index.js` file after all container modules are loaded, but before the first object is fetched from it.
+ * `StandaloneServices.initialize()` is called with service descriptors, not service instances. This lets us finish all overrides before any inversify object is constructed and
+ * might call `initialize()` while being constructed.
+ * The service descriptors require a constructor function, so we declare dummy class for each Monaco service we override. But instead of returning an instance of the dummy class,
+ * we fetch the implementation of the monaco service from the inversify container.
+ * The inversify-constructed services must not call StandaloneServices.get() or StandaloneServices.initialize() from their constructors. Calling `get`()` in postConstruct mehtods
+ * is allowed.
+ */
+
+import { Container } from '@theia/core/shared/inversify';
+import { ICodeEditorService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/codeEditorService';
+import { StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { SyncDescriptor } from '@theia/monaco-editor-core/esm/vs/platform/instantiation/common/descriptors';
+import { MonacoEditorServiceFactory, MonacoEditorServiceFactoryType } from './monaco-editor-service';
+import { IConfigurationService } from '@theia/monaco-editor-core/esm/vs/platform/configuration/common/configuration';
+import { ITextModelService } from '@theia/monaco-editor-core/esm/vs/editor/common/services/resolverService';
+import { MonacoConfigurationService } from './monaco-frontend-module';
+import { MonacoTextModelService } from './monaco-text-model-service';
+import { MonacoContextMenuService } from './monaco-context-menu';
+import { IContextMenuService } from '@theia/monaco-editor-core/esm/vs/platform/contextview/browser/contextView';
+import { IContextKeyService } from '@theia/monaco-editor-core/esm/vs/platform/contextkey/common/contextkey';
+import { IThemeService } from '@theia/monaco-editor-core/esm/vs/platform/theme/common/themeService';
+import { MonacoBulkEditService } from './monaco-bulk-edit-service';
+import { MonacoCommandService } from './monaco-command-service';
+import { IBulkEditService } from '@theia/monaco-editor-core/esm/vs/editor/browser/services/bulkEditService';
+import { ICommandService } from '@theia/monaco-editor-core/esm/vs/platform/commands/common/commands';
+import { MonacoQuickInputImplementation } from './monaco-quick-input-service';
+import { IQuickInputService } from '@theia/monaco-editor-core/esm/vs/platform/quickinput/common/quickInput';
+
+class MonacoEditorServiceConstructor {
+    /**
+     * MonacoEditorService needs other Monaco services as constructor parameters, so we need to do use a factory for constructing the service. If we want the singleton instance,
+     * we need to fetch it from the `StandaloneServices` class instead of injecting it.
+     * @param container
+     * @param contextKeyService
+     * @param themeService
+     */
+    constructor(container: Container,
+        @IContextKeyService contextKeyService: IContextKeyService,
+        @IThemeService themeService: IThemeService) {
+
+        return container.get<MonacoEditorServiceFactoryType>(MonacoEditorServiceFactory)(contextKeyService, themeService);
+    };
+}
+
+class MonacoConfigurationServiceConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoConfigurationService);
+    }
+}
+
+class MonacoTextModelServiceConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoTextModelService);
+    }
+}
+
+class MonacoContextMenuServiceConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoContextMenuService);
+    }
+}
+
+class MonacoBulkEditServiceConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoBulkEditService);
+    }
+}
+
+class MonacoCommandServiceConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoCommandService);
+    }
+}
+
+class MonacoQuickInputImplementationConstructor {
+    constructor(container: Container) {
+        return container.get(MonacoQuickInputImplementation);
+    }
+}
+
+export namespace MonacoInit {
+    export function init(container: Container): void {
+        StandaloneServices.initialize({
+            [ICodeEditorService.toString()]: new SyncDescriptor(MonacoEditorServiceConstructor, [container]),
+            [IConfigurationService.toString()]: new SyncDescriptor(MonacoConfigurationServiceConstructor, [container]),
+            [ITextModelService.toString()]: new SyncDescriptor(MonacoTextModelServiceConstructor, [container]),
+            [IContextMenuService.toString()]: new SyncDescriptor(MonacoContextMenuServiceConstructor, [container]),
+            [IBulkEditService.toString()]: new SyncDescriptor(MonacoBulkEditServiceConstructor, [container]),
+            [ICommandService.toString()]: new SyncDescriptor(MonacoCommandServiceConstructor, [container]),
+            [IQuickInputService.toString()]: new SyncDescriptor(MonacoQuickInputImplementationConstructor, [container]),
+        });
+    }
+}

package/src/browser/monaco-keybinding.ts

@@ -1,111 +1,111 @@
-// *****************************************************************************
-// Copyright (C) 2017 TypeFox and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-
-import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
-import { KeybindingContribution, KeybindingRegistry, KeybindingScope, KeyCode } from '@theia/core/lib/browser';
-import { MonacoCommands } from './monaco-command';
-import { MonacoCommandRegistry } from './monaco-command-registry';
-import { CommandRegistry, DisposableCollection, environment, isOSX } from '@theia/core';
-import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
-import { KeybindingsRegistry } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybindingsRegistry';
-import { StandaloneKeybindingService, StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
-import { IKeybindingService } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding';
-import { MonacoContextKeyService } from './monaco-context-key-service';
-import { KEY_CODE_MAP } from './monaco-keycode-map';
-import * as monaco from '@theia/monaco-editor-core';
-
-@injectable()
-export class MonacoKeybindingContribution implements KeybindingContribution {
-
-    protected toDisposeOnKeybindingChange = new DisposableCollection();
-
-    @inject(MonacoCommandRegistry) protected readonly commands: MonacoCommandRegistry;
-    @inject(KeybindingRegistry) protected readonly keybindings: KeybindingRegistry;
-    @inject(CommandRegistry) protected readonly theiaCommandRegistry: CommandRegistry;
-    @inject(MonacoContextKeyService) protected readonly contextKeyService: MonacoContextKeyService;
-
-    @postConstruct()
-    protected init(): void {
-        this.keybindings.onKeybindingsChanged(() => this.updateMonacoKeybindings());
-    }
-
-    registerKeybindings(registry: KeybindingRegistry): void {
-        const defaultKeybindings = KeybindingsRegistry.getDefaultKeybindings();
-        for (const item of defaultKeybindings) {
-            const command = this.commands.validate(item.command);
-            if (command) {
-                const when = (item.when && item.when.serialize()) ?? undefined;
-                let keybinding;
-                if (item.command === MonacoCommands.GO_TO_DEFINITION && !environment.electron.is()) {
-                    keybinding = 'ctrlcmd+f11';
-                } else {
-                    keybinding = MonacoResolvedKeybinding.toKeybinding(item.keybinding);
-                }
-                registry.registerKeybinding({ command, keybinding, when });
-            }
-        }
-    }
-
-    protected updateMonacoKeybindings(): void {
-        const monacoKeybindingRegistry = StandaloneServices.get(IKeybindingService);
-        if (monacoKeybindingRegistry instanceof StandaloneKeybindingService) {
-            this.toDisposeOnKeybindingChange.dispose();
-            for (const binding of this.keybindings.getKeybindingsByScope(KeybindingScope.USER).concat(this.keybindings.getKeybindingsByScope(KeybindingScope.WORKSPACE))) {
-                const resolved = this.keybindings.resolveKeybinding(binding);
-                const command = binding.command;
-                const when = binding.when
-                    ? this.contextKeyService.parse(binding.when)
-                    : binding.context
-                        ? this.contextKeyService.parse(binding.context)
-                        : undefined;
-                this.toDisposeOnKeybindingChange.push(monacoKeybindingRegistry.addDynamicKeybinding(
-                    binding.command,
-                    this.toMonacoKeybindingNumber(resolved),
-                    (_, ...args) => this.theiaCommandRegistry.executeCommand(command, ...args),
-                    when,
-                ));
-            }
-        }
-    }
-
-    protected toMonacoKeybindingNumber(codes: KeyCode[]): number {
-        const [firstPart, secondPart] = codes;
-        if (codes.length > 2) {
-            console.warn('Key chords should not consist of more than two parts; got ', codes);
-        }
-        const encodedFirstPart = this.toSingleMonacoKeybindingNumber(firstPart);
-        const encodedSecondPart = secondPart ? this.toSingleMonacoKeybindingNumber(secondPart) << 16 : 0;
-        return monaco.KeyMod.chord(encodedFirstPart, encodedSecondPart);
-    }
-
-    protected toSingleMonacoKeybindingNumber(code: KeyCode): number {
-        const keyCode = code.key?.keyCode !== undefined ? KEY_CODE_MAP[code.key.keyCode] : 0;
-        let encoded = (keyCode >>> 0) & 0x000000FF;
-        if (code.alt) {
-            encoded |= monaco.KeyMod.Alt;
-        }
-        if (code.shift) {
-            encoded |= monaco.KeyMod.Shift;
-        }
-        if (code.ctrl) {
-            encoded |= monaco.KeyMod.WinCtrl;
-        }
-        if (code.meta && isOSX) {
-            encoded |= monaco.KeyMod.CtrlCmd;
-        }
-        return encoded;
-    }
-}
+// *****************************************************************************
+// Copyright (C) 2017 TypeFox and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { injectable, inject, postConstruct } from '@theia/core/shared/inversify';
+import { KeybindingContribution, KeybindingRegistry, KeybindingScope, KeyCode } from '@theia/core/lib/browser';
+import { MonacoCommands } from './monaco-command';
+import { MonacoCommandRegistry } from './monaco-command-registry';
+import { CommandRegistry, DisposableCollection, environment, isOSX } from '@theia/core';
+import { MonacoResolvedKeybinding } from './monaco-resolved-keybinding';
+import { KeybindingsRegistry } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybindingsRegistry';
+import { StandaloneKeybindingService, StandaloneServices } from '@theia/monaco-editor-core/esm/vs/editor/standalone/browser/standaloneServices';
+import { IKeybindingService } from '@theia/monaco-editor-core/esm/vs/platform/keybinding/common/keybinding';
+import { MonacoContextKeyService } from './monaco-context-key-service';
+import { KEY_CODE_MAP } from './monaco-keycode-map';
+import * as monaco from '@theia/monaco-editor-core';
+
+@injectable()
+export class MonacoKeybindingContribution implements KeybindingContribution {
+
+    protected toDisposeOnKeybindingChange = new DisposableCollection();
+
+    @inject(MonacoCommandRegistry) protected readonly commands: MonacoCommandRegistry;
+    @inject(KeybindingRegistry) protected readonly keybindings: KeybindingRegistry;
+    @inject(CommandRegistry) protected readonly theiaCommandRegistry: CommandRegistry;
+    @inject(MonacoContextKeyService) protected readonly contextKeyService: MonacoContextKeyService;
+
+    @postConstruct()
+    protected init(): void {
+        this.keybindings.onKeybindingsChanged(() => this.updateMonacoKeybindings());
+    }
+
+    registerKeybindings(registry: KeybindingRegistry): void {
+        const defaultKeybindings = KeybindingsRegistry.getDefaultKeybindings();
+        for (const item of defaultKeybindings) {
+            const command = this.commands.validate(item.command || undefined);
+            if (command && item.keybinding) {
+                const when = (item.when && item.when.serialize()) ?? undefined;
+                let keybinding;
+                if (item.command === MonacoCommands.GO_TO_DEFINITION && !environment.electron.is()) {
+                    keybinding = 'ctrlcmd+f11';
+                } else {
+                    keybinding = MonacoResolvedKeybinding.toKeybinding(item.keybinding.chords);
+                }
+                registry.registerKeybinding({ command, keybinding, when });
+            }
+        }
+    }
+
+    protected updateMonacoKeybindings(): void {
+        const monacoKeybindingRegistry = StandaloneServices.get(IKeybindingService);
+        if (monacoKeybindingRegistry instanceof StandaloneKeybindingService) {
+            this.toDisposeOnKeybindingChange.dispose();
+            for (const binding of this.keybindings.getKeybindingsByScope(KeybindingScope.USER).concat(this.keybindings.getKeybindingsByScope(KeybindingScope.WORKSPACE))) {
+                const resolved = this.keybindings.resolveKeybinding(binding);
+                const command = binding.command;
+                const when = binding.when
+                    ? this.contextKeyService.parse(binding.when)
+                    : binding.context
+                        ? this.contextKeyService.parse(binding.context)
+                        : undefined;
+                this.toDisposeOnKeybindingChange.push(monacoKeybindingRegistry.addDynamicKeybinding(
+                    binding.command,
+                    this.toMonacoKeybindingNumber(resolved),
+                    (_, ...args) => this.theiaCommandRegistry.executeCommand(command, ...args),
+                    when,
+                ));
+            }
+        }
+    }
+
+    protected toMonacoKeybindingNumber(codes: KeyCode[]): number {
+        const [firstPart, secondPart] = codes;
+        if (codes.length > 2) {
+            console.warn('Key chords should not consist of more than two parts; got ', codes);
+        }
+        const encodedFirstPart = this.toSingleMonacoKeybindingNumber(firstPart);
+        const encodedSecondPart = secondPart ? this.toSingleMonacoKeybindingNumber(secondPart) << 16 : 0;
+        return monaco.KeyMod.chord(encodedFirstPart, encodedSecondPart);
+    }
+
+    protected toSingleMonacoKeybindingNumber(code: KeyCode): number {
+        const keyCode = code.key?.keyCode !== undefined ? KEY_CODE_MAP[code.key.keyCode] : 0;
+        let encoded = (keyCode >>> 0) & 0x000000FF;
+        if (code.alt) {
+            encoded |= monaco.KeyMod.Alt;
+        }
+        if (code.shift) {
+            encoded |= monaco.KeyMod.Shift;
+        }
+        if (code.ctrl) {
+            encoded |= monaco.KeyMod.WinCtrl;
+        }
+        if (code.meta && isOSX) {
+            encoded |= monaco.KeyMod.CtrlCmd;
+        }
+        return encoded;
+    }
+}