@eclipse-glsp/client 1.1.0-next.cb7168a.239 → 1.1.0-next.cc57a50.267

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

@@ -0,0 +1,149 @@
+/********************************************************************************
+ * Copyright (c) 2023 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    ActionHandlerRegistry,
+    ActionMessage,
+    Disposable,
+    DisposableCollection,
+    GLSPClient,
+    ILogger,
+    ModelSource,
+    RequestModelAction,
+    SModelRootSchema,
+    TYPES
+} from '~glsp-sprotty';
+/**
+ * A helper interface that allows the client to mark actions that have been received from the server.
+ */
+export interface ServerAction extends Action {
+    _receivedFromServer: true;
+}
+
+export namespace ServerAction {
+    export function is(object: unknown): object is ServerAction {
+        return Action.is(object) && '_receivedFromServer' in object && object._receivedFromServer === true;
+    }
+
+    /**
+     * 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 {
+        (action as ServerAction)._receivedFromServer = true;
+    }
+}
+
+/**
+ * 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
+ * from the server and dispatches the corresponding actions locally.
+ *
+ * Note that in sprotty a {@link ModelSource} is serving the model to the event cycle and
+ * is used to commit the local (i.e. client-side) model back to the source.
+ * However, in GLSP the update flow is reversed meaning that changes to the source model are applied
+ * on the server side and then an update is sent to the client.
+ */
+@injectable()
+export class GLSPModelSource extends ModelSource implements Disposable {
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    protected _sourceUri?: string;
+    protected _glspClient?: GLSPClient;
+    protected toDispose = new DisposableCollection();
+
+    clientId: string;
+
+    get glspClient(): GLSPClient | undefined {
+        return this._glspClient;
+    }
+
+    get sourceUri(): string | undefined {
+        return this._sourceUri;
+    }
+
+    async connect(client: GLSPClient, clientId?: string): Promise<GLSPClient> {
+        if (clientId) {
+            this.clientId = clientId;
+        }
+        await client.start();
+        this.toDispose.push(client.onActionMessage(message => this.messageReceived(message), this.clientId));
+        this._glspClient = client;
+        return this._glspClient;
+    }
+
+    protected messageReceived(message: ActionMessage): void {
+        if (this.clientId !== message.clientId) {
+            return;
+        }
+        const action = message.action;
+        ServerAction.mark(action);
+        this.logger.log(this, 'receiving', action);
+        this.actionDispatcher.dispatch(action);
+    }
+
+    override initialize(registry: ActionHandlerRegistry): void {
+        // Registering actions here is discouraged and it's recommended
+        // to implemented dedicated action handlers.
+        if (!this.clientId) {
+            this.clientId = this.viewerOptions.baseDiv;
+        }
+    }
+
+    handle(action: Action): void {
+        // Handling additional actions here is discouraged and it's recommended
+        // to implemented dedicated action handlers.
+        if (RequestModelAction.is(action)) {
+            this._sourceUri = action.options?.sourceUri.toString();
+        }
+        if (this.shouldForwardToServer(action)) {
+            this.forwardToServer(action);
+        }
+    }
+
+    protected forwardToServer(action: Action): void {
+        const message: ActionMessage = {
+            clientId: this.clientId,
+            action: action
+        };
+        this.logger.log(this, 'sending', message);
+        if (this.glspClient) {
+            this.glspClient.sendActionMessage(message);
+        } else {
+            throw new Error('GLSPClient is not connected');
+        }
+    }
+
+    protected shouldForwardToServer(action: Action): boolean {
+        return !ServerAction.is(action);
+    }
+
+    commitModel(newRoot: SModelRootSchema): SModelRootSchema {
+        /* In GLSP the model update flow is server-driven. i.e. changes to the graphical model are applied
+         * on server-side an only the server can issue a model update.
+         * The internal/local model should never be committed back to the model source i.e. GLSP server.
+         * => no-op implementation that simply returns the `newRoot`
+         */
+        return newRoot;
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+}

package/src/base/model/model-registry.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2022 EclipseSource and others.
+ * Copyright (c) 2021-2023 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,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { injectable } from 'inversify';
-import { SModelElement, SModelRegistry } from 'sprotty';
+import { SModelElement, SModelRegistry } from '~glsp-sprotty';
 
 @injectable()
 export class GLSPModelRegistry extends SModelRegistry {

package/src/base/model-initialization-constraint.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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,9 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Deferred, SetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
 import { injectable } from 'inversify';
-import { InitializeCanvasBoundsAction } from 'sprotty';
+import { Action, Deferred, InitializeCanvasBoundsAction, SetModelAction, UpdateModelAction } from '~glsp-sprotty';
 
 /**
  * The constraint defining when the initialization of the GLSP model is completed.

package/src/base/ranked.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * Copyright (c) 2019-2023 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 { AnyObject, hasNumberProp } from '~glsp-sprotty';
+
+/**
+ * A common interface for services/listeners that should be
+ * orderable by a type or rank/priority.
+ */
+export interface Ranked {
+    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');
+    }
+
+    /**
+     * Tries to retrieve the rank form the given object. If the object
+     * implements the {@link Ranked} interface the corresponding rank is returned
+     * otherwise the {@link DEFAULT_RANK} is returned.
+     * @param object
+     */
+    export function getRank(object: unknown): number {
+        return is(object) ? object.rank : DEFAULT_RANK;
+    }
+}

package/src/base/selection-clearing-mouse-listener.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 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,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { injectable } from 'inversify';
-import { MouseListener, SModelElement } from 'sprotty';
+import { MouseListener, SModelElement } from '~glsp-sprotty';
 
 /**
  * A mouse listener that clears the document selection on click

package/src/{features/select → base}/selection-service.spec.ts

@@ -13,25 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-/* eslint-disable import/no-deprecated,no-unused-expressions */
-import { Action, initializeContainer, SModelElementSchema } from '@eclipse-glsp/protocol';
 import { AssertionError, expect } from 'chai';
 import { Container, injectable } from 'inversify';
-import { defaultModule, SGraphFactory, SModelRoot } from 'sprotty';
-import { TYPES } from '../../base/types';
-import { IFeedbackActionDispatcher, IFeedbackEmitter } from '../tool-feedback/feedback-action-dispatcher';
-import { SelectFeedbackAction } from './select-feedback-action';
-import { SelectionListener, SelectionService } from './selection-service';
+import * as sinon from 'sinon';
+import { Action, Disposable, SGraphFactory, SModelElementSchema, SModelRoot, TYPES, initializeContainer } from '~glsp-sprotty';
+import { defaultModule } from './default.module';
+import { IFeedbackActionDispatcher, IFeedbackEmitter } from './feedback/feedback-action-dispatcher';
+import { ISelectionListener, SelectFeedbackAction, SelectionService } from './selection-service';
 
 @injectable()
 class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
     protected feedbackEmitters: Map<IFeedbackEmitter, Action[]> = new Map();
 
-    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+    registerFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): Disposable {
         this.feedbackEmitters.set(feedbackEmitter, actions);
+        return Disposable.create(() => this.deregisterFeedback(feedbackEmitter));
     }
 
-    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, actions: Action[]): void {
+    deregisterFeedback(feedbackEmitter: IFeedbackEmitter, _actions?: Action[]): void {
         this.feedbackEmitters.delete(feedbackEmitter);
     }
 
@@ -47,27 +46,9 @@ class MockFeedbackActionDispatcher implements IFeedbackActionDispatcher {
     }
 }
 
