@eclipse-glsp/client 2.3.0-next.391 → 2.3.0-next.395

package/lib/index.js

@@ -43,7 +43,6 @@ __exportStar(require("./base/drag-aware-mouse-listener"), exports);
 __exportStar(require("./base/editor-context-service"), exports);
 __exportStar(require("./base/feedback/css-feedback"), exports);
 __exportStar(require("./base/feedback/feedback-action-dispatcher"), exports);
-__exportStar(require("./base/feedback/feedback-action-dispatcher-default"), exports);
 __exportStar(require("./base/feedback/feedback-command"), exports);
 __exportStar(require("./base/feedback/feedback-emitter"), exports);
 __exportStar(require("./base/feedback/set-model-command"), exports);
@@ -161,7 +160,6 @@ __exportStar(require("./features/grid/grid-snapper"), exports);
 __exportStar(require("./features/grid/grid-style"), exports);
 __exportStar(require("./features/helper-lines/helper-line-feedback"), exports);
 __exportStar(require("./features/helper-lines/helper-line-manager"), exports);
-__exportStar(require("./features/helper-lines/helper-line-manager-default"), exports);
 __exportStar(require("./features/helper-lines/helper-line-module"), exports);
 __exportStar(require("./features/helper-lines/model"), exports);
 __exportStar(require("./features/helper-lines/view"), exports);

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/client",
-  "version": "2.3.0-next.391+dd011ea",
+  "version": "2.3.0-next.395+8de5d13",
   "description": "A sprotty-based client for GLSP",
   "keywords": [
     "eclipse",
@@ -46,7 +46,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/sprotty": "2.3.0-next.391+dd011ea",
+    "@eclipse-glsp/sprotty": "2.3.0-next.395+8de5d13",
     "autocompleter": "^9.1.2",
     "file-saver": "^2.0.5",
     "lodash": "4.17.21",
@@ -63,5 +63,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "dd011eae4f7a629cc2431e5e6d832ddb9483554b"
+  "gitHead": "8de5d139f94af875d6c073bf8d89107020f7a64d"
 }

package/src/base/action-dispatcher.ts

