@eclipse-glsp/client 1.1.0-next.fe0b297.182 → 2.0.0

package/src/standalone-modules.ts

@@ -0,0 +1,103 @@
+/********************************************************************************
+ * 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 {
+    Action,
+    EndProgressAction,
+    FeatureModule,
+    GModelElement,
+    IActionHandler,
+    ICommand,
+    ILogger,
+    KeyListener,
+    LayoutOperation,
+    MessageAction,
+    ModuleConfiguration,
+    StartProgressAction,
+    TYPES,
+    UpdateProgressAction,
+    bindAsService,
+    configureActionHandler,
+    matchesKeystroke
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { standaloneCopyPasteModule } from './features/copy-paste/copy-paste-modules';
+import { standaloneExportModule } from './features/export/export-modules';
+import { saveModule } from './features/save/save-module';
+import { standaloneSelectModule } from './features/select/select-module';
+import { undoRedoModule } from './features/undo-redo/undo-redo-module';
+import { standaloneMarkerNavigatorModule } from './features/validation/validation-modules';
+import { standaloneViewportModule } from './features/viewport/viewport-modules';
+
+export const standaloneDefaultModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    bind(FallbackActionHandler).toSelf().inSingletonScope();
+    configureActionHandler(context, MessageAction.KIND, FallbackActionHandler);
+    configureActionHandler(context, StartProgressAction.KIND, FallbackActionHandler);
+    configureActionHandler(context, UpdateProgressAction.KIND, FallbackActionHandler);
+    configureActionHandler(context, EndProgressAction.KIND, FallbackActionHandler);
+    bindAsService(context, TYPES.KeyListener, LayoutKeyListener);
+});
+
+/**
+ * A fallback action handler for actions sent by features that are currently not supported by
+ * default in the standalone context. Unhandled actions will be simply forwarded to the {@link ILogger}.
+ */
+@injectable()
+export class FallbackActionHandler implements IActionHandler {
+    @inject(TYPES.ILogger)
+    protected logger: ILogger;
+
+    handle(action: Action): void | Action | ICommand {
+        this.logger.log(this, 'Unhandled action received:', action);
+    }
+}
+
+@injectable()
+export class LayoutKeyListener extends KeyListener {
+    override keyDown(_element: GModelElement, event: KeyboardEvent): Action[] {
+        if (matchesKeystroke(event, 'KeyL', 'ctrlCmd', 'shift')) {
+            return [LayoutOperation.create()];
+        }
+        return [];
+    }
+}
+
+/**
+ * Configuration of all `standalone` modules.
+ *
+ * Standalone modules compose additional features/services that are intended for the standalone deployment of GLSP (i.e. plain webapp)
+ * When integrated into an application frame (e.g Theia/VS Code) this module is typically omitted and/or replaced
+ * with an application native module.
+ *
+ * Typically standalone modules built on top of (i.e require ) a default module and are therefore conditionally loaded if the
+ * required default modules have been loaded beforehand.
+ */
+
+export const STANDALONE_MODULES = [
+    standaloneViewportModule,
+    standaloneCopyPasteModule,
+    standaloneMarkerNavigatorModule,
+    standaloneSelectModule,
+    standaloneExportModule,
+    standaloneDefaultModule,
+    saveModule,
+    undoRedoModule
+] as const;
+
+export const STANDALONE_MODULE_CONFIG: ModuleConfiguration = {
+    add: [...STANDALONE_MODULES]
+};

