@eclipse-glsp/client 2.1.0-next.303 → 2.1.0-next.305

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/client",
-  "version": "2.1.0-next.303+f286b9d",
+  "version": "2.1.0-next.305+87e78dc",
   "description": "A sprotty-based client for GLSP",
   "keywords": [
     "eclipse",
@@ -47,7 +47,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/sprotty": "2.1.0-next.303+f286b9d",
+    "@eclipse-glsp/sprotty": "2.1.0-next.305+87e78dc",
     "autocompleter": "^9.1.0",
     "file-saver": "^2.0.5",
     "lodash": "4.17.21"
@@ -59,5 +59,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "f286b9d8289e11b2b3760cc7947c3bfc12a4bd70"
+  "gitHead": "87e78dc75c8346396619bbb1126335860f9fb50b"
 }

package/src/base/action-dispatcher.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import { Action, ActionDispatcher, RequestAction, ResponseAction } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { OptionalAction } from './model/glsp-model-source';
 import { ModelInitializationConstraint } from './model/model-initialization-constraint';
 
 @injectable()
@@ -76,6 +77,9 @@ export class GLSPActionDispatcher extends ActionDispatcher {
                 action.responseId = '';
             }
         }
+        if (!this.hasHandler(action) && OptionalAction.is(action)) {
+            return Promise.resolve();
+        }
         return super.handleAction(action);
     }
 

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

