@eclipse-glsp/client 2.3.0-next.322 → 2.3.0-next.363

package/src/base/default.module.ts

@@ -18,6 +18,7 @@ import {
     FeatureModule,
     KeyTool,
     LocationPostprocessor,
+    MousePositionTracker,
     MouseTool,
     MoveCommand,
     SetDirtyStateAction,
@@ -25,6 +26,7 @@ import {
     SetModelCommand,
     TYPES,
     bindAsService,
+    bindLazyInjector,
     bindOrRebind,
     configureActionHandler,
     configureCommand,
@@ -32,14 +34,13 @@ import {
 } from '@eclipse-glsp/sprotty';
 import '@vscode/codicons/dist/codicon.css';
 import '../../css/glsp-sprotty.css';
-import { bindContributionProvider } from '../utils/contribution-provider';
 import { GLSPActionDispatcher } from './action-dispatcher';
 import { GLSPActionHandlerRegistry } from './action-handler-registry';
 import { GLSPCommandStack } from './command-stack';
 import { EditorContextService } from './editor-context-service';
-import { FeedbackAwareSetModelCommand } from './feedback';
 import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
-import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher-default';
+import { FeedbackAwareSetModelCommand } from './feedback/set-model-command';
 import { FeedbackAwareUpdateModelCommand } from './feedback/update-model-command';
 import { FocusStateChangedAction } from './focus/focus-state-change-action';
 import { FocusTracker } from './focus/focus-tracker';
@@ -47,10 +48,12 @@ import { DiagramLoader } from './model/diagram-loader';
 import { GLSPModelSource } from './model/glsp-model-source';
 import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model/model-initialization-constraint';
 import { GModelRegistry } from './model/model-registry';
+import { GLSPMousePositionTracker } from './mouse-position-tracker';
 import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
 import { SelectionService } from './selection-service';
 import { EnableDefaultToolsAction, EnableToolsAction } from './tool-manager/tool';
 import { DefaultToolsEnablingKeyListener, ToolManager, ToolManagerActionHandler } from './tool-manager/tool-manager';
+import { GLSPUIExtensionRegistry } from './ui-extension/ui-extension-registry';
 import { GLSPKeyTool } from './view/key-tool';
 import { GLSPMouseTool } from './view/mouse-tool';
 import { GViewRegistry } from './view/view-registry';
@@ -59,65 +62,84 @@ import { GViewRegistry } from './view/view-registry';
  * The default module provides all of GLSP's base functionality and services.
  * It builds on top of sprotty's default module {@link `sprottyDefaultModule`}.
  */
-export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, ...rest) => {
-    // load bindings from sprotty's default module to avoid code duplication
-    sprottyDefaultModule.registry(bind, unbind, isBound, rebind, ...rest);
-    const context = { bind, unbind, isBound, rebind };
-
-    bind(EditorContextService).toSelf().inSingletonScope();
-    bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(ctx => async () => ctx.container.get(EditorContextService));
-
-    configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
-    configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
-
-    bind(FocusTracker).toSelf().inSingletonScope();
-    configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
-
-    // Model update initialization ------------------------------------
-    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
-    configureCommand(context, FeedbackAwareUpdateModelCommand);
-    rebind(SetModelCommand).to(FeedbackAwareSetModelCommand);
-
-    bind(GLSPMouseTool).toSelf().inSingletonScope();
-    bindOrRebind(context, MouseTool).toService(GLSPMouseTool);
-    bind(GLSPKeyTool).toSelf().inSingletonScope();
-    bindOrRebind(context, KeyTool).toService(GLSPKeyTool);
-
-    bindAsService(context, TYPES.MouseListener, SelectionClearingMouseListener);
-
-    bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack).inSingletonScope();
-    bind(GLSPActionDispatcher).toSelf().inSingletonScope();
-    bindOrRebind(context, TYPES.IActionDispatcher).toService(GLSPActionDispatcher);
-
-    bindContributionProvider(bind, TYPES.ActionHandlerRegistration);
-    bindContributionProvider(bind, TYPES.IActionHandlerInitializer);
-    bind(GLSPActionHandlerRegistry).toSelf().inSingletonScope();
-    bindOrRebind(context, ActionHandlerRegistry).toService(GLSPActionHandlerRegistry);
-
-    bindAsService(context, TYPES.ModelSource, GLSPModelSource);
-    bind(DiagramLoader).toSelf().inSingletonScope();
-    bind(ModelInitializationConstraint).to(DefaultModelInitializationConstraint).inSingletonScope();
-
-    // support re-registration of model elements and views
-    bindOrRebind(context, TYPES.SModelRegistry).to(GModelRegistry).inSingletonScope();
-    bindOrRebind(context, TYPES.ViewRegistry).to(GViewRegistry).inSingletonScope();
-
-    bind(SelectionService).toSelf().inSingletonScope();
-
-    // Feedback Support ------------------------------------
-    // Generic re-usable feedback modifying css classes
-    configureCommand(context, ModifyCssFeedbackCommand);
-    // We support using sprotty's MoveCommand as client-side visual feedback
-    configureCommand(context, MoveCommand);
-
-    bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
-    bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
-
-    // Tool manager initialization ------------------------------------
-    bind(TYPES.IToolManager).to(ToolManager).inSingletonScope();
-    bind(DefaultToolsEnablingKeyListener).toSelf().inSingletonScope();
-    bind(TYPES.KeyListener).toService(DefaultToolsEnablingKeyListener);
-    bind(ToolManagerActionHandler).toSelf().inSingletonScope();
-    configureActionHandler(context, EnableDefaultToolsAction.KIND, ToolManagerActionHandler);
-    configureActionHandler(context, EnableToolsAction.KIND, ToolManagerActionHandler);
-});
+export const defaultModule = new FeatureModule(
+    (bind, unbind, isBound, rebind, ...rest) => {
+        // load bindings from sprotty's default module to avoid code duplication
+        sprottyDefaultModule.registry(bind, unbind, isBound, rebind, ...rest);
+        const context = { bind, unbind, isBound, rebind };
+
+        bindLazyInjector(context);
+
+        bind(EditorContextService).toSelf().inSingletonScope();
+        bind(TYPES.IDiagramStartup).toService(EditorContextService);
+        bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
+            ctx => async () => ctx.container.get(EditorContextService)
+        );
+
+        configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
+        configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
+
+        bind(FocusTracker).toSelf().inSingletonScope();
+        configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
+
+        // Model update initialization ------------------------------------
+        bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
+        configureCommand(context, FeedbackAwareUpdateModelCommand);
+        rebind(SetModelCommand).to(FeedbackAwareSetModelCommand);
+
+        bind(GLSPMouseTool).toSelf().inSingletonScope();
+        bindOrRebind(context, MouseTool).toService(GLSPMouseTool);
+        bind(TYPES.IDiagramStartup).toService(GLSPMouseTool);
+        bind(GLSPMousePositionTracker).toSelf().inSingletonScope();
+        bindOrRebind(context, MousePositionTracker).toService(GLSPMousePositionTracker);
+        bind(GLSPKeyTool).toSelf().inSingletonScope();
+        bindOrRebind(context, KeyTool).toService(GLSPKeyTool);
+        bind(TYPES.IDiagramStartup).toService(GLSPKeyTool);
+
+        bindAsService(context, TYPES.MouseListener, SelectionClearingMouseListener);
+        bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack).inSingletonScope();
+        bind(GLSPActionDispatcher).toSelf().inSingletonScope();
+        bind(TYPES.IGModelRootListener).toService(GLSPActionDispatcher);
+        bindOrRebind(context, TYPES.IActionDispatcher).toService(GLSPActionDispatcher);
+
+        bindOrRebind(context, ActionHandlerRegistry).to(GLSPActionHandlerRegistry).inSingletonScope();
+
+        bindAsService(context, TYPES.ModelSource, GLSPModelSource);
+        bind(DiagramLoader).toSelf().inSingletonScope();
+        bind(ModelInitializationConstraint).to(DefaultModelInitializationConstraint).inSingletonScope();
+
+        // support re-registration of model elements and views
+        bindOrRebind(context, TYPES.SModelRegistry).to(GModelRegistry).inSingletonScope();
+        bindOrRebind(context, TYPES.ViewRegistry).to(GViewRegistry).inSingletonScope();
+
+        bind(SelectionService).toSelf().inSingletonScope();
+        bind(TYPES.IGModelRootListener).toService(SelectionService);
+        bind(TYPES.IDiagramStartup).toService(SelectionService);
+
+        // Feedback Support ------------------------------------
+        // Generic re-usable feedback modifying css classes
+        configureCommand(context, ModifyCssFeedbackCommand);
+        // We support using sprotty's MoveCommand as client-side visual feedback
+        configureCommand(context, MoveCommand);
+
+        bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
+        bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
+
+        // Tool manager initialization ------------------------------------
+        bind(TYPES.IToolManager).to(ToolManager).inSingletonScope();
+        bind(TYPES.IDiagramStartup).toService(TYPES.IToolManager);
+        bind(TYPES.IEditModeListener).toService(TYPES.IToolManager);
+        bind(DefaultToolsEnablingKeyListener).toSelf().inSingletonScope();
+        bind(TYPES.KeyListener).toService(DefaultToolsEnablingKeyListener);
+        bind(ToolManagerActionHandler).toSelf().inSingletonScope();
+        configureActionHandler(context, EnableDefaultToolsAction.KIND, ToolManagerActionHandler);
+        configureActionHandler(context, EnableToolsAction.KIND, ToolManagerActionHandler);
+
+        bind(GLSPUIExtensionRegistry).toSelf().inSingletonScope();
+        bindOrRebind(context, TYPES.UIExtensionRegistry).toService(GLSPUIExtensionRegistry);
+        bind(TYPES.IDiagramStartup).toService(GLSPUIExtensionRegistry);
+    },
+    {
+        featureId: Symbol('default')
+    }
+);