@@ -16,12 +16,14 @@
 import {
     Action,
     ActionDispatcher,
+    ActionHandlerRegistry,
     EMPTY_ROOT,
     GModelRoot,
     IActionDispatcher,
     RequestAction,
     ResponseAction,
-    SetModelAction
+    SetModelAction,
+    TYPES
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { GLSPActionHandlerRegistry } from './action-handler-registry';
@@ -37,6 +39,12 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
     @inject(ModelInitializationConstraint)
     protected initializationConstraint: ModelInitializationConstraint;
 
+    @inject(ActionHandlerRegistry)
+    protected override actionHandlerRegistry: ActionHandlerRegistry;
+
+    /** @deprecated No longer in used. The {@link ActionHandlerRegistry} is now directly injected */
+    // eslint-disable-next-line deprecation/deprecation
+    @inject(TYPES.ActionHandlerRegistryProvider) protected override actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
     protected postUpdateQueue: Action[] = [];
 
     override initialize(): Promise<void> {
@@ -47,10 +55,8 @@ export class GLSPActionDispatcher extends ActionDispatcher implements IGModelRoo
     }
 
     protected async doInitialize(): Promise<void> {
-        const registry = await this.actionHandlerRegistryProvider();
-        this.actionHandlerRegistry = registry;
-        if (registry instanceof GLSPActionHandlerRegistry) {
-            registry.initialize();
+        if (this.actionHandlerRegistry instanceof GLSPActionHandlerRegistry) {
+            this.actionHandlerRegistry.initialize();
         }
         this.handleAction(SetModelAction.create(EMPTY_ROOT)).catch(() => {
             /* Logged in handleAction method */

package/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 ------------------------------------

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

@@ -13,23 +13,29 @@
  *
  * 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,
+    MaybeActions,
+    TYPES,
+    toTypeGuard
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, preDestroy } from 'inversify';
+import { getFeedbackRank } from './feedback-command';
 import { FeedbackEmitter } from './feedback-emitter';
 
 export interface IFeedbackEmitter {}
 
 export const feedbackFeature = Symbol('feedbackFeature');
 
-export type MaybeActions = MaybeFunction<Action[] | Action | undefined>;
-
-export namespace MaybeActions {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
-    export function asArray(actions?: MaybeActions): Action[] {
-        const cleanup = actions ? call(actions) : [];
-        return cleanup ? toArray(cleanup) : [];
-    }
-}
-
 /**
  * Dispatcher for actions that are meant to show visual feedback on
  * the diagram that is not part of the diagram sent from the server
@@ -86,3 +92,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;
+    }
+}

package/src/base/feedback/feedback-emitter.ts

@@ -14,8 +14,8 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Action, Disposable, arrayOf } from '@eclipse-glsp/sprotty';
-import { IFeedbackActionDispatcher, IFeedbackEmitter, MaybeActions } from './feedback-action-dispatcher';
+import { Action, Disposable, MaybeActions, arrayOf } from '@eclipse-glsp/sprotty';
+import type { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback-action-dispatcher';
 
 // counter for internal id, mainly useful for debugging
 let idCounter = 0;

package/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
         };
     }
 }

package/src/features/helper-lines/helper-line-manager.ts

@@ -13,8 +13,38 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement, Vector } from '@eclipse-glsp/sprotty';
-import { Direction } from './model';
+import {
+    Action,
+    GModelElement,
+    GModelRoot,
+    IActionHandler,
+    MoveAction,
+    Point,
+    SetBoundsAction,
+    TYPES,
+    Vector,
+    Writable
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional, postConstruct } from 'inversify';
+import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
+import { ISelectionListener, SelectionService } from '../../base/selection-service';
+import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
+import { GResizeHandle, ResizeHandleLocation } from '../change-bounds/model';
+import { Grid } from '../grid/grid';
+import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
+import {
+    AlignmentElementFilter,
+    DEFAULT_ALIGNABLE_ELEMENT_FILTER,
+    DEFAULT_DEBUG,
+    DEFAULT_ELEMENT_LINES,
+    DEFAULT_EPSILON,
+    DEFAULT_VIEWPORT_LINES,
+    DrawHelperLinesFeedbackAction,
+    RemoveHelperLinesFeedbackAction,
+    ViewportLineType
+} from './helper-line-feedback';
+import { Direction, HelperLine, HelperLineType, isHelperLine } from './model';
 
 export interface IHelperLineManager {
     /**
@@ -35,3 +65,205 @@ export interface IHelperLineManager {
      */
     getMinimumMoveVector(element: GModelElement, isSnap: boolean, directions: Direction[]): Vector | undefined;
 }
+
+export interface IHelperLineOptions {
+    /**
+     * A list of helper line types that should be rendered when elements are aligned.
+     * Defaults to all possible alignments.
+     */
+    elementLines?: HelperLineType[];
+    /**
+     * A list of helper line types that should be rendered when an element is aligned with the viewport.
+     * Defaults to middle and center alignment.
+     */
+    viewportLines?: ViewportLineType[];
+    /**
+     * The minimum difference between two coordinates
+     * Defaults to 1 or zero (perfect match) if the optional grid module is loaded.
+     */
+    alignmentEpsilon?: number;
+    /**
+     * A filter that is applied to determine on which elements the alignment calculation is performed.
+     * By default all top-level bounds-aware, non-routable elements that are visible on the canvas are considered.
+     */
+    alignmentElementFilter?: AlignmentElementFilter;
+    /**
+     * The minimum move delta that is necessary for an element to break through a helper line.
+     * Defaults to { x: 1, y: 1 } whereas the x represents the horizontal distance and y represents the vertical distance.
+     * If the optional grid module is loaded, defaults to twice the grid size, i.e., two grid moves to break through a helper line.
+     */
+    minimumMoveDelta?: Point;
+
+    /**
+     * Produces debug output.
+     * Defaults to false.
+     */
+    debug?: boolean;
+}
+
+export const DEFAULT_MOVE_DELTA = { x: 1, y: 1 };
+
+export const DEFAULT_HELPER_LINE_OPTIONS: Required<IHelperLineOptions> = {
+    elementLines: DEFAULT_ELEMENT_LINES,
+    viewportLines: DEFAULT_VIEWPORT_LINES,
+    alignmentEpsilon: DEFAULT_EPSILON,
+    alignmentElementFilter: DEFAULT_ALIGNABLE_ELEMENT_FILTER,
+    minimumMoveDelta: DEFAULT_MOVE_DELTA,
+    debug: DEFAULT_DEBUG
+};
+
+@injectable()
+export class HelperLineManager implements IActionHandler, ISelectionListener, IHelperLineManager {
+    @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(SelectionService) protected selectionService: SelectionService;
+    @optional() @inject(TYPES.IHelperLineOptions) protected userOptions?: IHelperLineOptions;
+    @optional() @inject(TYPES.Grid) protected grid?: Grid;
+
+    protected options: Required<IHelperLineOptions>;
+    protected feedback: FeedbackEmitter;
+
+    @postConstruct()
+    protected init(): void {
+        this.feedback = this.feedbackDispatcher.createEmitter();
+        const dynamicOptions: IHelperLineOptions = {};
+        if (this.grid) {
+            dynamicOptions.alignmentEpsilon = 0;
+            dynamicOptions.minimumMoveDelta = Point.multiplyScalar(this.grid, 2);
+        }
+        this.options = { ...DEFAULT_HELPER_LINE_OPTIONS, ...dynamicOptions, ...this.userOptions };
+        this.selectionService.addListener(this);
+    }
+
+    handle(action: Action): void {
+        if (MoveInitializedEventAction.is(action)) {
+            this.handleMoveInitializedAction(action);
+        } else if (MoveAction.is(action)) {
+            this.handleMoveAction(action);
+        } else if (MoveFinishedEventAction.is(action)) {
+            this.handleMoveFinishedAction(action);
+        } else if (SetBoundsAction.is(action) || SetBoundsFeedbackAction.is(action)) {
+            this.handleSetBoundsAction(action);
+        }
+    }
+
+    protected handleMoveInitializedAction(_action: MoveInitializedEventAction): void {
+        this.submitHelperLineFeedback();
+    }
+
+    protected handleMoveFinishedAction(_action: MoveFinishedEventAction): void {
+        this.feedback.dispose();
+    }
+
+    protected handleMoveAction(action: MoveAction): void {
+        if (!action.finished) {
+            this.submitHelperLineFeedback(action.moves.map(move => move.elementId));
+        } else {
+            this.feedback.dispose();
+        }
+    }
+
+    protected submitHelperLineFeedback(elementIds: string[] = this.selectionService.getSelectedElementIDs()): void {
+        const feedback = this.createHelperLineFeedback(elementIds);
+        this.feedback.add(feedback, [RemoveHelperLinesFeedbackAction.create()]).submit();
+    }
+
+    protected createHelperLineFeedback(elementIds: string[]): DrawHelperLinesFeedbackAction {
+        return DrawHelperLinesFeedbackAction.create({ elementIds, ...this.options });
+    }
+
+    protected handleSetBoundsAction(action: SetBoundsAction | SetBoundsFeedbackAction): void {
+        this.submitHelperLineFeedback(action.bounds.map(bound => bound.elementId));
+    }
+
+    selectionChanged(root: Readonly<GModelRoot>, selectedElements: string[], deselectedElements?: string[] | undefined): void {
+        this.feedback.dispose();
+    }
+
+    getMinimumMoveDelta(element: GModelElement, isSnap: boolean, direction: Direction): number {
+        if (!isSnap) {
+            return 0;
+        }
+        const minimumMoveDelta = this.options.minimumMoveDelta;
+        return direction === Direction.Left || direction === Direction.Right ? minimumMoveDelta.x : minimumMoveDelta.y;
+    }
+
+    getMinimumMoveVector(element: GModelElement, isSnap: boolean, move: Direction[]): Vector | undefined {
+        if (!isSnap) {
+            return undefined;
+        }
+
+        const state = this.getHelperLineState(element);
+        if (state.helperLines.length === 0) {
+            return undefined;
+        }
+
+        const minimum: Writable<Vector> = { ...Vector.ZERO };
+        const resize =
+            element instanceof GResizeHandle
+                ? ResizeHandleLocation.direction(element.location)
+                : [Direction.Left, Direction.Right, Direction.Up, Direction.Down];
+
+        if ((state.types.left || state.types.center) && move.includes(Direction.Left) && resize.includes(Direction.Left)) {
+            minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Left);
+        } else if ((state.types.right || state.types.center) && move.includes(Direction.Right) && resize.includes(Direction.Right)) {
+            minimum.x = this.getMinimumMoveDelta(element, isSnap, Direction.Right);
+        }
+        if ((state.types.top || state.types.middle) && move.includes(Direction.Up) && resize.includes(Direction.Up)) {
+            minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Up);
+        } else if ((state.types.bottom || state.types.middle) && move.includes(Direction.Down) && resize.includes(Direction.Down)) {
+            minimum.y = this.getMinimumMoveDelta(element, isSnap, Direction.Down);
+        }
+        return Vector.isZero(minimum) ? undefined : minimum;
+    }
+
+    protected getHelperLineState(element: GModelElement): HelperLineState {
+        const helperLines = element.root.children.filter(isHelperLine) || [];
+        const types = {
+            left: false,
+            right: false,
+            top: false,
+            bottom: false,
+            center: false,
+            middle: false
+        };
+        for (const line of helperLines) {
+            switch (line.lineType) {
+                case HelperLineType.Left:
+                case HelperLineType.LeftRight:
+                    types.left = true;
+                    break;
+                case HelperLineType.Right:
+                case HelperLineType.RightLeft:
+                    types.right = true;
+                    break;
+                case HelperLineType.Top:
+                case HelperLineType.TopBottom:
+                    types.top = true;
+                    break;
+                case HelperLineType.Bottom:
+                case HelperLineType.BottomTop:
+                    types.bottom = true;
+                    break;
+                case HelperLineType.Center:
+                    types.center = true;
+                    break;
+                case HelperLineType.Middle:
+                    types.middle = true;
+                    break;
+            }
+        }
+        return { helperLines, types };
+    }
+}
+
+export interface HelperLineState {
+    helperLines: HelperLine[];
+    types: {
+        left: boolean;
+        right: boolean;
+        top: boolean;
+        bottom: boolean;
+        center: boolean;
+        middle: boolean;
+    };
+}

package/src/features/helper-lines/helper-line-module.ts

@@ -27,7 +27,7 @@ import {
 import { SetBoundsFeedbackAction } from '../bounds/set-bounds-feedback-command';
 import { MoveFinishedEventAction, MoveInitializedEventAction } from '../tools/change-bounds/change-bounds-tool-feedback';
 import { DrawHelperLinesFeedbackCommand, RemoveHelperLinesFeedbackCommand } from './helper-line-feedback';
-import { HelperLineManager } from './helper-line-manager-default';
+import { HelperLineManager } from './helper-line-manager';
 import { HELPER_LINE, HelperLine, SELECTION_BOUNDS, SelectionBounds } from './model';
 import { HelperLineView, SelectionBoundsView } from './view';
 

package/src/features/hints/type-hint-provider.spec.ts

@@ -36,7 +36,7 @@ import { expect } from 'chai';
 import { Container } from 'inversify';
 import * as sinon from 'sinon';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
-import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher-default';
+import { FeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
 import { GEdge } from '../../model';
 import { isResizable } from '../change-bounds/model';

package/src/features/navigation/navigation-action-handler.ts

@@ -38,7 +38,7 @@ import {
     hasStringProp
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { EditorContextServiceProvider } from '../../base/editor-context-service';
+import { EditorContextService, EditorContextServiceProvider } from '../../base/editor-context-service';
 import { NavigationTargetResolver } from './navigation-target-resolver';
 
 /**
@@ -140,9 +140,15 @@ export class NavigationActionHandler implements IActionHandler {
 
     @inject(TYPES.ILogger) protected logger: ILogger;
     @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
+    /** @deprecated No longer in used. The {@link ActionHandlerRegistry} is now directly injected */
+    // eslint-disable-next-line deprecation/deprecation
     @inject(TYPES.ActionHandlerRegistryProvider) protected actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
+    /** @deprecated No longer in used. The {@link EditorContextService} is now directly injected */
+    // eslint-disable-next-line deprecation/deprecation
     @inject(TYPES.IEditorContextServiceProvider) protected editorContextService: EditorContextServiceProvider;
+    @inject(ActionHandlerRegistry) protected actionHandlerRegistry: ActionHandlerRegistry;
     @inject(NavigationTargetResolver) protected resolver: NavigationTargetResolver;
+    @inject(EditorContextService) protected editorContext: EditorContextService;
 
     handle(action: Action): ICommand | Action | void {
         if (NavigateAction.is(action)) {
@@ -158,8 +164,7 @@ export class NavigationActionHandler implements IActionHandler {
 
     protected async handleNavigateAction(action: NavigateAction): Promise<void> {
         try {
-            const editorContextService = await this.editorContextService();
-            const editorContext = editorContextService.get(action.args);
+            const editorContext = this.editorContext.get(action.args);
             const response = await this.dispatcher.request(
                 RequestNavigationTargetsAction.create({ targetTypeId: action.targetTypeId, editorContext })
             );
@@ -250,8 +255,7 @@ export class NavigationActionHandler implements IActionHandler {
     }
 
     protected async handleNavigateToExternalTarget(action: NavigateToExternalTargetAction): Promise<void> {
-        const registry = await this.actionHandlerRegistryProvider();
-        const handlers = registry.get(NavigateToExternalTargetAction.KIND);
+        const handlers = this.actionHandlerRegistry.get(NavigateToExternalTargetAction.KIND);
         if (handlers.length === 1) {
             // we are the only handler so we know nobody took care of it
             this.warnAboutFailedNavigation('Could not resolve or navigate to target', action.target);

package/src/features/navigation/navigation-target-resolver.ts

@@ -13,7 +13,6 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import {
     IActionDispatcher,
     ILogger,
@@ -23,6 +22,7 @@ import {
     SetResolvedNavigationTargetAction,
     TYPES
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
 import { IDiagramOptions } from '../../base/model/diagram-loader';
 
 /**
@@ -51,9 +51,12 @@ export class NavigationTargetResolver {
         target: NavigationTarget
     ): Promise<SetResolvedNavigationTargetAction | undefined> {
         const targetUri = decodeURIComponent(target.uri);
-        if (sourceUri && sourceUri !== targetUri && `file://${sourceUri}` !== targetUri) {
+        const normalizedSourceUri = sourceUri?.replace(/^file:\/\//, '');
+        const normalizedTargetUri = targetUri.replace(/^file:\/\//, '');
+
+        if (normalizedSourceUri && normalizedSourceUri !== normalizedTargetUri) {
             // different URI, so we can't resolve it locally
-            this.logger.info("Source and Target URI are different. Can't resolve locally.", sourceUri, targetUri);
+            this.logger.info("Source and Target URI are different. Can't resolve locally.", normalizedSourceUri, normalizedTargetUri);
             return undefined;
         }
         if (NavigationTarget.getElementIds(target).length > 0) {