@@ -14,7 +14,6 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { inject, injectable, preDestroy } from 'inversify';
 import {
     Action,
     ActionMessage,
@@ -29,8 +28,10 @@ import {
     ModelSource,
     TYPES
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable, preDestroy } from 'inversify';
 import { GLSPActionHandlerRegistry } from '../action-handler-registry';
 import { IDiagramOptions } from './diagram-loader';
+
 /**
  * A helper interface that allows the client to mark actions that have been received from the server.
  */
@@ -44,7 +45,7 @@ export namespace ServerAction {
     }
 
     /**
-     * Mark the given action as {@link ServerAction} by attaching the "_receivedFromServer" property
+     * Mark the given action as {@link ServerAction} by attaching the "__receivedFromServer" property
      * @param action The action that should be marked as server action
      */
     export function mark(action: Action): void {
@@ -52,6 +53,29 @@ export namespace ServerAction {
     }
 }
 
+/**
+ * A helper interface that allows the client to mark actions that can be considered optional and should not throw an error if
+ * no handler is available.
+ */
+export interface OptionalAction extends Action {
+    __skipErrorIfNoHandler: true;
+}
+
+export namespace OptionalAction {
+    export function is(object: unknown): object is ServerAction {
+        return Action.is(object) && '__skipErrorIfNoHandler' in object && object.__skipErrorIfNoHandler === true;
+    }
+
+    /**
+     * Mark the given action as {@link OptionalAction} by attaching the "__skipErrorIfNoHandler" property
+     * @param action The action that should be marked as optional action
+     */
+    export function mark<T extends Action>(action: T): T & OptionalAction {
+        (action as unknown as OptionalAction).__skipErrorIfNoHandler = true;
+        return action as T & OptionalAction;
+    }
+}
+
 /**
  * Central component for enabling the client-server action flow with the help of an underlying {@link GLSPClient}.
  * Handles & forwards actions that are intended for the GLSP server. In addition, it handles {@link ActionMessage}s received

package/src/base/selection-service.spec.ts

@@ -13,10 +13,10 @@
  *
  * 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 { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
 import * as sinon from 'sinon';
-import { Action, Disposable, GModelRoot, GNode, TYPES, initializeContainer } from '@eclipse-glsp/sprotty';
 import { defaultModule } from './default.module';
 import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback/feedback-action-dispatcher';
 import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
@@ -217,13 +217,13 @@ describe('SelectionService', () => {
             selectionService.updateSelection(root, [], ['node4']);
             assertListener(listener, root, ['node2', 'node3'], ['node4'], 4);
         });
-        it('A registered listener should be notified of root changes.', () => {
+        it('A registered listener should NOT be notified of root changes.', () => {
             selectionService.updateSelection(root, [], []);
-            assertListener(listener, root, [], [], 1);
+            assertListener(listener, root, [], [], 0);
 
             const newRoot = createRoot('node1', 'newNode2', 'newNode3');
             selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, newRoot, [], [], 2);
+            assertListener(listener, newRoot, [], [], 0);
         });
         it('Selecting the same elements consecutively should not trigger a listener update.', () => {
             selectionService.updateSelection(root, ['node1'], []);
@@ -290,8 +290,10 @@ describe('SelectionService', () => {
         expectedCalled: number
     ): void {
         expect(listener.selectionChanged.callCount).to.be.equal(expectedCalled);
-        expect(listener.selectionChanged.lastCall.args[0]).to.be.deep.equals(expectedRoot);
-        expect(listener.selectionChanged.lastCall.args[1]).to.be.deep.equals(expectedSelection);
-        expect(listener.selectionChanged.lastCall.args[2]).to.be.deep.equals(expectedDeselection);
+        if (expectedCalled > 0) {
+            expect(listener.selectionChanged.lastCall.args[0]).to.be.deep.equals(expectedRoot);
+            expect(listener.selectionChanged.lastCall.args[1]).to.be.deep.equals(expectedSelection);
+            expect(listener.selectionChanged.lastCall.args[2]).to.be.deep.equals(expectedDeselection);
+        }
     }
 });

package/src/base/selection-service.ts

@@ -96,41 +96,41 @@ export class SelectionService implements IGModelRootListener, Disposable {
         this.updateSelection(root, [], []);
     }
 
-    updateSelection(root: Readonly<GModelRoot>, select: string[], deselect: string[]): void {
-        if (root === undefined && select.length === 0 && deselect.length === 0) {
+    updateSelection(newRoot: Readonly<GModelRoot>, select: string[], deselect: string[]): void {
+        if (newRoot === undefined && select.length === 0 && deselect.length === 0) {
             return;
         }
         const prevRoot = this.root;
         const prevSelectedElementIDs = new Set(this.selectedElementIDs);
 
-        // update root
-        this.root = root;
+        this.root = newRoot;
 
-        // update selected element IDs and collect deselected elements
-        // - select all elements that are not deselected at the same time (no-op)
-        // - deselect all elements that are not selected at the same time (no-op) but was selected
+        // We only select elements that are not part of the deselection
         const toSelect = [...select].filter(selectId => deselect.indexOf(selectId) === -1);
+
+        // We only need to deselect elements that are not part of the selection
+        // If an element is part of both the select and deselect, it's state is not changed
         const toDeselect = [...deselect].filter(deselectId => select.indexOf(deselectId) === -1 && this.selectedElementIDs.has(deselectId));
-        for (const id of toDeselect) {
-            this.selectedElementIDs.delete(id);
-        }
-        for (const id of toSelect) {
-            this.selectedElementIDs.add(id);
-        }
 
+        // update selected element ids
+        toDeselect.forEach(toDeselectId => this.selectedElementIDs.delete(toDeselectId));
+        toSelect.forEach(toSelectId => this.selectedElementIDs.add(toSelectId));
+
+        // check if the newly or previously selected elements still exist in the updated root
         const deselectedElementIDs = new Set(toDeselect);
-        // see if selected elements still exist in the updated root
         for (const id of this.selectedElementIDs) {
-            const element = root.index.getById(id);
+            const element = newRoot.index.getById(id);
             if (element === undefined) {
+                // element to be selected does not exist in the root...
                 this.selectedElementIDs.delete(id);
-                if (prevRoot !== undefined && prevRoot.index.getById(id)) {
+                if (prevRoot?.index.getById(id)) {
+                    // ...but existed in the previous root, so we want to consider it deselected
                     deselectedElementIDs.add(id);
                 }
             }
         }
 
-        // only send out changes if there actually are changes, i.e., the root or the selected elements changed
+        // only send out changes if there actually are changes, i.e., any of the selected elements ids has changed
         const selectionChanged =
             prevSelectedElementIDs.size !== this.selectedElementIDs.size ||
             ![...prevSelectedElementIDs].every(value => this.selectedElementIDs.has(value));
@@ -142,10 +142,6 @@ export class SelectionService implements IGModelRootListener, Disposable {
                     deselectedElementsIDs: [...deselectedElementIDs]
                 })
             ]);
-        }
-
-        const rootChanged = prevRoot !== root;
-        if (rootChanged || selectionChanged) {
             // notify listeners after the feedback action
             this.notifyListeners(this.root, this.selectedElementIDs, deselectedElementIDs);
         }

package/src/features/tools/change-bounds/change-bounds-tool-feedback.ts

@@ -36,6 +36,7 @@ import { DebouncedFunc, debounce } from 'lodash';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
 import { CursorCSS, cursorFeedbackAction } from '../../../base/feedback/css-feedback';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
+import { OptionalAction } from '../../../base/model/glsp-model-source';
 import { forEachElement } from '../../../utils/gmodel-util';
 import { SResizeHandle, addResizeHandles, isResizable, removeResizeHandles } from '../../change-bounds/model';
 import { createMovementRestrictionFeedback, removeMovementRestrictionFeedback } from '../../change-bounds/movement-restrictor';
@@ -125,7 +126,7 @@ export namespace MoveInitializedEventAction {
     }
 
     export function create(): MoveInitializedEventAction {
-        return { kind: KIND };
+        return OptionalAction.mark({ kind: KIND });
     }
 }
 
@@ -141,7 +142,7 @@ export namespace MoveFinishedEventAction {
     }
 
     export function create(): MoveFinishedEventAction {
-        return { kind: KIND };
+        return OptionalAction.mark({ kind: KIND });
     }
 }
 
@@ -157,6 +158,7 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
     protected positionUpdater;
     protected elementId2startPos = new Map<string, Point>();
     protected pendingMoveInitialized?: DebouncedFunc<() => void>;
+    protected moveInitialized = false;
 
     constructor(protected tool: ChangeBoundsTool) {
         super();
@@ -178,10 +180,12 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
     }
 
     protected scheduleMoveInitialized(): void {
+        this.moveInitialized = false;
         this.pendingMoveInitialized?.cancel();
         this.pendingMoveInitialized = debounce(() => {
             this.tool.registerFeedback([MoveInitializedEventAction.create()], this);
             this.pendingMoveInitialized = undefined;
+            this.moveInitialized = true;
         }, 750);
         this.pendingMoveInitialized();
     }
@@ -329,11 +333,12 @@ export class FeedbackMoveMouseListener extends DragAwareMouseListener implements
                 const moveAction = MoveAction.create(elementMoves, { animate: false, finished: true });
                 this.tool.deregisterFeedback(this, [moveAction]);
             }
-        } else if (resetFeedback) {
+        } else if (resetFeedback && this.moveInitialized) {
             this.tool.deregisterFeedback(this, [MoveFinishedEventAction.create()]);
         }
         this.positionUpdater.resetPosition();
         this._isMouseDrag = false;
+        this.moveInitialized = false;
         this.rootElement = undefined;
         this.elementId2startPos.clear();
     }