@eclipse-glsp/client 2.4.0-next.409 → 2.4.0-next.413

package/src/features/{accessibility/move-zoom/move-handler.ts → change-bounds/move-element-handler.ts}

@@ -19,127 +19,28 @@ import {
     ChangeBoundsOperation,
     ElementAndBounds,
     ElementMove,
-    GModelRoot,
     IActionDispatcher,
     IActionHandler,
     ICommand,
     ISnapper,
     MoveAction,
+    MoveViewportAction,
     Point,
-    SetViewportAction,
     TYPES,
-    Viewport,
     findParentByFeature,
     isBoundsAware,
     isViewport
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional, postConstruct } from 'inversify';
 import { DebouncedFunc, debounce } from 'lodash';
-import { EditorContextService } from '../../../base/editor-context-service';
-import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
-import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
-import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware } from '../../../utils/gmodel-util';
-import { isValidMove } from '../../../utils/layout-utils';
-import { outsideOfViewport } from '../../../utils/viewpoint-util';
-import { IMovementRestrictor } from '../../change-bounds/movement-restrictor';
-
-/**
- * Action for triggering moving of the viewport.
- */
-export interface MoveViewportAction extends Action {
-    kind: typeof MoveViewportAction.KIND;
-    /**
-     * used to specify the amount to be moved in the x-axis
-     */
-    moveX: number;
-    /**
-     * used to specify the amount to be moved in the y-axis
-     */
-    moveY: number;
-}
-
-export namespace MoveViewportAction {
-    export const KIND = 'moveViewportAction';
-
-    export function is(object: any): object is MoveViewportAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(moveX: number, moveY: number): MoveViewportAction {
-        return { kind: KIND, moveX, moveY };
-    }
-}
-
-/**
- * Action for triggering moving of elements.
- */
-export interface MoveElementAction extends Action {
-    kind: typeof MoveElementAction.KIND;
-    /**
-     * used to specify the elements to be zoomed in/out
-     */
-    elementIds: string[];
-    /**
-     * used to specify the amount to be moved in the x-axis
-     */
-    moveX: number;
-    /**
-     * used to specify the amount to be moved in the y-axis
-     */
-    moveY: number;
-    /**
-     * used to specify whether we should snap to the grid
-     */
-    snap: boolean;
-}
-
-export namespace MoveElementAction {
-    export const KIND = 'moveElementAction';
-
-    export function is(object: any): object is MoveElementAction {
-        return Action.hasKind(object, KIND);
-    }
-
-    export function create(elementIds: string[], moveX: number, moveY: number, snap: boolean = true): MoveElementAction {
-        return { kind: KIND, elementIds, moveX, moveY, snap };
-    }
-}
-
-/**
- * Action handler for moving of the viewport.
- */
-@injectable()
-export class MoveViewportHandler implements IActionHandler {
-    @inject(EditorContextService)
-    protected editorContextService: EditorContextService;
-    @inject(TYPES.IActionDispatcher)
-    protected dispatcher: IActionDispatcher;
-
-    handle(action: Action): void | Action | ICommand {
-        if (MoveViewportAction.is(action)) {
-            this.handleMoveViewport(action);
-        }
-    }
-
-    handleMoveViewport(action: MoveViewportAction): void {
-        const viewport = findParentByFeature(this.editorContextService.modelRoot, isViewport);
-        if (!viewport) {
-            return;
-        }
-        this.dispatcher.dispatch(this.moveViewport(viewport, action.moveX, action.moveY));
-    }
-
-    protected moveViewport(viewport: GModelRoot & Viewport, offsetX: number, offSetY: number): SetViewportAction {
-        const newViewport: Viewport = {
-            scroll: {
-                x: viewport.scroll.x + offsetX,
-                y: viewport.scroll.y + offSetY
-            },
-            zoom: viewport.zoom
-        };
-        return SetViewportAction.create(viewport.id, newViewport, { animate: false });
-    }
-}
+import { EditorContextService } from '../../base/editor-context-service';
+import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackEmitter } from '../../base/feedback/feedback-emitter';
+import { SelectableBoundsAware, getElements, isSelectableAndBoundsAware } from '../../utils/gmodel-util';
+import { isValidMove } from '../../utils/layout-utils';
+import { outsideOfViewport } from '../../utils/viewpoint-util';
+import { IMovementRestrictor } from '../change-bounds/movement-restrictor';
+import { MoveElementRelativeAction } from './move-element-action';
 
 /**
  * Action handler for moving elements.
@@ -172,12 +73,12 @@ export class MoveElementHandler implements IActionHandler {
     }
 
     handle(action: Action): void | Action | ICommand {
-        if (MoveElementAction.is(action)) {
+        if (MoveElementRelativeAction.is(action)) {
             this.handleMoveElement(action);
         }
     }
 
-    handleMoveElement(action: MoveElementAction): void {
+    protected handleMoveElement(action: MoveElementRelativeAction): void {
         const modelRoot = this.editorContextService.modelRoot;
         const viewport = findParentByFeature(modelRoot, isViewport);
         if (!viewport) {
@@ -197,8 +98,12 @@ export class MoveElementHandler implements IActionHandler {
                 },
                 toPosition: newPosition
             });
-            if (outsideOfViewport(newPosition, viewport)) {
-                viewportActions.push(MoveViewportAction.create(action.moveX, action.moveY));
+
+            const topLeftCorner = newPosition;
+            const bottomRightCorner = Point.add(newPosition, { x: element.bounds.width, y: element.bounds.height });
+
+            if (outsideOfViewport(topLeftCorner, viewport) || outsideOfViewport(bottomRightCorner, viewport)) {
+                viewportActions.push(MoveViewportAction.create({ moveX: action.moveX, moveY: action.moveY }));
             }
         }
 
@@ -209,7 +114,7 @@ export class MoveElementHandler implements IActionHandler {
         this.scheduleChangeBounds(this.toElementAndBounds(elementMoves));
     }
 
-    protected getTargetBounds(element: SelectableBoundsAware, action: MoveElementAction): Point {
+    protected getTargetBounds(element: SelectableBoundsAware, action: MoveElementRelativeAction): Point {
         let position = Point.add(element.bounds, { x: action.moveX, y: action.moveY });
         if (this.snapper && action.snap) {
             position = this.snapper.snap(position, element);

package/src/features/change-bounds/move-element-key-listener.ts

@@ -0,0 +1,74 @@
+/********************************************************************************
+ * Copyright (c) 2025 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 { isMoveable, KeyListener, matchesKeystroke, type Action, type GModelElement } from '@eclipse-glsp/sprotty';
+import type { SelectionService } from '../../base/selection-service';
+import { Grid } from '../grid/grid';
+import type { IChangeBoundsManager } from '../tools/change-bounds/change-bounds-manager';
+import { MoveElementRelativeAction } from './move-element-action';
+
+export class MoveElementKeyListener extends KeyListener {
+    constructor(
+        protected readonly selectionService: SelectionService,
+        protected readonly changeBoundsManager: IChangeBoundsManager,
+        protected readonly grid: Grid = Grid.DEFAULT
+    ) {
+        super();
+    }
+
+    override keyDown(_element: GModelElement, event: KeyboardEvent): Action[] {
+        const selectedElementIds = this.selectionService
+            .getSelectedElements()
+            .filter(element => isMoveable(element))
+            .map(element => element.id);
+        const snap = this.changeBoundsManager.usePositionSnap(event);
+        const offsetX = snap ? this.grid.x : 1;
+        const offsetY = snap ? this.grid.y : 1;
+
+        if (selectedElementIds.length > 0) {
+            if (this.matchesMoveUpKeystroke(event)) {
+                return [MoveElementRelativeAction.create({ elementIds: selectedElementIds, moveX: 0, moveY: -offsetY, snap })];
+            } else if (this.matchesMoveDownKeystroke(event)) {
+                return [MoveElementRelativeAction.create({ elementIds: selectedElementIds, moveX: 0, moveY: offsetY, snap })];
+            } else if (this.matchesMoveRightKeystroke(event)) {
+                return [MoveElementRelativeAction.create({ elementIds: selectedElementIds, moveX: offsetX, moveY: 0, snap })];
+            } else if (this.matchesMoveLeftKeystroke(event)) {
+                return [MoveElementRelativeAction.create({ elementIds: selectedElementIds, moveX: -offsetX, moveY: 0, snap })];
+            }
+        }
+        return [];
+    }
+
+    protected matchesMoveUpKeystroke(event: KeyboardEvent): boolean {
+        const unsnap = this.changeBoundsManager.unsnapModifier();
+        return matchesKeystroke(event, 'ArrowUp') || (!!unsnap && matchesKeystroke(event, 'ArrowUp', unsnap));
+    }
+
+    protected matchesMoveDownKeystroke(event: KeyboardEvent): boolean {
+        const unsnap = this.changeBoundsManager.unsnapModifier();
+        return matchesKeystroke(event, 'ArrowDown') || (!!unsnap && matchesKeystroke(event, 'ArrowDown', unsnap));
+    }
+
+    protected matchesMoveRightKeystroke(event: KeyboardEvent): boolean {
+        const unsnap = this.changeBoundsManager.unsnapModifier();
+        return matchesKeystroke(event, 'ArrowRight') || (!!unsnap && matchesKeystroke(event, 'ArrowRight', unsnap));
+    }
+
+    protected matchesMoveLeftKeystroke(event: KeyboardEvent): boolean {
+        const unsnap = this.changeBoundsManager.unsnapModifier();
+        return matchesKeystroke(event, 'ArrowLeft') || (!!unsnap && matchesKeystroke(event, 'ArrowLeft', unsnap));
+    }
+}

package/src/features/change-bounds/resize/resize-default-tool.ts

@@ -0,0 +1,75 @@
+/********************************************************************************
+ * Copyright (c) 2023 Business Informatics Group (TU Wien) 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 { KeyListener, matchesKeystroke, TYPES, type Action, type GModelElement, type IActionDispatcher } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { SelectionService } from '../../../base/selection-service';
+import type { ShortcutManager } from '../../../base/shortcuts/shortcuts-manager';
+import { EnableToolsAction } from '../../../base/tool-manager/tool';
+import { BaseEditTool } from '../../tools/base-tools';
+import { isResizable } from '../model';
+import { ResizeKeyTool } from './resize-tool';
+
+@injectable()
+export class DefaultResizeKeyListener extends KeyListener {
+    @inject(TYPES.IActionDispatcher)
+    protected readonly actionDispatcher: IActionDispatcher;
+    @inject(SelectionService)
+    protected readonly selectionService: SelectionService;
+
+    override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
+        const selectedElementsIds = this.selectionService
+            .getSelectedElements()
+            .filter(isResizable)
+            .map(e => e.id);
+
+        if (selectedElementsIds.length > 0) {
+            if (this.matchesActivateResizeModeKeystroke(event)) {
+                return [EnableToolsAction.create([ResizeKeyTool.ID])];
+            }
+        }
+
+        return [];
+    }
+
+    protected matchesActivateResizeModeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'KeyA', 'alt');
+    }
+}
+
+@injectable()
+export class DefaultResizeKeyTool extends BaseEditTool {
+    static ID = 'glsp.default-resize-key-tool';
+    static TOKEN = Symbol.for(DefaultResizeKeyTool.name);
+
+    get id(): string {
+        return DefaultResizeKeyTool.ID;
+    }
+
+    @inject(TYPES.IShortcutManager)
+    protected readonly shortcutManager: ShortcutManager;
+    @inject(DefaultResizeKeyListener)
+    protected readonly keyListener: DefaultResizeKeyListener;
+
+    enable(): void {
+        this.toDisposeOnDisable.push(
+            this.keyTool.registerListener(this.keyListener),
+            this.shortcutManager.register(DefaultResizeKeyTool.TOKEN, [
+                { shortcuts: ['ALT', 'A'], description: 'Activate resize mode for selected element', group: 'Resize', position: 0 }
+            ])
+        );
+    }
+}

package/src/features/{accessibility/resize-key-tool/resize-key-handler.ts → change-bounds/resize/resize-handler.ts}

@@ -64,37 +64,28 @@ export namespace ResizeElementAction {
     }
 }
 
-/* The ResizeElementHandler class is an implementation of the IActionHandler interface that handles
-resizing of elements. */
+/*
+ * The ResizeElementHandler class is an implementation of the IActionHandler interface that handles
+ * resizing of elements.
+ */
 @injectable()
 export class ResizeElementHandler implements IActionHandler {
     @inject(EditorContextService)
     protected editorContextService: EditorContextService;
-
     @inject(TYPES.IActionDispatcher)
     protected dispatcher: IActionDispatcher;
-
     @inject(TYPES.IFeedbackActionDispatcher)
     protected feedbackDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.Grid)
