@theia/core 1.28.0-next.9 → 1.28.0

package/src/browser/widget-manager.ts

@@ -17,6 +17,7 @@
 import { inject, named, injectable } from 'inversify';
 import { Widget } from '@phosphor/widgets';
 import { ILogger, Emitter, Event, ContributionProvider, MaybePromise, WaitUntilEvent } from '../common';
+import stableJsonStringify = require('fast-json-stable-stringify');
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 export const WidgetFactory = Symbol('WidgetFactory');
@@ -256,7 +257,7 @@ export class WidgetManager {
      * @returns the widget construction options represented as a string.
      */
     protected toKey(options: WidgetConstructionOptions): string {
-        return JSON.stringify(options);
+        return stableJsonStringify(options);
     }
 
     /**

package/src/browser/window/default-window-service.ts

@@ -22,6 +22,7 @@ import { FrontendApplicationContribution, FrontendApplication, OnWillStopAction
 import { WindowService } from './window-service';
 import { DEFAULT_WINDOW_HASH } from '../../common/window';
 import { confirmExit } from '../dialogs';
+import { StopReason } from '../../common/frontend-application-state';
 
 @injectable()
 export class DefaultWindowService implements WindowService, FrontendApplicationContribution {
@@ -97,16 +98,16 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         window.addEventListener('unload', () => this.onUnloadEmitter.fire());
     }
 
-    async isSafeToShutDown(): Promise<boolean> {
+    async isSafeToShutDown(stopReason: StopReason): Promise<boolean> {
         const vetoes = this.collectContributionUnloadVetoes();
         if (vetoes.length === 0) {
             return true;
         }
-        const preparedValues = await Promise.all(vetoes.map(e => e.prepare?.()));
+        const preparedValues = await Promise.all(vetoes.map(e => e.prepare?.(stopReason)));
         console.debug('Shutdown prevented by', vetoes.map(({ reason }) => reason).join(', '));
         for (let i = 0; i < vetoes.length; i++) {
             try {
-                const result = await vetoes[i].action(preparedValues[i]);
+                const result = await vetoes[i].action(preparedValues[i], stopReason);
                 if (!result) {
                     return false;
                 }
@@ -156,6 +157,10 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
     }
 
     reload(): void {
-        window.location.reload();
+        this.isSafeToShutDown(StopReason.Reload).then(isSafe => {
+            if (isSafe) {
+                window.location.reload();
+            }
+        });
     }
 }

package/src/browser/window/window-service.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { StopReason } from '../../common/frontend-application-state';
 import { Event } from '../../common/event';
 import { NewWindowOptions } from '../../common/window';
 
@@ -49,7 +50,7 @@ export interface WindowService {
      * will not be called again in the current session. I.e. if this return `true`, the shutdown should proceed without
      * further condition.
      */
-    isSafeToShutDown(): Promise<boolean>;
+    isSafeToShutDown(reason: StopReason): Promise<boolean>;
 
     /**
      * Will prevent subsequent checks of `FrontendApplicationContribution#willStop`. Should only be used after requesting

package/src/common/color.ts

@@ -85,7 +85,10 @@ export interface HSLA {
 export interface ColorDefaults {
     light?: Color
     dark?: Color
+    /** @deprecated @since 1.28.0 Please use hcDark and hcLight. This field will be ignored unless `hcDark` is absent. */
     hc?: Color
+    hcDark?: Color;
+    hcLight?: Color;
 }
 
 export interface ColorDefinition {

package/src/common/frontend-application-state.ts

@@ -21,3 +21,18 @@ export type FrontendApplicationState =
     | 'initialized_layout'
     | 'ready'
     | 'closing_window';
+
+export enum StopReason {
+    /**
+     * Closing the window with no prospect of restart.
+     */
+    Close,
+    /**
+     * Reload without closing the window.
+     */
+    Reload,
+    /**
+     * Reload that includes closing the window.
+     */
+    Restart,
+}

package/src/common/menu/action-menu-node.ts

@@ -0,0 +1,65 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { CommandRegistry } from '../command';
+import { AlternativeHandlerMenuNode, CommandMenuNode, MenuAction, MenuNode } from './menu-types';
+
+/**
+ * Node representing an action in the menu tree structure.
+ * It's based on {@link MenuAction} for which it tries to determine the
+ * best label, icon and sortString with the given data.
+ */
+export class ActionMenuNode implements MenuNode, CommandMenuNode, Partial<AlternativeHandlerMenuNode> {
+
+    readonly altNode: ActionMenuNode | undefined;
+
+    constructor(
+        protected readonly action: MenuAction,
+        protected readonly commands: CommandRegistry,
+    ) {
+        if (action.alt) {
+            this.altNode = new ActionMenuNode({ commandId: action.alt }, commands);
+        }
+    }
+
+    get command(): string { return this.action.commandId; };
+
+    get when(): string | undefined { return this.action.when; }
+
+    get id(): string { return this.action.commandId; }
+
+    get label(): string {
+        if (this.action.label) {
+            return this.action.label;
+        }
+        const cmd = this.commands.getCommand(this.action.commandId);
+        if (!cmd) {
+            console.debug(`No label for action menu node: No command "${this.action.commandId}" exists.`);
+            return '';
+        }
+        return cmd.label || cmd.id;
+    }
+
+    get icon(): string | undefined {
+        if (this.action.icon) {
+            return this.action.icon;
+        }
+        const command = this.commands.getCommand(this.action.commandId);
+        return command && command.iconClass;
+    }
+
+    get sortString(): string { return this.action.order || this.label; }
+}

package/src/common/menu/composite-menu-node.ts

@@ -0,0 +1,121 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Disposable } from '../disposable';
+import { CompoundMenuNode, CompoundMenuNodeMetadata, CompoundMenuNodeRole, MenuNode, SubMenuOptions } from './menu-types';
+
+/**
+ * Node representing a (sub)menu in the menu tree structure.
+ */
+export class CompositeMenuNode implements MenuNode, CompoundMenuNode, CompoundMenuNodeMetadata {
+    protected readonly _children: MenuNode[] = [];
+    public iconClass?: string;
+    public order?: string;
+    readonly when?: string;
+    readonly _role?: CompoundMenuNodeRole;
+
+    constructor(
+        public readonly id: string,
+        public label?: string,
+        options?: SubMenuOptions,
+        readonly parent?: MenuNode & CompoundMenuNode,
+    ) {
+        if (options) {
+            this.iconClass = options.iconClass;
+            this.order = options.order;
+            this.when = options.when;
+            this._role = options?.role;
+        }
+    }
+
+    get icon(): string | undefined {
+        return this.iconClass;
+    }
+
+    get children(): ReadonlyArray<MenuNode> {
+        return this._children;
+    }
+
+    get role(): CompoundMenuNodeRole { return this._role ?? (this.label ? CompoundMenuNodeRole.Submenu : CompoundMenuNodeRole.Group); }
+
+    /**
+     * Inserts the given node at the position indicated by `sortString`.
+     *
+     * @returns a disposable which, when called, will remove the given node again.
+     */
+    public addNode(node: MenuNode): Disposable {
+        this._children.push(node);
+        this._children.sort(CompoundMenuNode.sortChildren);
+        return {
+            dispose: () => {
+                const idx = this._children.indexOf(node);
+                if (idx >= 0) {
+                    this._children.splice(idx, 1);
+                }
+            }
+        };
+    }
+
+    /**
+     * Removes the first node with the given id.
+     *
+     * @param id node id.
+     */
+    public removeNode(id: string): void {
+        const node = this._children.find(n => n.id === id);
+        if (node) {
+            const idx = this._children.indexOf(node);
+            if (idx >= 0) {
+                this._children.splice(idx, 1);
+            }
+        }
+    }
+
+    get sortString(): string {
+        return this.order || this.id;
+    }
+
+    get isSubmenu(): boolean {
+        return Boolean(this.label);
+    }
+
+    /** @deprecated @since 1.28 use CompoundMenuNode.isNavigationGroup instead */
+    static isNavigationGroup = CompoundMenuNode.isNavigationGroup;
+}
+
+export class CompositeMenuNodeWrapper implements MenuNode, CompoundMenuNodeMetadata {
+    constructor(protected readonly wrapped: Readonly<CompositeMenuNode>, readonly parent: MenuNode & CompoundMenuNode, protected readonly options?: SubMenuOptions) { }
+
+    get id(): string { return this.wrapped.id; }
+
+    get label(): string | undefined { return this.wrapped.label; }
+
+    get sortString(): string { return this.order || this.id; }
+
+    get isSubmenu(): boolean { return Boolean(this.label); }
+
+    get role(): CompoundMenuNodeRole { return this.options?.role ?? this.wrapped.role; }
+
+    get icon(): string | undefined { return this.iconClass; }
+
+    get iconClass(): string | undefined { return this.options?.iconClass ?? this.wrapped.iconClass; }
+
+    get order(): string | undefined { return this.options?.order ?? this.wrapped.order; }
+
+    get when(): string | undefined { return this.options?.when ?? this.wrapped.when; }
+
+    get children(): ReadonlyArray<MenuNode> { return this.wrapped.children; }
+}