-class MockSelectionListener implements SelectionListener {
-    private called = 0;
-    private root: SModelRoot;
-    private selectedElements: string[] = [];
-
-    selectionChanged(newRoot: Readonly<SModelRoot>, selectedElements: string[]): void {
-        this.called++;
-        this.root = newRoot;
-        this.selectedElements = selectedElements;
-    }
-
-    getRoot(): SModelRoot {
-        return this.root;
-    }
-
-    getSelectedElements(): string[] {
-        return this.selectedElements;
-    }
-
-    getCalled(): number {
-        return this.called;
+class MockSelectionListener implements ISelectionListener {
+    selectionChanged(root: Readonly<SModelRoot>, selectedElements: string[], deselectedElements: string[] | undefined): void {
+        // no.op
     }
 }
 
@@ -75,9 +56,7 @@ function createContainer(): Container {
     const container = initializeContainer(new Container(), defaultModule);
     // eslint-disable-next-line deprecation/deprecation
     container.rebind(TYPES.IModelFactory).to(SGraphFactory).inSingletonScope();
-    container.bind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
-    container.bind(SelectionService).toSelf().inSingletonScope();
-    container.bind(TYPES.SelectionService).toService(SelectionService);
+    container.rebind(TYPES.IFeedbackActionDispatcher).to(MockFeedbackActionDispatcher).inSingletonScope();
     return container;
 }
 
@@ -93,7 +72,7 @@ describe('SelectionService', () => {
         // eslint-disable-next-line deprecation/deprecation
         graphFactory = container.get<SGraphFactory>(TYPES.IModelFactory);
         root = createRoot('node1', 'node2', 'node3', 'node4', 'node5');
-        selectionService = container.get<SelectionService>(TYPES.SelectionService);
+        selectionService = container.get<SelectionService>(SelectionService);
         feedbackDispatcher = container.get<MockFeedbackActionDispatcher>(TYPES.IFeedbackActionDispatcher);
     });
 
@@ -210,118 +189,56 @@ describe('SelectionService', () => {
         });
     });
     describe('Listeners', () => {
+        const sandbox = sinon.createSandbox();
+        const listener = sandbox.createStubInstance(MockSelectionListener);
+
+        beforeEach(() => {
+            selectionService.onSelectionChanged(change =>
+                listener.selectionChanged(change.root, change.selectedElements, change.deselectedElements)
+            );
+        });
+
+        afterEach(() => {
+            selectionService.dispose();
+            sandbox.reset();
+        });
         it('A registered listener should be notified of a single selection change.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1', 'node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
         it('A registered listener should be notified of a multi-selection change.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
-            assertListener(listener, root, ['node1', 'node2', 'node3'], 1);
+            assertListener(listener, root, ['node1', 'node2', 'node3'], [], 1);
         });
         it('A registered listener should be notified of series of selection changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node2'], 2);
+            assertListener(listener, root, ['node2'], ['node1'], 2);
             selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node2', 'node3', 'node4'], 3);
+            assertListener(listener, root, ['node2', 'node3', 'node4'], [], 3);
             selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node2', 'node3'], 4);
-        });
-        it('A registered listener should receive the selected elements in the right order.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node2', 'node1'], []);
-            expect(() => assertListener(listener, root, ['node1', 'node2'], 1)).to.throw(AssertionError, 'ordered members');
+            assertListener(listener, root, ['node2', 'node3'], ['node4'], 4);
         });
         it('A registered listener should be notified of root changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, [], []);
-            assertListener(listener, root, [], 1);
+            assertListener(listener, root, [], [], 1);
 
             const newRoot = createRoot('node1', 'newNode2', 'newNode3');
             selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, newRoot, [], 2);
