@eclipse-glsp/client 2.1.0-next.295 → 2.1.0-next.296

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/client",
-  "version": "2.1.0-next.295+0c22eb6",
+  "version": "2.1.0-next.296+545a20c",
   "description": "A sprotty-based client for GLSP",
   "keywords": [
     "eclipse",
@@ -47,7 +47,7 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/sprotty": "2.1.0-next.295+0c22eb6",
+    "@eclipse-glsp/sprotty": "2.1.0-next.296+545a20c",
     "autocompleter": "^9.1.0",
     "file-saver": "^2.0.5",
     "lodash": "4.17.21"
@@ -59,5 +59,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "0c22eb65d1e79fca017703f1238ef39bc33c06b9"
+  "gitHead": "545a20ca017d2efdf7bfc15fddea7f89197916c5"
 }

package/src/base/args-feature.ts

@@ -28,10 +28,20 @@ export interface ArgsAware {
     args?: Args;
 }
 
-export function isArgsAware(element: GModelElement): element is GModelElement & ArgsAware {
-    return element.hasFeature(argsFeature);
+export function isArgsAware(element?: GModelElement): element is GModelElement & ArgsAware {
+    return element !== undefined && element.hasFeature(argsFeature);
 }
 
 export function hasArgs(element?: GModelElement): element is GModelElement & Required<ArgsAware> {
     return element !== undefined && isArgsAware(element) && element.args !== undefined;
 }
+
+export function ensureArgs(element?: GModelElement): element is GModelElement & Required<ArgsAware> {
+    if (!isArgsAware(element)) {
+        return false;
+    }
+    if (element.args === undefined) {
+        element.args = {};
+    }
+    return true;
+}

package/src/base/feedback/css-feedback.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from 'inversify';
 import { Action, CommandExecutionContext, GModelElement, GModelRoot, TYPES, hasArrayProp } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
 import { addCssClasses, getElements, removeCssClasses } from '../../utils/gmodel-util';
 import { FeedbackCommand } from './feedback-command';
 
@@ -69,6 +69,9 @@ export class ModifyCssFeedbackCommand extends FeedbackCommand {
     }
 }
 
