@eclipse-glsp/client 2.1.0-next.301 → 2.1.0-next.302

package/src/features/change-bounds/point-position-updater.ts

@@ -0,0 +1,120 @@
+/********************************************************************************
+ * 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
+ * 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
+ ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-shadow */
+import { GModelElement, ISnapper, Point, Writable } from '@eclipse-glsp/sprotty';
+import { calculateDeltaBetweenPoints } from '../../utils/gmodel-util';
+import { isMouseEvent } from '../../utils/html-utils';
+import { IHelperLineManager } from '../helper-lines/helper-line-manager';
+import { Direction, getDirectionOf } from '../helper-lines/model';
+import { PositionSnapper } from './position-snapper';
+import { useSnap } from './snap';
+
+/**
+ * This class can be used to calculate the current position, when an element is
+ * moved. This includes node movements, node resizing (resize handle movement)
+ * or edge routing-point movements.
+ *
+ * You can initialize a this class with a optional {@link ISnapper}. If a
+ * snapper is present, the positions will be snapped to the defined grid.
+ */
+export class PointPositionUpdater {
+    protected positionSnapper: PositionSnapper;
+    protected lastDragPosition?: Point;
+    protected positionDelta: Writable<Point> = { x: 0, y: 0 };
+
+    constructor(snapper?: PositionSnapper);
+    constructor(snapper?: ISnapper, helperLineManager?: IHelperLineManager);
+    constructor(first?: PositionSnapper | ISnapper, helperLineManager?: IHelperLineManager) {
+        this.positionSnapper = first instanceof PositionSnapper ? first : new PositionSnapper(first, helperLineManager);
+    }
+
+    /**
+     * Init the position with the {@link Point} of your mouse cursor.
+     * This method is normally called in the `mouseDown` event.
+     * @param mousePosition current mouse position e.g `{x: event.pageX, y: event.pageY }`
+     */
+    public updateLastDragPosition(mousePosition: Point): void;
+    public updateLastDragPosition(mouseEvent: MouseEvent): void;
+    public updateLastDragPosition(first: Point | MouseEvent): void {
+        this.lastDragPosition = isMouseEvent(first) ? { x: first.pageX, y: first.pageY } : first;
+    }
+
+    /**
+     * Check if the mouse is currently not in a drag mode.
+     * @returns true if the last drag position is undefined
+     */
+    public isLastDragPositionUndefined(): boolean {
+        return this.lastDragPosition === undefined;
+    }
+
+    /**
+     * Reset the updater for new movements.
+     * This method is normally called in the `mouseUp` event.
+     */
+    public resetPosition(): void {
+        this.lastDragPosition = undefined;
+        this.positionDelta = { x: 0, y: 0 };
+    }
+
+    /**
+     * Calculate the current position of your movement.
+     * This method is normally called in the `mouseMove` event.
+     * @param target node which is moved around
+     * @param mousePosition current mouse position e.g `{x: event.pageX, y: event.pageY }`
+     * @param useSnap if a snapper is defined you can disable it, e.g when a specific key is pressed `!event.shiftKey`
+     * @param direction the direction in which the position is updated, will be calculated if not provided
+     * @returns delta to previous position or undefined if no delta should be applied
+     */
+    public updatePosition(target: GModelElement, mousePosition: Point, useSnap: boolean, direction?: Direction[]): Point | undefined;
+    public updatePosition(target: GModelElement, mouseEvent: MouseEvent, direction?: Direction[]): Point | undefined;
+    public updatePosition(
+        target: GModelElement,
+        second: Point | MouseEvent,
+        third?: boolean | Direction[],
+        fourth?: Direction[]
+    ): Point | undefined {
+        if (!this.lastDragPosition) {
+            return undefined;
+        }
+        const mousePosition = isMouseEvent(second) ? { x: second.pageX, y: second.pageY } : second;
+        const shouldSnap = typeof third === 'boolean' ? third : useSnap(second as MouseEvent);
+        const direction = typeof third !== 'boolean' ? third : fourth;
+
+        // calculate update to last drag position
+        const deltaToLastPosition = calculateDeltaBetweenPoints(mousePosition, this.lastDragPosition, target);
+        this.lastDragPosition = mousePosition;
+        if (Point.equals(deltaToLastPosition, Point.ORIGIN)) {
+            return undefined;
+        }
+
+        // accumulate position delta with latest delta
+        this.positionDelta.x += deltaToLastPosition.x;
+        this.positionDelta.y += deltaToLastPosition.y;
+
+        const directions = direction ?? getDirectionOf(this.positionDelta);
+
+        // only send update if the position actually changes
+        // otherwise accumulate delta until we get to an update
+        const positionUpdate = this.positionSnapper.snapDelta(this.positionDelta, target, shouldSnap, directions);
+        if (Point.equals(positionUpdate, Point.ORIGIN)) {
+            return undefined;
+        }
+        // we update our position so we update our delta by the snapped position
+        this.positionDelta.x -= positionUpdate.x;
+        this.positionDelta.y -= positionUpdate.y;
+        return positionUpdate;
+    }
+}

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