+    @optional()
+    protected grid: Grid = Grid.DEFAULT;
+    @inject(TYPES.ISnapper)
+    @optional()
+    protected readonly snapper?: ISnapper;
 
     protected debouncedChangeBounds?: DebouncedFunc<() => void>;
     protected resizeFeedback: FeedbackEmitter;
 
-    // Default x resize used if grid is not provided
-    static readonly defaultResizeX = 20;
-
-    // Default y resize used if grid is not provided
-    static readonly defaultResizeY = 20;
-
-    @inject(TYPES.Grid) @optional() protected grid: Grid = {
-        x: ResizeElementHandler.defaultResizeX,
-        y: ResizeElementHandler.defaultResizeY
-    };
-
-    protected isEditMode = false;
-
-    constructor(@inject(TYPES.ISnapper) @optional() protected readonly snapper?: ISnapper) {}
-
     @postConstruct()
     protected init(): void {
         this.resizeFeedback = this.feedbackDispatcher.createEmitter();

package/src/features/change-bounds/resize/resize-module.ts

@@ -0,0 +1,48 @@
+/********************************************************************************
+ * Copyright (c) 2023-2024 Business Informatics Group (TU Wien) 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 { FeatureModule, TYPES, bindAsService, configureActionHandler } from '@eclipse-glsp/sprotty';
+import { DefaultResizeKeyListener, DefaultResizeKeyTool } from './resize-default-tool';
+import { ResizeElementAction, ResizeElementHandler } from './resize-handler';
+import { ResizeKeyListener, ResizeKeyTool } from './resize-tool';
+
+/**
+ * Handles resize actions.
+ */
+export const resizeModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+        configureActionHandler(context, ResizeElementAction.KIND, ResizeElementHandler);
+    },
+    { featureId: Symbol('resize') }
+);
+
+/**
+ * Feature module that is 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.
+ */
+export const standaloneResizeModule = new FeatureModule(
+    (bind, unbind, isBound, rebind) => {
+        const context = { bind, unbind, isBound, rebind };
+
+        bindAsService(context, TYPES.IDefaultTool, DefaultResizeKeyTool);
+        context.bind(DefaultResizeKeyListener).toSelf();
+        bindAsService(context, TYPES.ITool, ResizeKeyTool);
+        context.bind(ResizeKeyListener).toSelf();
+    },
+    { featureId: Symbol('standaloneResize'), requires: resizeModule }
+);