package/src/utils/argument-utils.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021 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
@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElement } from 'sprotty';
-import { hasArguments } from '../base/argumentable';
+import { GModelElement } from '@eclipse-glsp/sprotty';
+import { hasArgs } from '../base/args-feature';
 
 export namespace GArgument {
     export function asNumber(argValue: string | number | boolean): number | undefined {
@@ -41,24 +41,24 @@ export namespace GArgument {
         return argValues.map(asBoolean);
     }
 
-    export function getArgument(element: SModelElement | undefined, key: string): string | number | boolean | undefined {
-        return hasArguments(element) ? element.args[key] : undefined;
+    export function getArgument(element: GModelElement | undefined, key: string): string | number | boolean | undefined {
+        return hasArgs(element) ? element.args[key] : undefined;
     }
 
-    export function getNumber(element: SModelElement | undefined, key: string): number | undefined {
-        return hasArguments(element) ? asNumber(element.args[key]) : undefined;
+    export function getNumber(element: GModelElement | undefined, key: string): number | undefined {
+        return hasArgs(element) ? asNumber(element.args[key]) : undefined;
     }
 
-    export function getString(element: SModelElement | undefined, key: string): string | undefined {
-        return hasArguments(element) ? asString(element.args[key]) : undefined;
+    export function getString(element: GModelElement | undefined, key: string): string | undefined {
+        return hasArgs(element) ? asString(element.args[key]) : undefined;
     }
 
-    export function getBoolean(element: SModelElement | undefined, key: string): boolean | undefined {
-        return hasArguments(element) ? asBoolean(element.args[key]) : undefined;
+    export function getBoolean(element: GModelElement | undefined, key: string): boolean | undefined {
+        return hasArgs(element) ? asBoolean(element.args[key]) : undefined;
     }
 
-    export function getArguments(element: SModelElement | undefined, ...keys: string[]): (number | boolean | string)[] | undefined {
-        if (!hasArguments(element)) {
+    export function getArguments(element: GModelElement | undefined, ...keys: string[]): (number | boolean | string)[] | undefined {
+        if (!hasArgs(element)) {
             return undefined;
         }
         const values = [];
@@ -71,17 +71,17 @@ export namespace GArgument {
         return values;
     }
 
-    export function getNumbers(element: SModelElement | undefined, ...keys: string[]): (number | undefined)[] | undefined {
+    export function getNumbers(element: GModelElement | undefined, ...keys: string[]): (number | undefined)[] | undefined {
         const values = getArguments(element, ...keys);
         return values ? asNumbers(values) : undefined;
     }
 
-    export function getStrings(element: SModelElement | undefined, ...keys: string[]): (string | undefined)[] | undefined {
+    export function getStrings(element: GModelElement | undefined, ...keys: string[]): (string | undefined)[] | undefined {
         const values = getArguments(element, ...keys);
         return values ? asStrings(values) : undefined;
     }
 
-    export function getBooleans(element: SModelElement | undefined, ...keys: string[]): (boolean | undefined)[] | undefined {
+    export function getBooleans(element: GModelElement | undefined, ...keys: string[]): (boolean | undefined)[] | undefined {
         const values = getArguments(element, ...keys);
         return values ? asBooleans(values) : undefined;
     }
@@ -94,7 +94,7 @@ export namespace GArgument {
 export namespace EdgePadding {
     const KEY = 'edgePadding';
 
-    export function from(element: SModelElement | undefined): number | undefined {
+    export function from(element: GModelElement | undefined): number | undefined {
         return GArgument.getNumber(element, KEY);
     }
 }
@@ -114,7 +114,7 @@ export class CornerRadius {
         public readonly bottomLeft: number = topRight
     ) {}
 
-    static from(element: SModelElement | undefined): CornerRadius | undefined {
+    static from(element: GModelElement | undefined): CornerRadius | undefined {
         const radius = GArgument.getNumbers(
             element,
             this.KEY_RADIUS_TOP_LEFT,

package/src/utils/gmodel-util.spec.ts

@@ -0,0 +1,221 @@
+/********************************************************************************
+ * 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 {
+    AbstractEdgeRouter,
+    EdgeRouterRegistry,
+    GNode,
+    GRoutableElement,
+    GRoutingHandle,
+    LinearRouteOptions,
+    Point,
+    ResolvedHandleMove,
+    RoutedPoint
+} from '@eclipse-glsp/sprotty';
+import { expect } from 'chai';
+import { Container } from 'inversify';
+import { routingModule } from '../features/routing/routing-module';
+import { ALL_ROUTING_POINTS, ROUTE_KINDS, ROUTING_POINT_KINDS, calcRoute } from './gmodel-util';
+import { GEdge, GGraph } from '../model';
+
+class TestRouter extends AbstractEdgeRouter {
+    kind = 'test-router';
+
+    route(edge: GRoutableElement): RoutedPoint[] {
+        const pureRoute = edge.routingPoints.map(
+            (point, idx) =>
+                <RoutedPoint>{
+                    kind: 'linear',
+                    ...point,
+                    pointIndex: idx
+                }
+        );
+        return [
+            { kind: 'source', ...edge.source!.position },
+            ...pureRoute,
+            { kind: 'bezier-control-after', x: 999, y: 999, pointIndex: pureRoute.length },
+            { kind: 'target', ...edge.target!.position }
+        ];
+    }
+
+    createRoutingHandles(edge: GRoutableElement): void {
+        // do nothing
+    }
+
+    protected getOptions(edge: GRoutableElement): LinearRouteOptions {
+        return {
+            minimalPointDistance: 0,
+            selfEdgeOffset: 0,
+            standardDistance: 0
+        };
+    }
+
+    protected getInnerHandlePosition(edge: GRoutableElement, route: RoutedPoint[], handle: GRoutingHandle): Point | undefined {
+        return undefined;
+    }
+
+    protected applyInnerHandleMoves(edge: GRoutableElement, moves: ResolvedHandleMove[]): void {
+        // do nothing
+    }
+}
+
+describe('SModel Util', () => {
+    describe('calcRoute', () => {
+        const graph = new GGraph();
+
+        const source = new GNode();
+        source.id = 'node0';
+        source.position = { x: 0, y: 0 };
+        source.size = { width: 0, height: 0 };
+        graph.add(source);
+
+        const target = new GNode();
+        target.id = 'node1';
+        target.position = { x: 100, y: 100 };
+        target.size = { width: 0, height: 0 };
+        graph.add(target);
+
+        const edge = new GEdge();
+        edge.id = 'edge0';
+        edge.sourceId = 'node0';
+        edge.targetId = 'node1';
+        graph.add(edge);
+
+        edge.routerKind = 'test-router';
+
+        const container = new Container();
+        container.load(routingModule);
+
+        const routerRegistry = container.get<EdgeRouterRegistry>(EdgeRouterRegistry);
+        routerRegistry.register('test-router', new TestRouter());
+
+        it('should return complete route', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+            const route = calcRoute(edge, routerRegistry);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 3 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should filter duplicates with same coordinates', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 2 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 3 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 4 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should not filter source and target even if duplicate coordinates', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 0, y: 0 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 3 },
+                { x: 0, y: 0, kind: 'target' }
+            ]);
+        });
+
+        it('should filter duplicates with same coordinates but allow tolerance', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 25, y: 25 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry, ALL_ROUTING_POINTS, 10);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 2 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 3 },
+                { x: 999, y: 999, kind: 'bezier-control-after', pointIndex: 4 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should allow filtering based on point type: ROUTE_KINDS', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry, ROUTE_KINDS);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 0, y: 0, kind: 'source' },
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 },
+                { x: 100, y: 100, kind: 'target' }
+            ]);
+        });
+
+        it('should allow filtering based on point type: ROUTING_POINT_KINDS', () => {
+            edge.source!.position = { x: 0, y: 0 };
+            edge.target!.position = { x: 100, y: 100 };
+            edge.routingPoints = [
+                { x: 20, y: 20 },
+                { x: 30, y: 30 },
+                { x: 40, y: 40 }
+            ];
+
+            const route = calcRoute(edge, routerRegistry, ROUTING_POINT_KINDS);
+            expect(route).to.deep.equal(<RoutedPoint[]>[
+                { x: 20, y: 20, kind: 'linear', pointIndex: 0 },
+                { x: 30, y: 30, kind: 'linear', pointIndex: 1 },
+                { x: 40, y: 40, kind: 'linear', pointIndex: 2 }
+            ]);
+        });
+    });
+});