@@ -0,0 +1,69 @@
+/********************************************************************************
+ * 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 { GModelElement, ISnapper, Point, TYPES, Writable } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { IHelperLineManager } from '../helper-lines/helper-line-manager';
+import { Direction, HelperLine, isHelperLine } from '../helper-lines/model';
+
+@injectable()
+export class PositionSnapper {
+    constructor(
+        @optional() @inject(TYPES.ISnapper) protected snapper?: ISnapper,
+        @optional() @inject(TYPES.IHelperLineManager) protected helperLineManager?: IHelperLineManager
+    ) {}
+
+    snapPosition(position: Point, element: GModelElement, isSnap: boolean = true): Point {
+        return isSnap && this.snapper ? this.snapper.snap(position, element) : { x: position.x, y: position.y };
+    }
+
+    snapDelta(positionDelta: Point, element: GModelElement, isSnap: boolean, directions: Direction[]): Point {
+        const delta: Writable<Point> = this.snapPosition(positionDelta, element, isSnap);
+        const minimumDelta = this.getMinimumDelta(element, isSnap, directions);
+        if (!minimumDelta) {
+            return delta;
+        }
+        delta.x = Math.abs(delta.x) >= minimumDelta.x ? delta.x : 0;
+        delta.y = Math.abs(delta.y) >= minimumDelta.y ? delta.y : 0;
+        return delta;
+    }
+
+    protected getMinimumDelta(target: GModelElement, isSnap: boolean, directions: Direction[]): Point | undefined {
+        return this.getHelperLineMinimum(target, isSnap, directions);
+    }
+
+    protected getHelperLineMinimum(target: GModelElement, isSnap: boolean, directions: Direction[]): Point | undefined {
+        if (!this.helperLineManager) {
+            return undefined;
+        }
+        const helperLines = target.root.children.filter(child => isHelperLine(child)) as HelperLine[];
+        if (helperLines.length === 0) {
+            return undefined;
+        }
+
+        const minimum: Writable<Point> = { x: 0, y: 0 };
+        if (directions.includes(Direction.Left) && helperLines.some(line => line.isLeft || line.isCenter)) {
+            minimum.x = this.helperLineManager.getHelperLineSnapping(target, isSnap, Direction.Left);
+        } else if (directions.includes(Direction.Right) && helperLines.some(line => line.isRight || line.isCenter)) {
+            minimum.x = this.helperLineManager.getHelperLineSnapping(target, isSnap, Direction.Right);
+        }
+        if (directions.includes(Direction.Up) && helperLines.some(line => line.isTop || line.isMiddle)) {
+            minimum.y = this.helperLineManager.getHelperLineSnapping(target, isSnap, Direction.Up);
+        } else if (directions.includes(Direction.Down) && helperLines.some(line => line.isBottom || line.isMiddle)) {
+            minimum.y = this.helperLineManager.getHelperLineSnapping(target, isSnap, Direction.Down);
+        }
+        return minimum;
+    }
+}

package/src/features/change-bounds/snap.spec.ts

@@ -14,9 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { expect } from 'chai';
 import { GModelElement } from '@eclipse-glsp/sprotty';
-import { GridSnapper, PointPositionUpdater } from './snap';
+import { expect } from 'chai';
+import { PointPositionUpdater } from './point-position-updater';
+import { GridSnapper } from './snap';
 
 describe('GridSnapper', () => {
     it('snap', () => {

package/src/features/change-bounds/snap.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-shadow */
+import { GModelElement, ISnapper, KeyboardModifier, Point } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
-import { ISnapper, Point, GModelElement, Writable, findParentByFeature, isViewport } from '@eclipse-glsp/sprotty';
 
 /**
  * A {@link ISnapper} implementation that snaps all elements onto a fixed gride size.
@@ -30,7 +31,7 @@ import { ISnapper, Point, GModelElement, Writable, findParentByFeature, isViewpo
 export class GridSnapper implements ISnapper {
     constructor(public grid: { x: number; y: number } = { x: 10, y: 10 }) {}
 
-    snap(position: Point, element: GModelElement): Point {
+    snap(position: Point, _element: GModelElement): Point {
         return {
             x: Math.round(position.x / this.grid.x) * this.grid.x,
             y: Math.round(position.y / this.grid.y) * this.grid.y
@@ -38,85 +39,10 @@ export class GridSnapper implements ISnapper {
     }
 }
 
-/**
- * This class can be used to calculate the current position, when an element is
- * moved. This includes node movements, node resizing (resize handle movement)
- * or edge routing-point movements.
- *
- * You can initialize a this class with a optional {@link ISnapper}. If a
- * snapper is present, the positions will be snapped to the defined grid.
- */
-export class PointPositionUpdater {
-    protected lastDragPosition?: Point;
-    protected positionDelta: Writable<Point> = { x: 0, y: 0 };
-
-    constructor(protected snapper?: ISnapper) {}
-
-    /**
-     * Init the position with the {@link Point} of your mouse cursor.
-     * This method is normally called in the `mouseDown` event.
-     * @param mousePosition current mouse position e.g `{x: event.pageX, y: event.pageY }`
-     */
-    public updateLastDragPosition(mousePosition: Point): void {
-        this.lastDragPosition = mousePosition;
-    }
-
-    /**
-     * Check if the mouse is currently not in a drag mode.
-     * @returns true if the last drag position is undefined
-     */
-    public isLastDragPositionUndefined(): boolean {
-        return this.lastDragPosition === undefined;
-    }
-
-    /**
-     * Reset the updater for new movements.
-     * This method is normally called in the `mouseUp` event.
-     */
-    public resetPosition(): void {
-        this.lastDragPosition = undefined;
-        this.positionDelta = { x: 0, y: 0 };
-    }
-
-    /**
-     * Calculate the current position of your movement.
-     * This method is normally called in the `mouseMove` event.
-     * @param target node which is moved around
-     * @param mousePosition current mouse position e.g `{x: event.pageX, y: event.pageY }`
-     * @param isSnapEnabled if a snapper is defined you can disable it, e.g when a specific key is pressed `!event.altKey`
-     * @returns current position or undefined if updater has no last drag position initialized
-     */
-    public updatePosition(target: GModelElement, mousePosition: Point, isSnapEnabled: boolean): Point | undefined {
-        if (this.lastDragPosition) {
-            const newDragPosition = mousePosition;
-
-            const viewport = findParentByFeature(target, isViewport);
-            const zoom = viewport?.zoom ?? 1;
-            const dx = (mousePosition.x - this.lastDragPosition.x) / zoom;
-            const dy = (mousePosition.y - this.lastDragPosition.y) / zoom;
-            const deltaToLastPosition = { x: dx, y: dy };
-            this.lastDragPosition = newDragPosition;
-
-            // update position delta with latest delta
-            this.positionDelta.x += deltaToLastPosition.x;
-            this.positionDelta.y += deltaToLastPosition.y;
-
-            // snap our delta and only send update if the position actually changes
-            // otherwise accumulate delta until we do snap to an update
-            const positionUpdate = this.snap(this.positionDelta, target, isSnapEnabled);
-            if (positionUpdate.x === 0 && positionUpdate.y === 0) {
-                return undefined;
-            }
-
-            // we update our position so we update our delta by the snapped position
-            this.positionDelta.x -= positionUpdate.x;
-            this.positionDelta.y -= positionUpdate.y;
-            return positionUpdate;
-        }
-        return undefined;
-    }
+export function useSnap(event: MouseEvent | KeyboardEvent): boolean {
+    return !event.shiftKey;
+}
 
-    protected snap(position: Point, element: GModelElement, isSnap: boolean): Point {
-        return isSnap && this.snapper ? this.snapper.snap(position, element) : { x: position.x, y: position.y };
-    }
+export function unsnapModifier(): KeyboardModifier {
+    return 'shift';
 }

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

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './command-palette-module';
+export * from './command-palette-tool';
+export * from './server-command-palette-provider';

package/src/features/context-menu/index.ts

@@ -0,0 +1,19 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './context-menu-module';
+export * from './delete-element-context-menu';
+export * from './glsp-context-menu-mouse-listener';
+export * from './server-context-menu-provider';

package/src/features/copy-paste/index.ts

@@ -0,0 +1,19 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './copy-paste-context-menu';
+export * from './copy-paste-handler';
+export * from './copy-paste-modules';
+export * from './copy-paste-standalone';

package/src/features/decoration/index.ts

@@ -0,0 +1,17 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './decoration-module';
+export * from './decoration-placer';

package/src/features/element-template/index.ts

@@ -0,0 +1,19 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './add-template-element';
+export * from './element-template-module';
+export * from './mouse-tracking-element-position-listener';
+export * from './remove-template-element';

package/src/features/element-template/mouse-tracking-element-position-listener.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Action, Disposable, GModelElement, ISnapper, MoveAction, Point, isBoundsAware, isMoveable } from '@eclipse-glsp/sprotty';
+import { Action, Disposable, GModelElement, Locateable, MoveAction, Point, isBoundsAware, isMoveable } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
 import { DragAwareMouseListener } from '../../base/drag-aware-mouse-listener';
 import { CSS_HIDDEN, ModifyCSSFeedbackAction } from '../../base/feedback/css-feedback';