package/src/features/change-bounds/resize/resize-tool.ts

@@ -0,0 +1,114 @@
+/********************************************************************************
+ * Copyright (c) 2025 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 { KeyListener, matchesKeystroke, TYPES, type Action, type GModelElement } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { Disposable } from 'vscode-jsonrpc';
+import { SelectionService } from '../../../base/selection-service';
+import type { ShortcutManager } from '../../../base/shortcuts/shortcuts-manager';
+import * as messages from '../../accessibility/toast/messages.json';
+import { ShowToastMessageAction } from '../../accessibility/toast/toast-handler';
+import { BaseEditTool } from '../../tools/base-tools';
+import { isResizable } from '../model';
+import { ResizeElementAction, ResizeType } from './resize-handler';
+
+@injectable()
+export class ResizeKeyListener extends KeyListener {
+    @inject(SelectionService)
+    protected readonly selectionService: SelectionService;
+
+    override keyDown(element: GModelElement, event: KeyboardEvent): Action[] {
+        const actions = [];
+        const selectedElementsIds = this.selectionService
+            .getSelectedElements()
+            .filter(isResizable)
+            .map(e => e.id);
+
+        if (selectedElementsIds.length > 0) {
+            if (this.matchesIncreaseSizeKeystroke(event)) {
+                actions.push(ResizeElementAction.create(selectedElementsIds, ResizeType.Increase));
+            } else if (this.matchesDecreaseSizeKeystroke(event)) {
+                actions.push(ResizeElementAction.create(selectedElementsIds, ResizeType.Decrease));
+            } else if (this.matchesMinSizeKeystroke(event)) {
+                actions.push(ResizeElementAction.create(selectedElementsIds, ResizeType.MinSize));
+            }
+        }
+        return actions;
+    }
+
+    enable(): Action[] {
+        return [
+            ShowToastMessageAction.create({
+                id: ResizeKeyTool.TOKEN,
+                message: messages.resize.resize_mode_activated
+            })
+        ];
+    }
+
+    disable(): Action[] {
+        return [
+            ShowToastMessageAction.createWithTimeout({
+                id: ResizeKeyTool.TOKEN,
+                message: messages.resize.resize_mode_deactivated
+            })
+        ];
+    }
+
+    protected matchesIncreaseSizeKeystroke(event: KeyboardEvent): boolean {
+        /** here event.key is used for '+', as keycode 187 is already declared for 'Equals' in {@link matchesKeystroke}.*/
+        return event.key === '+' || matchesKeystroke(event, 'NumpadAdd');
+    }
+
+    protected matchesMinSizeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Digit0', 'ctrl') || matchesKeystroke(event, 'Numpad0', 'ctrl');
+    }
+
+    protected matchesDecreaseSizeKeystroke(event: KeyboardEvent): boolean {
+        return matchesKeystroke(event, 'Minus') || matchesKeystroke(event, 'NumpadSubtract');
+    }
+}
+
+@injectable()
+export class ResizeKeyTool extends BaseEditTool {
+    static ID = 'glsp.resize-key-tool';
+    static TOKEN = Symbol.for(ResizeKeyTool.name);
+
+    get id(): string {
+        return ResizeKeyTool.ID;
+    }
+
+    @inject(TYPES.IShortcutManager)
+    protected readonly shortcutManager: ShortcutManager;
+    @inject(ResizeKeyListener)
+    protected readonly keyListener: ResizeKeyListener;
+
+    enable(): void {
+        this.dispatchActions(this.keyListener.enable());
+
+        this.toDisposeOnDisable.push(
+            this.keyTool.registerListener(this.keyListener),
+            this.shortcutManager.register(ResizeKeyTool.TOKEN, [
+                { shortcuts: ['Escape'], description: 'Deactivate resize handler ', group: 'Resize', position: 0 },
+                { shortcuts: ['+'], description: 'Increase size of element', group: 'Resize', position: 1 },
+                { shortcuts: ['-'], description: 'Increase size of element', group: 'Resize', position: 2 },
+                { shortcuts: ['CTRL', '0'], description: 'Set element size to default', group: 'Resize', position: 3 }
+            ]),
+            Disposable.create(() => {
+                this.dispatchActions(this.keyListener.disable());
+            })
+        );
+    }
+}