package/src/common/menu/index.ts

@@ -0,0 +1,21 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+export * from './action-menu-node';
+export * from './composite-menu-node';
+export * from './menu-adapter';
+export * from './menu-model-registry';
+export * from './menu-types';

package/src/common/menu/menu-adapter.ts

@@ -0,0 +1,103 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { inject, injectable } from 'inversify';
+import { CommandRegistry } from '../command';
+import { Disposable } from '../disposable';
+import { MenuPath } from './menu-types';
+
+export type MenuCommandArguments = [menuPath: MenuPath, command: string, ...commandArgs: unknown[]];
+
+export const MenuCommandExecutor = Symbol('MenuCommandExecutor');
+export interface MenuCommandExecutor {
+    isVisible(...args: MenuCommandArguments): boolean;
+    isEnabled(...args: MenuCommandArguments): boolean;
+    isToggled(...args: MenuCommandArguments): boolean;
+    executeCommand(...args: MenuCommandArguments): Promise<unknown>;
+};
+
+export const MenuCommandAdapter = Symbol('MenuCommandAdapter');
+export interface MenuCommandAdapter extends MenuCommandExecutor {
+    /** Return values less than or equal to 0 are treated as rejections. */
+    canHandle(...args: MenuCommandArguments): number;
+}
+
+export const MenuCommandAdapterRegistry = Symbol('MenuCommandAdapterRegistry');
+export interface MenuCommandAdapterRegistry {
+    registerAdapter(adapter: MenuCommandAdapter): Disposable;
+    getAdapterFor(...args: MenuCommandArguments): MenuCommandAdapter | undefined;
+}
+
+@injectable()
+export class MenuCommandExecutorImpl implements MenuCommandExecutor {
+    @inject(MenuCommandAdapterRegistry) protected readonly adapterRegistry: MenuCommandAdapterRegistry;
+    @inject(CommandRegistry) protected readonly commandRegistry: CommandRegistry;
+
+    executeCommand(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): Promise<unknown> {
+        return this.delegate(menuPath, command, commandArgs, 'executeCommand');
+    }
+
+    isVisible(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        return this.delegate(menuPath, command, commandArgs, 'isVisible');
+    }
+
+    isEnabled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        return this.delegate(menuPath, command, commandArgs, 'isEnabled');
+    }
+
+    isToggled(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): boolean {
+        return this.delegate(menuPath, command, commandArgs, 'isToggled');
+    }
+
+    protected delegate<T extends keyof MenuCommandExecutor>(menuPath: MenuPath, command: string, commandArgs: unknown[], method: T): ReturnType<MenuCommandExecutor[T]> {
+        const adapter = this.adapterRegistry.getAdapterFor(menuPath, command, commandArgs);
+        return (adapter
+            ? adapter[method](menuPath, command, ...commandArgs)
+            : this.commandRegistry[method](command, ...commandArgs)) as ReturnType<MenuCommandExecutor[T]>;
+    }
+}
+
+@injectable()
+export class MenuCommandAdapterRegistryImpl implements MenuCommandAdapterRegistry {
+    protected readonly adapters = new Array<MenuCommandAdapter>();
+
+    registerAdapter(adapter: MenuCommandAdapter): Disposable {
+        if (!this.adapters.includes(adapter)) {
+            this.adapters.push(adapter);
+            return Disposable.create(() => {
+                const index = this.adapters.indexOf(adapter);
+                if (index !== -1) {
+                    this.adapters.splice(index, 1);
+                }
+            });
+        }
+        return Disposable.NULL;
+    }
+
+    getAdapterFor(menuPath: MenuPath, command: string, ...commandArgs: unknown[]): MenuCommandAdapter | undefined {
+        let bestAdapter: MenuCommandAdapter | undefined = undefined;
+        let bestScore = 0;
+        let currentScore = 0;
+        for (const adapter of this.adapters) {
+            // Greater than or equal: favor later registrations over earlier.
+            if ((currentScore = adapter.canHandle(menuPath, command, ...commandArgs)) >= bestScore) {
+                bestScore = currentScore;
+                bestAdapter = adapter;
+            }
+        }
+        return bestAdapter;
+    }
+}