package/src/base/drag-aware-mouse-listener.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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, MouseListener, GModelElement } from '@eclipse-glsp/sprotty';
+import { Action, Disposable, GModelElement, MouseListener, Point } from '@eclipse-glsp/sprotty';
 
 /**
  * A mouse listener that is aware of prior mouse dragging.
@@ -23,24 +23,49 @@ import { Action, MouseListener, GModelElement } from '@eclipse-glsp/sprotty';
  * `draggingMouseUp` and/or `nonDraggingMouseUp` to react to only these specific kinds
  * of mouse up events.
  */
-export class DragAwareMouseListener extends MouseListener {
+export class DragAwareMouseListener extends MouseListener implements Disposable {
     protected _isMouseDown = false;
     protected _isMouseDrag = false;
 
+    protected _dragStart?: Point;
+    protected _dragSensitivity = 0;
+
+    constructor(dragSensitivity = 0) {
+        super();
+        this._dragSensitivity = dragSensitivity;
+    }
+
     override mouseDown(target: GModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = true;
+        this._dragStart = this._dragSensitivity > 0 ? { x: event.clientX, y: event.clientY } : undefined;
         return [];
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
         if (this._isMouseDown) {
+            if (this._dragStart) {
+                const dragDistance = Point.maxDistance(this._dragStart, { x: event.clientX, y: event.clientY });
+                if (dragDistance < this._dragSensitivity) {
+                    return this.nonDraggingMouseMove(target, event);
+                }
+            }
             this._isMouseDrag = true;
+            return this.draggingMouseMove(target, event);
         }
+        return this.nonDraggingMouseMove(target, event);
+    }
+
+    protected draggingMouseMove(target: GModelElement, event: MouseEvent): Action[] {
+        return [];
+    }
+
+    protected nonDraggingMouseMove(target: GModelElement, event: MouseEvent): Action[] {
         return [];
     }
 
     override mouseUp(element: GModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = false;
+        this._dragStart = undefined;
         if (this._isMouseDrag) {
             this._isMouseDrag = false;
             return this.draggingMouseUp(element, event);
@@ -64,4 +89,9 @@ export class DragAwareMouseListener extends MouseListener {
     get isMouseDown(): boolean {
         return this._isMouseDown;
     }
+
+    dispose(): void {
+        this._isMouseDrag = false;
+        this._isMouseDown = false;
+    }
 }

package/src/base/editor-context-service.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2023 EclipseSource and others.
+ * Copyright (c) 2020-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,30 +13,50 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
 import {
     Action,
+    AnyObject,
     Args,
+    CommandStack,
     Disposable,
     DisposableCollection,
     EditMode,
     EditorContext,
     Emitter,
     Event,
+    GModelElement,
+    GModelRoot,
     IActionHandler,
+    LazyInjector,
     MaybePromise,
     MousePositionTracker,
-    GModelElement,
-    GModelRoot,
     SetDirtyStateAction,
     SetEditModeAction,
     TYPES,
     ValueChange
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable, postConstruct, preDestroy } from 'inversify';
 import { GLSPActionDispatcher } from './action-dispatcher';
 import { IDiagramOptions, IDiagramStartup } from './model/diagram-loader';
 import { SelectionService } from './selection-service';
 
+/**
+ * A hook to listen for model root changes. Will be called after a server update
+ * has been processed
+ */
+export interface IGModelRootListener {
+    modelRootChanged(root: Readonly<GModelRoot>): void;
+}
+
+/**
+ * @deprecated Use {@link IGModelRootListener} instead
+ */
+export type ISModelRootListener = IGModelRootListener;
+
+/**
+ * A hook to listen for edit mode changes. Will be after the {@link EditorContextService}
+ * has handled the {@link SetEditModeAction}.
+ */
 export interface IEditModeListener {
     editModeChanged(newValue: string, oldValue: string): void;
 }
@@ -62,13 +82,12 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
     @inject(MousePositionTracker)
     protected mousePositionTracker: MousePositionTracker;
 
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
     @inject(TYPES.IDiagramOptions)
     protected diagramOptions: IDiagramOptions;
 
-    @multiInject(TYPES.IEditModeListener)
-    @optional()
-    protected editModeListeners: IEditModeListener[] = [];
-
     @inject(GLSPActionDispatcher)
     protected actionDispatcher: GLSPActionDispatcher;
 
@@ -84,15 +103,27 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
         return this.onDirtyStateChangedEmitter.event;
     }
 
+    protected _modelRoot?: Readonly<GModelRoot>;
+    protected onModelRootChangedEmitter = new Emitter<Readonly<GModelRoot>>();
+    get onModelRootChanged(): Event<Readonly<GModelRoot>> {
+        return this.onModelRootChangedEmitter.event;
+    }
+
     protected toDispose = new DisposableCollection();
 
     @postConstruct()
     protected initialize(): void {
         this._editMode = this.diagramOptions.editMode ?? EditMode.EDITABLE;
         this.toDispose.push(this.onEditModeChangedEmitter, this.onDirtyStateChangedEmitter);
-        this.editModeListeners.forEach(listener =>
-            this.onEditModeChanged(change => listener.editModeChanged(change.newValue, change.oldValue))
-        );
+    }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<IGModelRootListener>(TYPES.IGModelRootListener).forEach(listener => {
+            this.onModelRootChanged(event => listener.modelRootChanged(event));
+        });
+        this.lazyInjector.getAll<IEditModeListener>(TYPES.IEditModeListener).forEach(listener => {
+            this.onEditModeChanged(event => listener.editModeChanged(event.newValue, event.oldValue));
+        });
     }
 
     @preDestroy()
@@ -116,6 +147,21 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
         };
     }
 