+export const CSS_GHOST_ELEMENT = 'ghost-element';
+export const CSS_HIDDEN = 'hidden';
+
 export enum CursorCSS {
     DEFAULT = 'default-mode',
     OVERLAP_FORBIDDEN = 'overlap-forbidden-mode',

package/src/default-modules.ts

@@ -39,6 +39,7 @@ import { commandPaletteModule } from './features/command-palette/command-palette
 import { contextMenuModule } from './features/context-menu/context-menu-module';
 import { copyPasteModule } from './features/copy-paste/copy-paste-modules';
 import { decorationModule } from './features/decoration/decoration-module';
+import { elementTemplateModule } from './features/element-template/element-template-module';
 import { exportModule } from './features/export/export-modules';
 import { typeHintsModule } from './features/hints/type-hints-module';
 import { hoverModule } from './features/hover/hover-module';
@@ -90,6 +91,7 @@ export const DEFAULT_MODULES = [
     edgeCreationToolModule,
     edgeEditToolModule,
     deletionToolModule,
+    elementTemplateModule,
     nodeCreationToolModule,
     changeBoundsToolModule,
     marqueeSelectionToolModule,

package/src/features/accessibility/keyboard-tool-palette/keyboard-tool-palette-module.ts

@@ -15,11 +15,19 @@
  ********************************************************************************/
 import '../../../../css/keyboard-tool-palette.css';
 
-import { configureActionHandler, TYPES, bindAsService, BindingContext, FeatureModule } from '@eclipse-glsp/sprotty';
+import {
+    BindingContext,
+    FeatureModule,
+    SetModelAction,
+    TYPES,
+    UpdateModelAction,
+    bindAsService,
+    configureActionHandler
+} from '@eclipse-glsp/sprotty';
+import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
 import { EnableToolPaletteAction } from '../../tool-palette/tool-palette';
-import { KeyboardToolPalette } from './keyboard-tool-palette';
 import { FocusDomAction } from '../actions';
-import { EnableDefaultToolsAction } from '../../../base/tool-manager/tool';
+import { KeyboardToolPalette } from './keyboard-tool-palette';
 
 export const keyboardToolPaletteModule = new FeatureModule((bind, unbind, isBound, rebind) => {
     const context = { bind, unbind, isBound, rebind };
@@ -32,4 +40,6 @@ export function configureKeyboardToolPaletteTool(context: BindingContext): void
     configureActionHandler(context, EnableDefaultToolsAction.KIND, KeyboardToolPalette);
     configureActionHandler(context, FocusDomAction.KIND, KeyboardToolPalette);
     configureActionHandler(context, EnableToolPaletteAction.KIND, KeyboardToolPalette);
+    configureActionHandler(context, UpdateModelAction.KIND, KeyboardToolPalette);
+    configureActionHandler(context, SetModelAction.KIND, KeyboardToolPalette);
 }

package/src/features/accessibility/keyboard-tool-palette/keyboard-tool-palette.ts

@@ -13,35 +13,35 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
 import {
-    ICommand,
-    SetUIExtensionVisibilityAction,
     Action,
+    ICommand,
     PaletteItem,
     RequestContextActions,
     RequestMarkersAction,
     SetContextActions,
+    SetUIExtensionVisibilityAction,
     TriggerNodeCreationAction
 } from '@eclipse-glsp/sprotty';
+import { injectable } from 'inversify';
 import { KeyCode, matchesKeystroke } from 'sprotty/lib/utils/keyboard';
-import { MouseDeleteTool } from '../../tools/deletion/delete-tool';
-import { MarqueeMouseTool } from '../../tools/marquee-selection/marquee-mouse-tool';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../../base/tool-manager/tool';
 import {
-    createIcon,
-    changeCodiconClass,
-    createToolGroup,
+    EnableToolPaletteAction,
     ToolPalette,
+    changeCodiconClass,
     compare,
-    EnableToolPaletteAction
+    createIcon,
+    createToolGroup
 } from '../../tool-palette/tool-palette';
-import { KeyboardNodeGridMetadata } from '../keyboard-grid/constants';
+import { MouseDeleteTool } from '../../tools/deletion/delete-tool';
+import { MarqueeMouseTool } from '../../tools/marquee-selection/marquee-mouse-tool';
 import { FocusDomAction } from '../actions';
 import { EdgeAutocompletePaletteMetadata } from '../edge-autocomplete/edge-autocomplete-palette';
-import { EnableDefaultToolsAction, EnableToolsAction } from '../../../base/tool-manager/tool';
-import { ShowToastMessageAction } from '../toast/toast-handler';
 import { ElementNavigatorKeyListener } from '../element-navigation/diagram-navigation-tool';
+import { KeyboardNodeGridMetadata } from '../keyboard-grid/constants';
 import * as messages from '../toast/messages.json';
+import { ShowToastMessageAction } from '../toast/toast-handler';
 
 const SEARCH_ICON_ID = 'search';
 const PALETTE_ICON_ID = 'symbol-color';
@@ -119,7 +119,7 @@ export class KeyboardToolPalette extends ToolPalette {
     }
 
     override handle(action: Action): ICommand | Action | void {
-        if (action.kind === EnableToolPaletteAction.KIND) {
+        if (EnableToolPaletteAction.is(action)) {
             const requestAction = RequestContextActions.create({
                 contextId: ToolPalette.ID,
                 editorContext: {
@@ -134,9 +134,6 @@ export class KeyboardToolPalette extends ToolPalette {
                     ]);
                 }
             });
-        } else if (action.kind === EnableDefaultToolsAction.KIND) {
-            this.changeActiveButton();
-            this.restoreFocus();
         } else if (FocusDomAction.is(action) && action.id === ToolPalette.ID) {
             if (this.containerElement.contains(document.activeElement)) {
                 this.toggleShortcutVisibility();
@@ -144,6 +141,8 @@ export class KeyboardToolPalette extends ToolPalette {
                 this.showShortcuts();
             }
             this.containerElement.focus();
+        } else {
+            super.handle(action);
         }
     }
 

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

@@ -30,6 +30,8 @@ import { FreeFormLayouter } from './freeform-layout';
 import { GLSPHiddenBoundsUpdater } from './glsp-hidden-bounds-updater';
 import { HBoxLayouterExt } from './hbox-layout';
 import { LayouterExt } from './layouter';
+import { LocalComputedBoundsCommand } from './local-bounds';
+import { SetBoundsFeebackCommand } from './set-bounds-feedback-command';
 import { VBoxLayouterExt } from './vbox-layout';
 
 export const boundsModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
@@ -38,6 +40,10 @@ export const boundsModule = new FeatureModule((bind, _unbind, isBound, _rebind)
     configureCommand(context, RequestBoundsCommand);
     bind(HiddenBoundsUpdater).toSelf().inSingletonScope();
     bindAsService(context, TYPES.HiddenVNodePostprocessor, GLSPHiddenBoundsUpdater);
+
+    configureCommand(context, LocalComputedBoundsCommand);
+    configureCommand(context, SetBoundsFeebackCommand);
+
     bind(TYPES.Layouter).to(LayouterExt).inSingletonScope();
     bind(TYPES.LayoutRegistry).to(LayoutRegistry).inSingletonScope();
 

package/src/features/bounds/glsp-hidden-bounds-updater.ts

@@ -14,22 +14,23 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { inject, injectable, optional } from 'inversify';
-import { VNode } from 'snabbdom';
 import {
     Action,
     ComputedBoundsAction,
     Deferred,
     EdgeRouterRegistry,
     ElementAndRoutingPoints,
+    GModelElement,
+    GRoutableElement,
     HiddenBoundsUpdater,
     IActionDispatcher,
     RequestAction,
-    ResponseAction,
-    GModelElement,
-    GRoutableElement
+    ResponseAction
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable, optional } from 'inversify';
+import { VNode } from 'snabbdom';
 import { calcElementAndRoute, isRoutable } from '../../utils/gmodel-util';
+import { LocalComputedBoundsAction, LocalRequestBoundsAction } from './local-bounds';
 
 /**
  * Grabs the bounds from hidden SVG DOM elements, applies layouts, collects routes and fires {@link ComputedBoundsAction}s.
@@ -56,7 +57,7 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
         const actions = this.captureActions(() => super.postUpdate(cause));
         actions
             .filter(action => ComputedBoundsAction.is(action))
-            .forEach(action => this.actionDispatcher.dispatch(this.enhanceAction(action as ComputedBoundsAction)));
+            .forEach(action => this.actionDispatcher.dispatch(this.enhanceAction(action as ComputedBoundsAction, cause)));
         this.element2route = [];
     }
 
@@ -72,7 +73,10 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
         }
     }
 
-    protected enhanceAction(action: ComputedBoundsAction): ComputedBoundsAction {
+    protected enhanceAction(action: ComputedBoundsAction, cause?: Action): ComputedBoundsAction {
+        if (LocalRequestBoundsAction.is(cause)) {
+            LocalComputedBoundsAction.mark(action);
+        }
         action.routes = this.element2route.length === 0 ? undefined : this.element2route;
         return action;
     }

package/src/features/bounds/local-bounds.ts

@@ -0,0 +1,91 @@
+/********************************************************************************
+ * 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,
+    ActionDispatcher,
+    Command,
+    CommandExecutionContext,
+    CommandResult,
+    CommandReturn,
+    ComputedBoundsAction,
+    ComputedBoundsApplicator,
+    GModelRoot,
+    GModelRootSchema,
+    RequestBoundsAction,
+    TYPES
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { ServerAction } from '../../base/model/glsp-model-source';
+
+export namespace LocalRequestBoundsAction {
+    export function is(object: unknown): object is RequestBoundsAction {
+        return RequestBoundsAction.is(object) && !ServerAction.is(object);
+    }
+
+    export function fromCommand(context: CommandExecutionContext, actionDispatcher: ActionDispatcher, cause?: Action): CommandResult {
+        // do not modify the main model (modelChanged = false) but request local bounds calculation on hidden model
+        actionDispatcher.dispatch(RequestBoundsAction.create(context.root as unknown as GModelRootSchema));
+        return {
+            model: context.root,
+            modelChanged: false,
+            cause
+        };
+    }
+}
+
+export namespace LocalComputedBoundsAction {
+    export function is(object: unknown): object is RequestBoundsAction {
+        return ComputedBoundsAction.is(object) && ServerAction.is(object);
+    }
+
+    export function mark(action: ComputedBoundsAction): ComputedBoundsAction {
+        // mimic: we mark the computed bounds action as coming from the server so it is not sent to the server and handled locally
+        ServerAction.mark(action);
+        return action;
+    }
+}
+
+@injectable()
+export class LocalComputedBoundsCommand extends Command {
+    static readonly KIND: string = ComputedBoundsAction.KIND;
+
+    @inject(ComputedBoundsApplicator) protected readonly computedBoundsApplicator: ComputedBoundsApplicator;
+
+    constructor(@inject(TYPES.Action) readonly action: ComputedBoundsAction) {
+        super();
+    }
+
+    override execute(context: CommandExecutionContext): GModelRoot | CommandResult {
+        if (LocalComputedBoundsAction.is(this.action)) {
+            // apply computed bounds from the hidden model and return updated model to render new main model
+            this.computedBoundsApplicator.apply(context.root as unknown as GModelRootSchema, this.action);
+            return context.root;
+        }
+        // computed bounds action from server -> we do not care and do not trigger any update of the main model
+        return {
+            model: context.root,
+            modelChanged: false
+        };
+    }
+
+    override undo(context: CommandExecutionContext): CommandReturn {
+        return context.root;
+    }
+
+    override redo(context: CommandExecutionContext): CommandReturn {
+        return context.root;
+    }
+}

package/src/features/bounds/set-bounds-feedback-command.ts

@@ -0,0 +1,70 @@
+/********************************************************************************
+ * 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,
+    CommandExecutionContext,
+    CommandReturn,
+    ElementAndBounds,
+    SetBoundsAction,
+    SetBoundsCommand,
+    TYPES,
+    isLayoutContainer
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { LocalRequestBoundsAction } from './local-bounds';
+
+export interface SetBoundsFeedbackAction extends Omit<SetBoundsAction, 'kind'> {
+    kind: typeof SetBoundsFeedbackAction.KIND;
+}
+
+export namespace SetBoundsFeedbackAction {
+    export const KIND = 'setBoundsFeedback';
+
+    export function is(object: any): object is SetBoundsFeedbackAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(bounds: ElementAndBounds[]): SetBoundsFeedbackAction {
+        return { kind: KIND, bounds };
+    }
+}
+
+@injectable()
+export class SetBoundsFeebackCommand extends SetBoundsCommand implements FeedbackCommand {
+    static override readonly KIND: string = SetBoundsFeedbackAction.KIND;
+
+    readonly priority: number = 0;
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+
+    override execute(context: CommandExecutionContext): CommandReturn {
+        super.execute(context);
+
+        // apply set bounds as layout options so that when we calculate the bounds they are considered by the layouter
+        this.action.bounds.forEach(bounds => {
+            const element = context.root.index.getById(bounds.elementId);
+            if (element && isLayoutContainer(element)) {
+                const options = element.layoutOptions ?? {};
+                options.prefHeight = bounds.newSize.height;
+                options.prefWidth = bounds.newSize.width;
+                element.layoutOptions = options;
+            }
+        });
+        return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action);
+    }
+}

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

@@ -16,10 +16,10 @@
 import {
     BoundsAware,
     GChildElement,
-    Hoverable,
-    Locateable,
     GModelElement,
     GParentElement,
+    Hoverable,
+    Locateable,
     Selectable,
     hoverFeedbackFeature,
     isBoundsAware,
@@ -72,7 +72,6 @@ export class SResizeHandle extends GChildElement implements Hoverable {
 }
 
 export function addResizeHandles(element: GParentElement): void {
-    removeResizeHandles(element);
     element.add(new SResizeHandle(ResizeHandleLocation.TopLeft));
     element.add(new SResizeHandle(ResizeHandleLocation.TopRight));
     element.add(new SResizeHandle(ResizeHandleLocation.BottomLeft));

package/src/features/decoration/decoration-placer.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { Decoration, DecorationPlacer, GChildElement, GModelElement, GRoutableElement, Point, isSizeable } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
-import { Decoration, DecorationPlacer, GChildElement, Point, GModelElement, GRoutableElement, isSizeable } from '@eclipse-glsp/sprotty';
 
 @injectable()
 export class GlspDecorationPlacer extends DecorationPlacer {
@@ -26,8 +26,8 @@ export class GlspDecorationPlacer extends DecorationPlacer {
         }
         if (isSizeable(element)) {
             return {
-                x: GlspDecorationPlacer.DECORATION_OFFSET.x * element.bounds.width,
-                y: GlspDecorationPlacer.DECORATION_OFFSET.y * element.bounds.height
+                x: -GlspDecorationPlacer.DECORATION_OFFSET.x,
+                y: -GlspDecorationPlacer.DECORATION_OFFSET.y
             };
         }
         return Point.ORIGIN;

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

@@ -0,0 +1,109 @@
+/********************************************************************************
+ * 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,
+    CommandExecutionContext,
+    CommandResult,
+    ElementTemplate,
+    GChildElement,
+    GModelElementSchema,
+    TYPES,
+    distinctAdd,
+    remove
+} from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { isNotUndefined } from '../../utils/gmodel-util';
+import { LocalRequestBoundsAction } from '../bounds/local-bounds';
+
+export interface AddTemplateElementsAction extends Action {
+    kind: typeof AddTemplateElementsAction.KIND;
+    templates: ElementTemplate[];
+    addClasses?: string[];
+    removeClasses?: string[];
+}
+
+export namespace AddTemplateElementsAction {
+    export const KIND = 'addTemplateElements';
+
+    export function create(options: Omit<AddTemplateElementsAction, 'kind'>): AddTemplateElementsAction {
+        return {
+            kind: KIND,
+            ...options
+        };
+    }
+}
+
+export function getTemplateElementId(template: ElementTemplate): string {
+    return typeof template === 'string' ? `${template}_feedback` : template.id;
+}
+
+@injectable()
+export class AddTemplateElementsFeedbackCommand extends FeedbackCommand {
+    static readonly KIND = AddTemplateElementsAction.KIND;
+
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+
+    constructor(@inject(TYPES.Action) readonly action: AddTemplateElementsAction) {
+        super();
+    }
+
+    override execute(context: CommandExecutionContext): CommandResult {
+        this.action.templates
+            .map(template => templateToSchema(template, context))
+            .filter(isNotUndefined)
+            .map(schema => context.modelFactory.createElement(schema))
+            .map(element => this.applyRootCssClasses(element, this.action.addClasses, this.action.removeClasses))
+            .forEach(templateElement => context.root.add(templateElement));
+        return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action);
+    }
+
+    protected applyRootCssClasses(element: GChildElement, addClasses?: string[], removeClasses?: string[]): GChildElement {
+        element.cssClasses = modifyCssClasses(element.cssClasses, addClasses, removeClasses);
+        return element;
+    }
+}
+
+export function templateToSchema(template: ElementTemplate, context: CommandExecutionContext): GModelElementSchema | undefined {
+    if (typeof template === 'string') {
+        const element = context.root.index.getById(template);
+        const schema = element ? context.modelFactory.createSchema(element) : undefined;
+        if (schema) {
+            adaptSchemaIds(schema);
+        }
+        return schema;
+    }
+    return template;
+}
+
+function adaptSchemaIds(schema: GModelElementSchema): GModelElementSchema {
+    schema.id = getTemplateElementId(schema.id);
+    schema.children?.forEach(child => adaptSchemaIds(child));
+    return schema;
+}
+
+function modifyCssClasses(source?: string[], toAdd?: string[], toRemove?: string[]): string[] {
+    const classes = source ?? [];
+    if (toAdd) {
+        distinctAdd(classes, ...toAdd);
+    }
+    if (toRemove) {
+        remove(classes, ...toRemove);
+    }
+    return classes;
+}

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

@@ -0,0 +1,24 @@
+/********************************************************************************
+ * 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 { FeatureModule, configureCommand } from '@eclipse-glsp/sprotty';
+import { AddTemplateElementsFeedbackCommand } from './add-template-element';
+import { RemoveTemplateElementsFeedbackCommand } from './remove-template-element';
+
+export const elementTemplateModule = new FeatureModule((bind, unbind, isBound, rebind) => {
+    const context = { bind, unbind, isBound, rebind };
+    configureCommand(context, AddTemplateElementsFeedbackCommand);
+    configureCommand(context, RemoveTemplateElementsFeedbackCommand);
+});