Various minor improvements

- Merge *-default.ts implementation files of `FeedbackActionDispatcher` and `HelperLineManager` with the
  the interface definition files. The split is no longer necessary since we resolved potential circular dependency issues
- Ensure that we consistently use the `LazyInjector` over dedicated async providers and deprecate existing provider injection
- Fix a bug in the `FocusTracker` where we could end up in an invalid state on startup (diagram active but .diagramElement is undefined). This mostly occurred in standalone contexts (Diagram element is root => no focus change => handle gets never invoked)

packages/client/src/base/default.module.ts

@@ -39,7 +39,7 @@ import { GLSPActionHandlerRegistry } from './action-handler-registry';
 import { GLSPCommandStack } from './command-stack';
 import { EditorContextService } from './editor-context-service';
 import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
-import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher-default';
+import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
 import { FeedbackAwareSetModelCommand } from './feedback/set-model-command';
 import { FeedbackAwareUpdateModelCommand } from './feedback/update-model-command';
 import { FocusStateChangedAction } from './focus/focus-state-change-action';
@@ -72,6 +72,7 @@ export const defaultModule = new FeatureModule(
 
         bind(EditorContextService).toSelf().inSingletonScope();
         bind(TYPES.IDiagramStartup).toService(EditorContextService);
+        // eslint-disable-next-line deprecation/deprecation
         bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
             ctx => async () => ctx.container.get(EditorContextService)
         );
@@ -80,6 +81,7 @@ export const defaultModule = new FeatureModule(
         configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
 
         bind(FocusTracker).toSelf().inSingletonScope();
+        bind(TYPES.IDiagramStartup).toService(FocusTracker);
         configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
 
         // Model update initialization ------------------------------------

packages/client/src/base/feedback/feedback-action-dispatcher.ts

@@ -13,7 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Command, CommandExecutionContext, Disposable, MaybeFunction, call, asArray as toArray } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    ActionHandlerRegistry,
+    Command,
+    CommandActionHandler,
+    CommandExecutionContext,
+    Disposable,
+    GModelElement,
+    IActionDispatcher,
+    ICommand,
+    ILogger,
+    MaybeFunction,
+    TYPES,
+    call,
+    asArray as toArray,
+    toTypeGuard
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, preDestroy } from 'inversify';
+import { getFeedbackRank } from './feedback-command';
 import { FeedbackEmitter } from './feedback-emitter';
 
 export interface IFeedbackEmitter {}
@@ -86,3 +104,100 @@ export interface IFeedbackActionDispatcher {
      */
     createEmitter(): FeedbackEmitter;
 }
+
+@injectable()
+export class FeedbackActionDispatcher implements IFeedbackActionDispatcher, Disposable {
+    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
+
+    @inject(TYPES.ILogger) protected logger: ILogger;
+
+    @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
+
+    protected isDisposed = false;
+
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: MaybeActions): Disposable {
+        if (feedbackEmitter instanceof GModelElement) {
+            this.logger.log(
+                this,
+                // eslint-disable-next-line max-len
+                'GModelElements as feedback emitters are discouraged, as they usually change between model updates and are considered unstable.'
+            );
+        }
+        if (feedbackActions.length > 0) {
+            this.registeredFeedback.set(feedbackEmitter, feedbackActions);
+            this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        }
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
+    }
+
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: MaybeActions): void {
+        this.registeredFeedback.delete(feedbackEmitter);
+        const actions = MaybeActions.asArray(cleanupActions);
+        if (actions.length > 0) {
+            this.dispatchFeedback(actions, feedbackEmitter);
+        }
+    }
+
+    getRegisteredFeedback(): Action[] {
+        const result: Action[] = [];
+        this.registeredFeedback.forEach(actions => result.push(...actions));
+        return result;
+    }
+
+    getRegisteredFeedbackEmitters(action: Action): IFeedbackEmitter[] {
+        const result: IFeedbackEmitter[] = [];
+        this.registeredFeedback.forEach((actions, emitter) => {
+            if (actions.includes(action)) {
+                result.push(emitter);
+            }
+        });
+        return result;
+    }
+
+    getFeedbackCommands(): Command[] {
+        return this.getRegisteredFeedback()
+            .flatMap(action => this.actionToCommands(action))
+            .sort((left, right) => getFeedbackRank(left) - getFeedbackRank(right));
+    }
+
+    async applyFeedbackCommands(context: CommandExecutionContext): Promise<void> {
+        const feedbackCommands = this.getFeedbackCommands() ?? [];
+        if (feedbackCommands?.length > 0) {
+            const results = feedbackCommands.map(command => command.execute(context));
+            await Promise.all(results);
+        }
+    }
+
+    protected actionToCommands(action: Action): ICommand[] {
+        return (
+            this.actionHandlerRegistry
+                .get(action.kind)
+                .filter(toTypeGuard(CommandActionHandler))
+                .map(handler => handler.handle(action)) ?? []
+        );
+    }
+
+    createEmitter(): FeedbackEmitter {
+        return new FeedbackEmitter(this);
+    }
+
+    protected async dispatchFeedback(actions: Action[], feedbackEmitter: IFeedbackEmitter): Promise<void> {
+        try {
+            if (this.isDisposed) {
+                return;
+            }
+            await this.actionDispatcher.dispatchAll(actions);
+            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
+        } catch (reason) {
+            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
+        }
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.registeredFeedback.clear();
+        this.isDisposed = true;
+    }
+}