+    /**
+     * Notifies the service about a model root change. This method should not be called
+     * directly. It is called by the `CommandStack` after a model update has been processed.
+     * @throws an error if the notifier is not a `CommandStack`
+     * @param root the new model root
+     * @param notifier the object that triggered the model root change
+     */
+    notifyModelRootChanged(root: Readonly<GModelRoot>, notifier: AnyObject): void {
+        if (!(notifier instanceof CommandStack)) {
+            throw new Error('Invalid model root change notification. Notifier is not an instance of `CommandStack`.');
+        }
+        this._modelRoot = root;
+        this.onModelRootChangedEmitter.fire(root);
+    }
+
     handle(action: Action): void {
         if (SetEditModeAction.is(action)) {
             this.handleSetEditModeAction(action);
@@ -154,7 +200,10 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
     }
 
     get modelRoot(): Readonly<GModelRoot> {
-        return this.selectionService.getModelRoot();
+        if (!this._modelRoot) {
+            throw new Error('Model root not available yet');
+        }
+        return this._modelRoot;
     }
 
     get selectedElements(): Readonly<GModelElement>[] {
@@ -168,10 +217,6 @@ export class EditorContextService implements IActionHandler, Disposable, IDiagra
     get isDirty(): boolean {
         return this._isDirty;
     }
-
-    postRequestModel(): MaybePromise<void> {
-        this.actionDispatcher.dispatch(SetEditModeAction.create(this.editMode));
-    }
 }
 
 export type EditorContextServiceProvider = () => Promise<EditorContextService>;

package/src/base/feedback/css-feedback.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
@@ -84,11 +84,19 @@ export enum CursorCSS {
     ELEMENT_DELETION = 'element-deletion-mode',
     RESIZE_NESW = 'resize-nesw-mode',
     RESIZE_NWSE = 'resize-nwse-mode',
+    RESIZE_NW = 'resize-nw-mode',
+    RESIZE_N = 'resize-n-mode',
+    RESIZE_NE = 'resize-ne-mode',
+    RESIZE_E = 'resize-e-mode',
+    RESIZE_SE = 'resize-se-mode',
+    RESIZE_S = 'resize-s-mode',
+    RESIZE_SW = 'resize-sw-mode',
+    RESIZE_W = 'resize-w-mode',
     MOVE = 'move-mode',
     MARQUEE = 'marquee-mode'
 }
 
-export function cursorFeedbackAction(cursorCss?: CursorCSS): ModifyCSSFeedbackAction {
+export function cursorFeedbackAction(cursorCss?: string): ModifyCSSFeedbackAction {
     const add = [];
     if (cursorCss) {
         add.push(cursorCss);
@@ -103,3 +111,7 @@ export function applyCssClasses(element: GModelElement, ...add: string[]): Modif
 export function deleteCssClasses(element: GModelElement, ...remove: string[]): ModifyCSSFeedbackAction {
     return ModifyCSSFeedbackAction.create({ elements: [element], remove });
 }
+
+export function toggleCssClasses(element: GModelElement, add: boolean, ...cssClasses: string[]): ModifyCSSFeedbackAction {
+    return add ? applyCssClasses(element, ...cssClasses) : deleteCssClasses(element, ...cssClasses);
+}

package/src/base/feedback/feedback-action-dispatcher-default.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * 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
+ * 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 {
+    Action,
+    ActionHandlerRegistry,
+    Command,
+    CommandActionHandler,
+    CommandExecutionContext,
+    Disposable,
+    GModelElement,
+    IActionDispatcher,
+    ICommand,
+    ILogger,
+    TYPES,
+    toTypeGuard
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { getFeedbackRank } from './feedback-command';
+import { FeedbackEmitter } from './feedback-emitter';
+import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from './feedback-action-dispatcher';
+
+@injectable()
+export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
+    protected registeredFeedback: Map<IFeedbackEmitter, Action[]> = new Map();
+
+    @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
+    @inject(TYPES.ILogger) protected logger: ILogger;
+
+    @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
+
+    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 {
+            const actionDispatcher = await this.actionDispatcher();
+            await actionDispatcher.dispatchAll(actions);
+            this.logger.info(this, `Dispatched feedback actions for ${feedbackEmitter}`);
+        } catch (reason) {
+            this.logger.error(this, 'Failed to dispatch feedback actions', reason);
+        }
+    }
+}