-        });
-        it('Registering an already registered listener should have no effect.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            selectionService.register(listener);
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1', 'node2', 'node3'], []);
-            assertListener(listener, root, ['node1', 'node2', 'node3'], 1);
-            selectionService.register(listener);
-            selectionService.updateSelection(root, [], ['node2']);
-            assertListener(listener, root, ['node1', 'node3'], 2);
+            assertListener(listener, newRoot, [], [], 2);
         });
         it('Selecting the same elements consecutively should not trigger a listener update.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
         it('Selecting a not-existing elements should not trigger a listener update.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
             selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
             selectionService.updateSelection(root, ['not-existing'], []);
-            assertListener(listener, root, ['node1'], 1);
-        });
-        it('All registered listeners should be called on selection changes.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            const listener2: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            selectionService.register(listener2);
-            assertListener(listener, undefined, [], 0);
-            assertListener(listener2, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
-            assertListener(listener2, root, ['node1'], 1);
-            selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node2'], 2);
-            assertListener(listener2, root, ['node2'], 2);
-            selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node2', 'node3', 'node4'], 3);
-            assertListener(listener2, root, ['node2', 'node3', 'node4'], 3);
-            selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node2', 'node3'], 4);
-            assertListener(listener2, root, ['node2', 'node3'], 4);
-        });
-        it('A deregistered listener should not receive further updates.', () => {
-            const listener: MockSelectionListener = new MockSelectionListener();
-            selectionService.register(listener);
-            assertListener(listener, undefined, [], 0);
-            selectionService.updateSelection(root, ['node1'], []);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.deregister(listener);
-            selectionService.updateSelection(root, ['node2'], ['node1']);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.updateSelection(root, ['node3', 'node4'], []);
-            assertListener(listener, root, ['node1'], 1);
-            selectionService.updateSelection(root, [], ['node4']);
-            assertListener(listener, root, ['node1'], 1);
-
-            const newRoot = createRoot('node1', 'newNode2', 'newNode3');
-            selectionService.updateSelection(newRoot, [], []);
-            assertListener(listener, root, ['node1'], 1);
+            assertListener(listener, root, ['node1'], [], 1);
         });
     });
 
@@ -366,14 +283,15 @@ describe('SelectionService', () => {
     }
 
     function assertListener(
-        listener: MockSelectionListener,
+        listener: sinon.SinonStubbedInstance<MockSelectionListener>,
         expectedRoot: SModelRoot | undefined,
         expectedSelection: string[],
+        expectedDeselection: string[],
         expectedCalled: number
     ): void {
-        expect(listener.getRoot()).to.equal(expectedRoot);
-        expect(listener.getSelectedElements()).to.have.lengthOf(expectedSelection.length);
-        expect(listener.getSelectedElements()).to.have.ordered.members(expectedSelection);
-        expect(listener.getCalled()).to.equal(expectedCalled);
+        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);
     }
 });