package/src/features/grid/grid-module.ts

@@ -16,6 +16,7 @@
 
 import { FeatureModule, TYPES, bindAsService, configureActionHandler, configureCommand } from '@eclipse-glsp/sprotty';
 import '../../../css/grid.css';
+import { Grid } from './grid';
 import { GridManager } from './grid-manager';
 import { ShowGridAction, ShowGridCommand } from './grid-model';
 import { GridSnapper } from './grid-snapper';
@@ -24,7 +25,7 @@ export const gridModule = new FeatureModule(
     (bind, unbind, isBound, rebind) => {
         const context = { bind, unbind, isBound, rebind };
 
-        bind(TYPES.Grid).toConstantValue({ x: 10, y: 10 });
+        bind(TYPES.Grid).toConstantValue(Grid.DEFAULT);
 
         configureCommand(context, ShowGridCommand);
 

package/src/features/grid/grid-snapper.ts

@@ -36,7 +36,7 @@ import { Grid } from './grid';
  */
 @injectable()
 export class GridSnapper implements ISnapper {
-    constructor(@optional() @inject(TYPES.Grid) public readonly grid: Grid = { x: 10, y: 10 }) {}
+    constructor(@optional() @inject(TYPES.Grid) public readonly grid: Grid = Grid.DEFAULT) {}
 
     snap(position: Point, element: GModelElement): Point {
         return Point.snapToGrid(position, this.grid);
@@ -45,7 +45,7 @@ export class GridSnapper implements ISnapper {
 
 @injectable()
 export class GLSPCenterGridSnapper extends CenterGridSnapper {
-    constructor(@optional() @inject(TYPES.Grid) public readonly grid: Grid = { x: 10, y: 10 }) {
+    constructor(@optional() @inject(TYPES.Grid) public readonly grid: Grid = Grid.DEFAULT) {
         super();
     }
 

package/src/features/grid/grid.ts

@@ -16,3 +16,6 @@
 import { Point } from '@eclipse-glsp/sprotty';
 
 export type Grid = Point;
+export namespace Grid {
+    export const DEFAULT: Grid = { x: 10, y: 10 };
+}

package/src/features/tools/base-tools.ts

@@ -53,10 +53,10 @@ export interface FeedbackAwareTool extends Tool {
 }
 
 /**
- *  A reusable base implementation for edit {@link Tool}s.
+ * A reusable base implementation for {@link Tool}s.
  */
 @injectable()
-export abstract class BaseEditTool implements FeedbackAwareTool {
+export abstract class BaseTool implements FeedbackAwareTool {
     @inject(TYPES.IFeedbackActionDispatcher) protected feedbackDispatcher: IFeedbackActionDispatcher;
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: IActionDispatcher;
     @inject(GLSPMouseTool) protected mouseTool: GLSPMouseTool;
@@ -73,10 +73,6 @@ export abstract class BaseEditTool implements FeedbackAwareTool {
 
     abstract id: string;
 
-    get isEditTool(): boolean {
-        return true;
-    }
-
     dispatchActions(actions: Action[]): Promise<void> {
         return this.actionDispatcher.dispatchAll(actions);
     }
@@ -94,6 +90,16 @@ export abstract class BaseEditTool implements FeedbackAwareTool {
     }
 }
 
+/**
+ * A reusable base implementation for edit {@link Tool}s.
+ */
+@injectable()
+export abstract class BaseEditTool extends BaseTool {
+    get isEditTool(): boolean {
+        return true;
+    }
+}
+
 @injectable()
 export abstract class BaseCreationTool<T extends Action> extends BaseEditTool implements IActionHandler {
     protected abstract isTriggerAction: (obj: any) => obj is T;