packages/client/src/base/focus/focus-tracker.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Emitter, Event, IActionHandler, ICommand, TYPES, ViewerOptions } from '@eclipse-glsp/sprotty';
+import { Action, Emitter, Event, IActionHandler, ICommand, MaybePromise, TYPES, ViewerOptions } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import { IDiagramStartup } from '../model/diagram-loader';
 import { FocusStateChangedAction } from './focus-state-change-action';
 
 export interface FocusChange {
@@ -29,7 +30,7 @@ export interface FocusChange {
  * Allows querying of the current focus state and the focused root diagram element and the currently focused element within the diagram.
  */
 @injectable()
-export class FocusTracker implements IActionHandler {
+export class FocusTracker implements IActionHandler, IDiagramStartup {
     protected inActiveCssClass = 'inactive';
     protected _hasFocus = true;
     protected _focusElement: HTMLOrSVGElement | null;
@@ -57,12 +58,20 @@ export class FocusTracker implements IActionHandler {
         return this._diagramElement;
     }
 
+    postModelInitialization(): MaybePromise<void> {
+        this.handleFocusChange();
+    }
+
     handle(action: Action): void | Action | ICommand {
         if (!FocusStateChangedAction.is(action)) {
             return;
         }
 
         this._hasFocus = action.hasFocus;
+        this.handleFocusChange();
+    }
+
+    protected handleFocusChange(): void {
         this._focusElement = document.activeElement as HTMLOrSVGElement | null;
         this._diagramElement = document.getElementById(this.options.baseDiv);
         if (!this._diagramElement) {

packages/client/src/features/context-menu/delete-element-context-menu.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2023 EclipseSource and others.
+ * Copyright (c) 2019-2024 EclipseSource 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
@@ -13,27 +13,31 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { DeleteElementOperation, GModelRoot, IContextMenuItemProvider, MenuItem, Point, TYPES } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { DeleteElementOperation, IContextMenuItemProvider, MenuItem, Point, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
 import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
 
 @injectable()
 export class DeleteElementContextMenuItemProvider implements IContextMenuItemProvider {
+    /** @deprecated No longer used. The {@link EditorContextService} is now directly injected.*/
+    // eslint-disable-next-line deprecation/deprecation
     @inject(TYPES.IEditorContextServiceProvider) editorContextServiceProvider: EditorContextServiceProvider;
 
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
     async getItems(_root: Readonly<GModelRoot>, _lastMousePosition?: Point): Promise<MenuItem[]> {
-        const editorContextService = await this.editorContextServiceProvider();
-        return [this.createDeleteMenuItem(editorContextService)];
+        return [this.createDeleteMenuItem()];
     }
 
-    protected createDeleteMenuItem(editorContextService: EditorContextService): MenuItem {
+    protected createDeleteMenuItem(): MenuItem {
         return {
             id: 'delete',
             label: 'Delete',
             sortString: 'd',
             group: 'edit',
-            actions: [DeleteElementOperation.create(editorContextService.selectedElements.map(e => e.id))],
-            isEnabled: () => !editorContextService.isReadonly && editorContextService.selectedElements.length > 0
+            actions: [DeleteElementOperation.create(this.editorContext.selectedElements.map(e => e.id))],
+            isEnabled: () => !this.editorContext.isReadonly && this.editorContext.selectedElements.length > 0
         };
     }
 }