@eclipse-glsp/client 2.1.1 → 2.2.0-next.326

package/src/base/model/diagram-loader.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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
@@ -21,6 +21,7 @@ import {
     EMPTY_ROOT,
     GLSPClient,
     InitializeParameters,
+    LazyInjector,
     MaybePromise,
     RequestModelAction,
     SetModelAction,
@@ -28,7 +29,7 @@ import {
     TYPES,
     hasNumberProp
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
+import { inject, injectable } from 'inversify';
 import { GLSPActionDispatcher } from '../action-dispatcher';
 import { Ranked } from '../ranked';
 import { GLSPModelSource } from './glsp-model-source';
@@ -69,22 +70,27 @@ export interface IDiagramOptions {
  */
 export interface IDiagramStartup extends Partial<Ranked> {
     /**
-     * Hook for services that should be executed before the underlying GLSP client is configured and the server is initialized.
+     * Hook for services that want to execute code before the diagram loading routine is started. This is the
+     * first hook that is invoked directly after {@link DiagramLoader.load} is called.
+     */
+    preLoadDiagram?(): MaybePromise<void>;
+    /**
+     * Hook for services that want to execute code before the underlying GLSP client is configured and the server is initialized.
      */
     preInitialize?(): MaybePromise<void>;
     /**
-     * Hook for services that should be executed before the initial model loading request (i.e. `RequestModelAction`) but
+     * Hook for services that want to execute code before the initial model loading request (i.e. `RequestModelAction`) but
      * after the underlying GLSP client has been configured and the server is initialized.
      */
     preRequestModel?(): MaybePromise<void>;
     /**
-     * Hook for services that should be executed after the initial model loading request (i.e. `RequestModelAction`).
+     * Hook for services that want to execute code after the initial model loading request (i.e. `RequestModelAction`).
      * Note that this hook is invoked directly after the `RequestModelAction` has been dispatched. It does not necessarily wait
      * until the client-server update roundtrip is completed. If you need to wait until the diagram is fully initialized use the
      * {@link postModelInitialization} hook.
      */
     postRequestModel?(): MaybePromise<void>;
-    /* Hook for services that should be executed after the diagram model is fully initialized
+    /* Hook for services that want to execute code after the diagram model is fully initialized
      * (i.e. `ModelInitializationConstraint` is completed).
      */
     postModelInitialization?(): MaybePromise<void>;
@@ -95,7 +101,8 @@ export namespace IDiagramStartup {
         return (
             AnyObject.is(object) &&
             hasNumberProp(object, 'rank', true) &&
-            ('preInitialize' in object ||
+            ('preLoadDiagram' in object ||
+                'preInitialize' in object ||
                 'preRequestModel' in object ||
                 'postRequestModel' in object ||
                 'postModelInitialization' in object)
@@ -144,22 +151,22 @@ export class DiagramLoader {
     @inject(GLSPActionDispatcher)
     protected actionDispatcher: GLSPActionDispatcher;
 
-    @multiInject(TYPES.IDiagramStartup)
-    @optional()
-    protected diagramStartups: IDiagramStartup[] = [];
-
     @inject(GLSPModelSource)
     protected modelSource: GLSPModelSource;
 
     @inject(ModelInitializationConstraint)
     protected modelInitializationConstraint: ModelInitializationConstraint;
 
-    @postConstruct()
-    protected postConstruct(): void {
-        this.diagramStartups.sort((a, b) => Ranked.getRank(a) - Ranked.getRank(b));
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    get diagramStartups(): IDiagramStartup[] {
+        return this.lazyInjector.getAll<IDiagramStartup>(TYPES.IDiagramStartup);
     }
 
     async load(options: DiagramLoadingOptions = {}): Promise<void> {
+        this.diagramStartups.sort(Ranked.sort);
+        await this.invokeStartupHook('preLoadDiagram');
         const resolvedOptions: ResolvedDiagramLoadingOptions = {
             requestModelOptions: {
                 sourceUri: this.options.sourceUri ?? '',

package/src/base/model/glsp-model-source.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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

package/src/base/ranked.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
@@ -21,11 +21,16 @@ import { AnyObject, hasNumberProp } from '@eclipse-glsp/sprotty';
  * orderable by a type or rank/priority.
  */
 export interface Ranked {
+    /**
+     * A rank implies the position of this element within a sequence of other ranked elements.
+     * A lower rank implies a position earlier in the list.
+     */
     rank: number;
 }
 
 export namespace Ranked {
     export const DEFAULT_RANK = 0;
+
     export function is(object: unknown): object is Ranked {
         return AnyObject.is(object) && hasNumberProp(object, 'rank');
     }
@@ -39,4 +44,13 @@ export namespace Ranked {
     export function getRank(object: unknown): number {
         return is(object) ? object.rank : DEFAULT_RANK;
     }
+
+    /** Sort function for lowest rank first. */
+    export const sortAsc = (left: unknown, right: unknown): number => getRank(left) - getRank(right);
+
+    /** Sort function for highest rank first. */
+    export const sortDesc = (left: unknown, right: unknown): number => getRank(right) - getRank(left);
+
+    /** Default sort function for rank: Lowest rank first */
+    export const sort = sortAsc;
 }

package/src/base/selection-service.spec.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,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Disposable, GModelRoot, GNode, TYPES, initializeContainer } from '@eclipse-glsp/sprotty';
+import { Action, Command, CommandExecutionContext, Disposable, GModelRoot, GNode, TYPES, initializeContainer } from '@eclipse-glsp/sprotty';
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
 import * as sinon from 'sinon';
@@ -44,6 +44,12 @@ class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
         const actions = this.getRegisteredFeedback();
         return actions.length === 1 ? (actions[0] as SelectFeedbackAction) : undefined;
     }
+
+    getFeedbackCommands(): Command[] {
+        return [];
+    }
+
+    async applyFeedbackCommands(context: CommandExecutionContext): Promise<void> {}
 }
 
 class MockSelectionListener implements ISelectionListener {

package/src/base/selection-service.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
@@ -25,6 +25,7 @@ import {
     GModelElement,
     GModelRoot,
     ILogger,
+    LazyInjector,
     SelectAction,
     SelectAllAction,
     Selectable,
@@ -35,10 +36,11 @@ import {
     isSelectable,
     pluck
 } from '@eclipse-glsp/sprotty';
-import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
+import { inject, injectable, postConstruct, preDestroy } from 'inversify';
 import { getElements, getMatchingElements } from '../utils/gmodel-util';
-import { GLSPCommandStack, IGModelRootListener } from './command-stack';
+import { IGModelRootListener } from './editor-context-service';
 import { IFeedbackActionDispatcher } from './feedback/feedback-action-dispatcher';
+import { IDiagramStartup } from './model';
 
 export interface ISelectionListener {
     selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[]): void;
@@ -51,35 +53,34 @@ export interface SelectionChange {
 }
 
 @injectable()
-export class SelectionService implements IGModelRootListener, Disposable {
-    protected root: Readonly<GModelRoot>;
-    protected selectedElementIDs: Set<string> = new Set();
-
+export class SelectionService implements IGModelRootListener, Disposable, IDiagramStartup {
     @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackDispatcher: IFeedbackActionDispatcher;
 
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
     @inject(TYPES.ILogger)
     protected logger: ILogger;
 
-    @inject(TYPES.ICommandStack)
-    protected commandStack: GLSPCommandStack;
-
-    @multiInject(TYPES.ISelectionListener)
-    @optional()
-    protected selectionListeners: ISelectionListener[] = [];
+    protected root: Readonly<GModelRoot>;
+    protected selectedElementIDs: Set<string> = new Set();
 
     protected toDispose = new DisposableCollection();
 
     @postConstruct()
     protected initialize(): void {
-        this.toDispose.push(
-            this.onSelectionChangedEmitter,
-            this.commandStack.onModelRootChanged(root => this.modelRootChanged(root))
-        );
-
-        this.selectionListeners.forEach(listener =>
-            this.onSelectionChanged(change => listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements))
-        );
+        this.toDispose.push(this.onSelectionChangedEmitter);
+    }
+
+    preLoadDiagram(): void {
+        this.lazyInjector
+            .getAll<ISelectionListener>('selectionListener')
+            .forEach(listener =>
+                this.onSelectionChanged(change =>
+                    listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
+                )
+            );
     }
 
     @preDestroy()

package/src/base/tool-manager/tool-manager.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
@@ -14,19 +14,23 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { inject, injectable, multiInject, optional } from 'inversify';
 import {
     Action,
     EditMode,
+    GModelElement,
     IActionHandler,
     ICommand,
     KeyListener,
-    GModelElement,
+    LazyInjector,
+    MaybePromise,
     TYPES,
     distinctAdd,
     matchesKeystroke
 } from '@eclipse-glsp/sprotty';
-import { EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
+import { inject, injectable } from 'inversify';
+import { EditorContextService, IEditModeListener } from '../editor-context-service';
+import { IDiagramStartup } from '../model';
+import { Ranked } from '../ranked';
 import { EnableDefaultToolsAction, EnableToolsAction, Tool } from './tool';
 /**
  * A tool manager coordinates the state of tools in the context of an editor.
@@ -75,27 +79,23 @@ export interface IToolManager {
  * registration of tools via Dependency Injection.
  */
 @injectable()
-export class ToolManager implements IToolManager {
-    readonly actives: Tool[] = [];
+export class ToolManager implements IToolManager, IDiagramStartup, IEditModeListener {
+    @inject(EditorContextService)
+    protected editorContext: EditorContextService;
+
+    @inject(LazyInjector)
+    protected readonly lazyInjector: LazyInjector;
 
-    protected editorContext?: EditorContextService;
-
-    constructor(
-        @multiInject(TYPES.ITool)
-        @optional()
-        readonly tools: Tool[] = [],
-        @multiInject(TYPES.IDefaultTool)
-        @optional()
-        readonly defaultTools: Tool[],
-        @inject(TYPES.IEditorContextServiceProvider) protected contextServiceProvider: EditorContextServiceProvider
-    ) {
-        this.registerTools(...this.tools);
-        this.registerDefaultTools(...this.defaultTools);
+    readonly actives: Tool[] = [];
+    readonly tools: Tool[] = [];
+    readonly defaultTools: Tool[] = [];
+
+    preLoadDiagram(): MaybePromise<void> {
+        const tools: Tool[] = this.lazyInjector.getAll(TYPES.ITool);
+        const defaultTools: Tool[] = this.lazyInjector.getAll(TYPES.IDefaultTool);
+        this.registerTools(...tools);
+        this.registerDefaultTools(...defaultTools);
         this.enableDefaultTools();
-        this.contextServiceProvider().then(editorContext => {
-            editorContext.onEditModeChanged(change => this.editModeChanged(change.newValue, change.oldValue));
-            this.editorContext = editorContext;
-        });
     }
 
     get managedTools(): Tool[] {
@@ -106,6 +106,10 @@ export class ToolManager implements IToolManager {
         return this.actives;
     }
 
+    get rank(): number {
+        return Ranked.DEFAULT_RANK - 100;
+    }
+
     registerDefaultTools(...tools: Tool[]): void {
         distinctAdd(this.defaultTools, ...tools);
     }

package/src/base/ui-extension-registry.ts

@@ -0,0 +1,33 @@
+/********************************************************************************
+ * Copyright (c) 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 { IUIExtension, LazyInjector, MaybePromise, TYPES, UIExtensionRegistry } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IDiagramStartup } from './model';
+
+@injectable()
+export class GLSPUIExtensionRegistry extends UIExtensionRegistry implements IDiagramStartup {
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    constructor(@optional() extensions: IUIExtension[] = []) {
+        super(extensions);
+    }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<IUIExtension>(TYPES.IUIExtension).forEach(extension => this.register(extension.id(), extension));
+    }
+}

package/src/base/view/key-tool.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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,13 +13,25 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
-import { Disposable, KeyListener, KeyTool } from '@eclipse-glsp/sprotty';
+import { Disposable, KeyListener, KeyTool, LazyInjector, MaybePromise, TYPES } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IDiagramStartup } from '../model';
 
 @injectable()
-export class GLSPKeyTool extends KeyTool {
+export class GLSPKeyTool extends KeyTool implements IDiagramStartup {
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
+    constructor(@optional() keyListeners: KeyListener[] = []) {
+        super(keyListeners);
+    }
+
     registerListener(keyListener: KeyListener): Disposable {
         super.register(keyListener);
         return Disposable.create(() => this.deregister(keyListener));
     }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<KeyListener>(TYPES.KeyListener).forEach(listener => this.register(listener));
+    }
 }

package/src/base/view/mouse-tool.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,8 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable, multiInject, optional } from 'inversify';
-import { Action, Disposable, MouseListener, MouseTool, GModelElement, GModelRoot, TYPES } from '@eclipse-glsp/sprotty';
+import {
+    Action,
+    Disposable,
+    GModelElement,
+    GModelRoot,
+    LazyInjector,
+    MaybePromise,
+    MouseListener,
+    MouseTool,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IDiagramStartup } from '../model';
 import { Ranked } from '../ranked';
 
 /**
@@ -24,12 +35,18 @@ import { Ranked } from '../ranked';
 type MouseListenerMethods = keyof Omit<MouseListener, 'decorate'>;
 
 @injectable()
-export class GLSPMouseTool extends MouseTool {
+export class GLSPMouseTool extends MouseTool implements IDiagramStartup {
+    @inject(LazyInjector)
+    protected lazyInjector: LazyInjector;
+
     protected rankedMouseListeners: Map<number, MouseListener[]>;
 
-    constructor(@multiInject(TYPES.MouseListener) @optional() protected override mouseListeners: MouseListener[] = []) {
+    constructor(@optional() mouseListeners: MouseListener[] = []) {
         super(mouseListeners);
-        this.rankedMouseListeners = groupBy(mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    preLoadDiagram(): MaybePromise<void> {
+        this.lazyInjector.getAll<MouseListener>(TYPES.MouseListener).forEach(listener => this.register(listener));
     }
 
     override register(mouseListener: MouseListener): void {

package/src/default-modules.ts

@@ -26,7 +26,6 @@ import {
     edgeLayoutModule,
     expandModule,
     fadeModule,
-    labelEditUiModule,
     modelSourceModule,
     resolveContainerConfiguration,
     zorderModule
@@ -61,6 +60,7 @@ import { nodeCreationToolModule } from './features/tools/node-creation/node-crea
 import { toolFocusLossModule } from './features/tools/tool-focus-loss-module';
 import { markerNavigatorModule, validationModule } from './features/validation/validation-modules';
 import { viewportModule } from './features/viewport/viewport-modules';
+import { labelEditUiModule } from './features/label-edit-ui/label-edit-ui-module';
 
 export const DEFAULT_MODULES = [
     defaultModule,

package/src/features/bounds/glsp-hidden-bounds-updater.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2023 EclipseSource and others.
+ * Copyright (c) 2022-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
@@ -16,20 +16,21 @@
 
 import {
     Action,
+    BoundsData,
     ComputedBoundsAction,
     Deferred,
     EdgeRouterRegistry,
     ElementAndRoutingPoints,
     GModelElement,
-    GRoutableElement,
     HiddenBoundsUpdater,
     IActionDispatcher,
+    ModelIndexImpl,
     RequestAction,
     ResponseAction
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
 import { VNode } from 'snabbdom';
-import { calcElementAndRoute, isRoutable } from '../../utils/gmodel-util';
+import { BoundsAwareModelElement, calcElementAndRoute, getDescendantIds, isRoutable } from '../../utils/gmodel-util';
 import { LocalComputedBoundsAction, LocalRequestBoundsAction } from './local-bounds';
 
 /**
@@ -42,8 +43,10 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
     @inject(EdgeRouterRegistry) @optional() protected readonly edgeRouterRegistry?: EdgeRouterRegistry;
 
     protected element2route: ElementAndRoutingPoints[] = [];
-    protected edges: GRoutableElement[] = [];
-    protected nodes: VNode[] = [];
+
+    protected getElement2BoundsData(): Map<BoundsAwareModelElement, BoundsData> {
+        return this['element2boundsData'];
+    }
 
     override decorate(vnode: VNode, element: GModelElement): VNode {
         super.decorate(vnode, element);
@@ -54,6 +57,9 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
     }
 
     override postUpdate(cause?: Action): void {
+        if (LocalRequestBoundsAction.is(cause) && cause.elementIDs) {
+            this.focusOnElements(cause.elementIDs);
+        }
         const actions = this.captureActions(() => super.postUpdate(cause));
         actions
             .filter(action => ComputedBoundsAction.is(action))
@@ -61,6 +67,22 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
         this.element2route = [];
     }
 
+    protected focusOnElements(elementIDs: string[]): void {
+        const data = this.getElement2BoundsData();
+        if (data.size > 0) {
+            // expand given IDs to their descendent element IDs as we need their bounding boxes as well
+            const index = [...data.keys()][0].index;
+            const relevantIds = new Set(elementIDs.flatMap(elementId => this.expandElementId(elementId, index, elementIDs)));
+
+            // ensure we only keep the bounds of the elements we are interested in
+            data.forEach((_bounds, element) => !relevantIds.has(element.id) && data.delete(element));
+        }
+    }
+
+    protected expandElementId(id: string, index: ModelIndexImpl, elementIDs: string[]): string[] {
+        return getDescendantIds(index.getById(id));
+    }
+
     protected captureActions(call: () => void): Action[] {
         const capturingActionDispatcher = new CapturingActionDispatcher();
         const actualActionDispatcher = this.actionDispatcher;

package/src/features/bounds/local-bounds.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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
@@ -26,21 +26,38 @@ import {
     GModelRootSchema,
     RequestBoundsAction,
     TYPES,
-    ViewerOptions
+    ViewerOptions,
+    hasArrayProp
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { ServerAction } from '../../base/model/glsp-model-source';
 
+export interface LocalRequestBoundsAction extends RequestBoundsAction {
+    elementIDs?: string[];
+}
+
 export namespace LocalRequestBoundsAction {
-    export function is(object: unknown): object is RequestBoundsAction {
-        return RequestBoundsAction.is(object) && !ServerAction.is(object);
+    export function is(object: unknown): object is LocalRequestBoundsAction {
+        return RequestBoundsAction.is(object) && !ServerAction.is(object) && hasArrayProp(object, 'elementIDs', true);
+    }
+
+    export function create(newRoot: GModelRootSchema, elementIDs?: string[]): LocalRequestBoundsAction {
+        return {
+            ...RequestBoundsAction.create(newRoot),
+            elementIDs
+        };
     }
 
-    export function fromCommand(context: CommandExecutionContext, actionDispatcher: ActionDispatcher, cause?: Action): CommandResult {
+    export function fromCommand(
+        { root }: CommandExecutionContext,
+        actionDispatcher: ActionDispatcher,
+        cause?: Action,
+        elementIDs?: string[]
+    ): CommandResult {
         // do not modify the main model (modelChanged = false) but request local bounds calculation on hidden model
-        actionDispatcher.dispatch(RequestBoundsAction.create(context.root as unknown as GModelRootSchema));
+        actionDispatcher.dispatch(LocalRequestBoundsAction.create(root as unknown as GModelRootSchema, elementIDs));
         return {
-            model: context.root,
+            model: root,
             modelChanged: false,
             cause
         };

package/src/features/bounds/set-bounds-feedback-command.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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
@@ -24,6 +24,7 @@ import {
     isLayoutContainer
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import { Ranked } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
 import { LocalRequestBoundsAction } from './local-bounds';
@@ -48,7 +49,7 @@ export namespace SetBoundsFeedbackAction {
 export class SetBoundsFeedbackCommand extends SetBoundsCommand implements FeedbackCommand {
     static override readonly KIND: string = SetBoundsFeedbackAction.KIND;
 
-    readonly priority: number = 0;
+    readonly rank: number = Ranked.DEFAULT_RANK;
 
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
 
@@ -65,6 +66,7 @@ export class SetBoundsFeedbackCommand extends SetBoundsCommand implements Feedba
                 element.layoutOptions = options;
             }
         });
-        return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action);
+        const elementIDs = this.action.bounds.map(bounds => bounds.elementId);
+        return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action, elementIDs);
     }
 }

package/src/features/change-bounds/position-snapper.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023 EclipseSource and others.
+ * Copyright (c) 2023-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

package/src/features/command-palette/command-palette-module.ts

@@ -13,13 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { CommandPalette, CommandPaletteActionProviderRegistry, FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
+import { CommandPaletteActionProviderRegistry, FeatureModule, TYPES, bindAsService } from '@eclipse-glsp/sprotty';
 import '../../../css/command-palette.css';
+import { GlspCommandPalette } from './command-palette';
 import { CommandPaletteTool } from './command-palette-tool';
 import { ServerCommandPaletteActionProvider } from './server-command-palette-provider';
 
 export const commandPaletteModule = new FeatureModule(bind => {
-    bindAsService(bind, TYPES.IUIExtension, CommandPalette);
+    bindAsService(bind, TYPES.IUIExtension, GlspCommandPalette);
     bind(TYPES.ICommandPaletteActionProviderRegistry).to(CommandPaletteActionProviderRegistry).inSingletonScope();
     bindAsService(bind, TYPES.ICommandPaletteActionProvider, ServerCommandPaletteActionProvider);
     bindAsService(bind, TYPES.IDefaultTool, CommandPaletteTool);