@@ -26,9 +26,12 @@ import {
     createMovementRestrictionFeedback,
     removeMovementRestrictionFeedback
 } from '../change-bounds/movement-restrictor';
+import { PositionSnapper } from '../change-bounds/position-snapper';
+import { PointPositionUpdater } from '../change-bounds/point-position-updater';
+import { useSnap } from '../change-bounds/snap';
 
 export interface PositioningTool extends Tool {
-    readonly snapper?: ISnapper;
+    readonly positionSnapper: PositionSnapper;
     readonly movementRestrictor?: IMovementRestrictor;
 
     registerFeedback(feedbackActions: Action[], feedbackEmitter?: IFeedbackEmitter, cleanupActions?: Action[]): Disposable;
@@ -37,57 +40,61 @@ export interface PositioningTool extends Tool {
 
 @injectable()
 export class MouseTrackingElementPositionListener extends DragAwareMouseListener {
-    element?: GModelElement;
     currentPosition?: Point;
 
+    protected positionUpdater: PointPositionUpdater;
+
     constructor(
         protected elementId: string,
         protected tool: PositioningTool,
         protected cursorPosition: 'top-left' | 'middle' = 'top-left'
     ) {
         super();
+        this.positionUpdater = new PointPositionUpdater(this.tool.positionSnapper);
     }
 
     override mouseMove(target: GModelElement, event: MouseEvent): Action[] {
         super.mouseMove(target, event);
         const element = target.root.index.getById(this.elementId);
-        this.element = element;
-        if (!element) {
+        if (!element || !isMoveable(element)) {
             return [];
         }
-
-        let newPosition = getAbsolutePosition(target, event);
-        if (this.cursorPosition === 'middle' && isBoundsAware(element)) {
-            newPosition = Point.subtract(newPosition, { x: element.bounds.width / 2, y: element.bounds.height / 2 });
+        let targetPosition = this.getTargetPosition(target, event, element);
+        if (this.positionUpdater.isLastDragPositionUndefined()) {
+            this.positionUpdater.updateLastDragPosition(targetPosition);
         }
-        newPosition = this.snap(newPosition, element);
-
-        const finished = false;
-        if (isMoveable(element)) {
-            newPosition = this.validateMove(this.currentPosition ?? newPosition, newPosition, element, finished);
+        const delta = this.positionUpdater.updatePosition(element, targetPosition, useSnap(event));
+        if (!delta) {
+            return [];
         }
-        this.currentPosition = newPosition;
+        targetPosition = this.validateMove(this.currentPosition ?? targetPosition, targetPosition, element, false);
         const moveGhostElement = MoveAction.create(
             [
                 {
                     elementId: element.id,
-                    toPosition: newPosition
+                    fromPosition: this.currentPosition,
+                    toPosition: targetPosition
                 }
             ],
-            { animate: false, finished }
+            { animate: false, finished: false }
         );
+        this.currentPosition = targetPosition;
         this.tool.registerFeedback([moveGhostElement], this);
         return element.cssClasses?.includes(CSS_HIDDEN)
             ? [ModifyCSSFeedbackAction.create({ elements: [element.id], remove: [CSS_HIDDEN] })]
             : [];
     }
 
-    protected snap(position: Point, element: GModelElement, isSnap = true): Point {
-        if (isSnap && this.tool.snapper) {
-            return this.tool.snapper.snap(position, element);
-        } else {
-            return position;
+    protected getTargetPosition(target: GModelElement, event: MouseEvent, element: GModelElement & Locateable): Point {
+        let targetPosition = getAbsolutePosition(target, event);
+        if (this.cursorPosition === 'middle' && isBoundsAware(element)) {
+            targetPosition = Point.subtract(targetPosition, { x: element.bounds.width / 2, y: element.bounds.height / 2 });
         }
+        return targetPosition;
+    }
+
+    protected snap(position: Point, element: GModelElement, isSnap = true): Point {
+        return this.tool.positionSnapper.snapPosition(position, element, isSnap);
     }
 
     protected validateMove(startPosition: Point, toPosition: Point, element: GModelElement, isFinished: boolean): Point {

package/src/features/export/index.ts

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+export * from './export-modules';
+export * from './export-svg-action-handler';
+export * from './glsp-svg-exporter';