@eclipse-glsp/client 1.1.0-next.fdfeeeb.193 → 2.0.0

package/src/features/hints/type-hint-provider.ts

@@ -0,0 +1,249 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    CommandExecutionContext,
+    Connectable,
+    EdgeTypeHint,
+    IActionHandler,
+    RequestTypeHintsAction,
+    GModelElement,
+    GModelElementSchema,
+    GModelRoot,
+    GRoutableElement,
+    GShapeElement,
+    SetTypeHintsAction,
+    ShapeTypeHint,
+    TYPES,
+    TypeHint,
+    connectableFeature,
+    deletableFeature,
+    editFeature,
+    isConnectable,
+    moveFeature
+} from '@eclipse-glsp/sprotty';
+
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { IFeedbackActionDispatcher } from '../../base/feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../../base/feedback/feedback-command';
+import { IDiagramStartup } from '../../base/model/diagram-loader';
+import { getElementTypeId } from '../../utils/gmodel-util';
+import { resizeFeature } from '../change-bounds/model';
+import { reconnectFeature } from '../reconnect/model';
+import { containerFeature, isContainable, reparentFeature } from './model';
+import { GEdge } from '../../model';
+
+/**
+ * Is dispatched by the {@link TypeHintProvider} to apply the type hints received from the server
+ * onto the graphical model. The action is dispatched as persistent feedback to ensure the applied type hints
+ * don't get lost after a server-side model update.
+ */
+export interface ApplyTypeHintsAction extends Action {
+    kind: typeof ApplyTypeHintsAction.KIND;
+}
+
+export namespace ApplyTypeHintsAction {
+    export const KIND = 'applyTypeHints';
+
+    export function is(object: any): object is ApplyTypeHintsAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): ApplyTypeHintsAction {
+        return { kind: KIND };
+    }
+}
+
+type CanConnectFn = Connectable['canConnect'];
+
+/**
+ * Command that processes the entire model and for each model element applies its
+ * type hints i.e. translates the type hint information into corresponding model features
+ * and adds/removes them from the model element.
+ */
+@injectable()
+export class ApplyTypeHintsCommand extends FeedbackCommand {
+    public static KIND = ApplyTypeHintsAction.KIND;
+    public override readonly priority = 10;
+
+    @inject(TYPES.ITypeHintProvider)
+    protected typeHintProvider: ITypeHintProvider;
+
+    constructor(@inject(TYPES.Action) protected action: ApplyTypeHintsAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): GModelRoot {
+        context.root.index.all().forEach(element => {
+            if (element instanceof GShapeElement || element instanceof GModelRoot) {
+                return this.applyShapeTypeHint(element);
+            }
+            if (element instanceof GEdge) {
+                this.applyEdgeTypeHint(element);
+            }
+        });
+        return context.root;
+    }
+
+    protected applyEdgeTypeHint(element: GModelElement): void {
+        const hint = this.typeHintProvider.getEdgeTypeHint(element);
+
+        if (hint && element.features instanceof Set) {
+            addOrRemove(element.features, deletableFeature, hint.deletable);
+            addOrRemove(element.features, editFeature, hint.routable);
+            addOrRemove(element.features, reconnectFeature, hint.repositionable);
+        }
+    }
+
+    protected applyShapeTypeHint(element: GModelElement): void {
+        const hint = this.typeHintProvider.getShapeTypeHint(element);
+        if (hint && element.features instanceof Set) {
+            addOrRemove(element.features, deletableFeature, hint.deletable);
+            addOrRemove(element.features, moveFeature, hint.repositionable);
+            addOrRemove(element.features, resizeFeature, hint.resizable);
+            addOrRemove(element.features, reparentFeature, hint.reparentable);
+
+            addOrRemove(element.features, containerFeature, true);
+            if (isContainable(element)) {
+                element.isContainableElement = input => this.isContainableElement(input, hint);
+            }
+
+            const fallbackCanConnect = isConnectable(element) ? element.canConnect.bind(element) : undefined;
+            addOrRemove(element.features, connectableFeature, true);
+            if (isConnectable(element)) {
+                element.canConnect = (routable, role) => this.canConnect(routable, role, element, fallbackCanConnect);
+            }
+        }
+    }
+
+    /**
+     * Type hints aware wrapper function for  `Connectable.canConnect`. After type hints have been applied
+     * the `canConnect` implementation of `connectable` model elements  (with a matching hint) will forward to this method.
+     */
+    protected canConnect(
+        routable: GRoutableElement,
+        role: 'source' | 'target',
+        element: GModelElement,
+        fallbackCanConnect?: CanConnectFn
+    ): boolean {
+        const edgeHint = this.typeHintProvider.getEdgeTypeHint(routable.type);
+        if (!edgeHint) {
+            return fallbackCanConnect?.(routable, role) ?? false;
+        }
+        const validElementIds = role === 'source' ? edgeHint.sourceElementTypeIds : edgeHint.targetElementTypeIds;
+        // If no source/target element ids are defined in the hint all elements are considered valid
+        if (!validElementIds) {
+            return true;
+        }
+        const elementType = element.type + ':';
+        return validElementIds.some(type => elementType.startsWith(type));
+    }
+
+    /**
+     * Type hints aware wrapper function for  `Containable.isContainableElement`. After type hints have been applied
+     * the `isContainableElement` implementation of `containable` model elements (with a matching hint) will forward to this method.
+     */
+    protected isContainableElement(input: GModelElement | GModelElementSchema | string, hint: ShapeTypeHint): boolean {
+        const elemenType = getElementTypeId(input) + ':';
+        return hint.containableElementTypeIds?.some(type => elemenType.startsWith(type)) ?? false;
+    }
+}
+
+function addOrRemove(features: Set<symbol>, feature: symbol, add: boolean): void {
+    if (add && !features.has(feature)) {
+        features.add(feature);
+    } else if (!add && features.has(feature)) {
+        features.delete(feature);
+    }
+}
+
+/**
+ * Provides query methods for retrieving the type hint that is applicable for a given model element.
+ * If there is no type hint registered for the given element type the hint of the most concrete subtype (if any)
+ * is returned instead. Subtypes are declared with a `:` delimiter.
+ * For example consider the type `node:task:manual`. Then the provider fist checks wether there is
+ * a type hint registered for `node:task:manual`. If not it checks wether there is one registered
+ * for `node:task` and finally it checks wether there is a type hint for `node`.
+ */
+export interface ITypeHintProvider {
+    /**
+     * Retrieve the most applicable {@link ShapeTypeHint} for the given model element.
+     *
+     * @param input The model element whose type hint should be retrieved
+     * @returns The most applicable hint of the given element or `undefined` if no matching hint is registered.
+     */
+    getShapeTypeHint(input: GModelElement | GModelElementSchema | string): ShapeTypeHint | undefined;
+    /**
+     * Retrieve the most applicable {@link EdgeTypeHint} for the given model element.
+     *
+     * @param input The model element whose type hint should be retrieved
+     * @returns The most applicable hint of the given element or `undefined` if no matching hint is registered.
+     */
+    getEdgeTypeHint(input: GModelElement | GModelElementSchema | string): EdgeTypeHint | undefined;
+}
+
+@injectable()
+export class TypeHintProvider implements IActionHandler, ITypeHintProvider, IDiagramStartup {
+    @inject(TYPES.IFeedbackActionDispatcher)
+    protected feedbackActionDispatcher: IFeedbackActionDispatcher;
+
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
+    protected shapeHints: Map<string, ShapeTypeHint> = new Map();
+    protected edgeHints: Map<string, EdgeTypeHint> = new Map();
+
+    handle(action: SetTypeHintsAction): void {
+        this.shapeHints.clear();
+        this.edgeHints.clear();
+        action.shapeHints.forEach(hint => this.shapeHints.set(hint.elementTypeId, hint));
+        action.edgeHints.forEach(hint => this.edgeHints.set(hint.elementTypeId, hint));
+        this.feedbackActionDispatcher.registerFeedback(this, [ApplyTypeHintsAction.create()]);
+    }
+
+    getShapeTypeHint(input: GModelElement | GModelElementSchema | string): ShapeTypeHint | undefined {
+        return this.getTypeHint(input, this.shapeHints);
+    }
+
+    getEdgeTypeHint(input: GModelElement | GModelElementSchema | string): EdgeTypeHint | undefined {
+        return this.getTypeHint(input, this.edgeHints);
+    }
+
+    protected getTypeHint<T extends TypeHint>(input: GModelElement | GModelElementSchema | string, hints: Map<string, T>): T | undefined {
+        const type = getElementTypeId(input);
+        let hint = hints.get(type);
+        // Check subtypes
+        if (hint === undefined) {
+            const subtypes = type.split(':');
+            while (hint === undefined && subtypes.length > 0) {
+                subtypes.pop();
+                hint = hints.get(subtypes.join(':'));
+                if (hint) {
+                    // add received subtype hint to map to avoid future recomputation
+                    hints.set(type, hint);
+                    break;
+                }
+            }
+        }
+        return hint;
+    }
+
+    async postRequestModel(): Promise<void> {
+        const setTypeHintsAction = await this.actionDispatcher.request(RequestTypeHintsAction.create());
+        this.handle(setTypeHintsAction);
+    }
+}

package/src/features/hints/type-hints-module.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * 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, SetTypeHintsAction, TYPES, bindAsService, configureActionHandler, configureCommand } from '@eclipse-glsp/sprotty';
+import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hint-provider';
+
+export const typeHintsModule = new FeatureModule((bind, unbind, isBound) => {
+    const context = { bind, unbind, isBound };
+    bindAsService(context, TYPES.ITypeHintProvider, TypeHintProvider);
+    bind(TYPES.IDiagramStartup).toService(TypeHintProvider);
+    configureActionHandler(context, SetTypeHintsAction.KIND, TypeHintProvider);
+    configureCommand(context, ApplyTypeHintsCommand);
+});

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

@@ -0,0 +1,64 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+import {
+    CenterCommand,
+    ClosePopupActionHandler,
+    FeatureModule,
+    FitToScreenCommand,
+    HoverFeedbackCommand,
+    HoverKeyListener,
+    HoverState,
+    MoveCommand,
+    PopupHoverMouseListener,
+    PopupPositionUpdater,
+    SetPopupModelCommand,
+    SetViewportCommand,
+    TYPES,
+    bindAsService,
+    configureActionHandler,
+    configureCommand
+} from '@eclipse-glsp/sprotty';
+import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
+import { GlspHoverMouseListener } from './hover';
+
+export const hoverModule = new FeatureModule((bind, _unbind, isBound) => {
+    const context = { bind, isBound };
+    bindAsService(context, TYPES.PopupVNodePostprocessor, PopupPositionUpdater);
+    bindAsService(context, TYPES.MouseListener, GlspHoverMouseListener);
+    bindAsService(context, TYPES.PopupMouseListener, PopupHoverMouseListener);
+    bindAsService(context, TYPES.KeyListener, HoverKeyListener);
+
+    bind<HoverState>(TYPES.HoverState).toConstantValue({
+        mouseOverTimer: undefined,
+        mouseOutTimer: undefined,
+        popupOpen: false,
+        previousPopupElement: undefined
+    });
+    bind(ClosePopupActionHandler).toSelf().inSingletonScope();
+
+    configureCommand(context, HoverFeedbackCommand);
+    configureCommand(context, SetPopupModelCommand);
+    configureActionHandler(context, SetPopupModelCommand.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, FitToScreenCommand.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, CenterCommand.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, SetViewportCommand.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, MoveCommand.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, FocusStateChangedAction.KIND, ClosePopupActionHandler);
+    configureActionHandler(context, EnableToolsAction.KIND, GlspHoverMouseListener);
+    configureActionHandler(context, EnableDefaultToolsAction.KIND, GlspHoverMouseListener);
+    configureActionHandler(context, FocusStateChangedAction.KIND, GlspHoverMouseListener);
+});

package/src/features/hover/hover.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-2023 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,21 +13,27 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+import { injectable } from 'inversify';
 import {
     Action,
     Bounds,
-    PreRenderedElementSchema,
+    EMPTY_ROOT,
+    HoverFeedbackAction,
+    HoverMouseListener,
+    IActionHandler,
+    ICommand,
+    GPreRenderedElementSchema,
     RequestPopupModelAction,
+    GModelElement,
+    GModelElementSchema,
     SetPopupModelAction,
-    SModelElementSchema,
-    SModelRootSchema
-} from '@eclipse-glsp/protocol';
-import { injectable } from 'inversify';
-import { EMPTY_ROOT, HoverFeedbackAction, HoverMouseListener, IActionHandler, ICommand, SModelElement } from 'sprotty';
-import { FocusStateChangedAction } from '../../base/actions/focus-change-action';
-import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool-actions';
-import { EdgeCreationTool } from '../tools/edge-creation-tool';
-import { getSeverity, GIssueMarker } from '../validation/issue-marker';
+    GModelRootSchema
+} from '@eclipse-glsp/sprotty';
+import { FocusStateChangedAction } from '../../base/focus/focus-state-change-action';
+import { EnableDefaultToolsAction, EnableToolsAction } from '../../base/tool-manager/tool';
+import { EdgeCreationTool } from '../tools/edge-creation/edge-creation-tool';
+import { GIssueMarker, getSeverity } from '../validation/issue-marker';
+
 @injectable()
 export class GlspHoverMouseListener extends HoverMouseListener implements IActionHandler {
     protected enableHover = true;
@@ -55,20 +61,20 @@ export class GlspHoverMouseListener extends HoverMouseListener implements IActio
         }
     }
 
-    override mouseOver(target: SModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
+    override mouseOver(target: GModelElement, event: MouseEvent): (Action | Promise<Action>)[] {
         if (this.enableHover) {
             return super.mouseOver(target, event);
         }
         return [];
     }
 
-    protected override startMouseOverTimer(target: SModelElement, event: MouseEvent): Promise<Action> {
+    protected override startMouseOverTimer(target: GModelElement, event: MouseEvent): Promise<Action> {
         this.stopMouseOverTimer();
         return new Promise(resolve => {
             this.state.mouseOverTimer = window.setTimeout(() => {
                 const popupBounds = this.computePopupBounds(target, { x: event.pageX, y: event.pageY });
                 if (target instanceof GIssueMarker) {
-                    resolve(SetPopupModelAction.create(this.createPopupModel(target as GIssueMarker, popupBounds)));
+                    resolve(SetPopupModelAction.create(this.createPopupModel(target, popupBounds)));
                 } else {
                     resolve(RequestPopupModelAction.create({ elementId: target.id, bounds: popupBounds }));
                 }
@@ -79,7 +85,7 @@ export class GlspHoverMouseListener extends HoverMouseListener implements IActio
         });
     }
 
-    protected createPopupModel(marker: GIssueMarker, bounds: Bounds): SModelRootSchema {
+    protected createPopupModel(marker: GIssueMarker, bounds: Bounds): GModelRootSchema {
         if (marker.issues !== undefined && marker.issues.length > 0) {
             return {
                 type: 'html',
@@ -91,13 +97,13 @@ export class GlspHoverMouseListener extends HoverMouseListener implements IActio
         return { type: EMPTY_ROOT.type, id: EMPTY_ROOT.id };
     }
 
-    protected createMarkerIssuePopup(marker: GIssueMarker): SModelElementSchema {
+    protected createMarkerIssuePopup(marker: GIssueMarker): GModelElementSchema {
         const message = this.createIssueMessage(marker);
-        return {
+        return <GPreRenderedElementSchema>{
             type: 'pre-rendered',
             id: 'popup-title',
             code: `<div class="${getSeverity(marker)}"><div class="sprotty-popup-title">${message}</div></div>`
-        } as PreRenderedElementSchema;
+        };
     }
 
     protected createIssueMessage(marker: GIssueMarker): string {

package/src/features/label-edit/edit-label-tool.ts

@@ -0,0 +1,42 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+import { injectable } from 'inversify';
+import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from '@eclipse-glsp/sprotty';
+import { BaseEditTool } from '../tools/base-tools';
+
+@injectable()
+export class DirectLabelEditTool extends BaseEditTool {
+    static readonly ID = 'glsp.direct-label-edit-tool';
+
+    get id(): string {
+        return DirectLabelEditTool.ID;
+    }
+
+    protected createEditLabelMouseListener(): MouseListener {
+        return new EditLabelMouseListener();
+    }
+
+    protected createEditLabelKeyListener(): KeyListener {
+        return new EditLabelKeyListener();
+    }
+
+    enable(): void {
+        this.toDisposeOnDisable.push(
+            this.mouseTool.registerListener(this.createEditLabelMouseListener()),
+            this.keyTool.registerListener(this.createEditLabelKeyListener())
+        );
+    }
+}

package/src/features/label-edit/edit-label-validator.ts

@@ -0,0 +1,103 @@
+/********************************************************************************
+ * 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 { inject, injectable } from 'inversify';
+import {
+    Action,
+    EditLabelValidationResult,
+    EditableLabel,
+    IEditLabelValidationDecorator,
+    IEditLabelValidator,
+    RequestEditValidationAction,
+    GModelElement,
+    SetEditValidationResultAction,
+    Severity,
+    TYPES,
+    ValidationStatus
+} from '@eclipse-glsp/sprotty';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+
+export namespace LabelEditValidation {
+    export const CONTEXT_ID = 'label-edit';
+
+    export function toEditLabelValidationResult(status: ValidationStatus): EditLabelValidationResult {
+        const message = status.message;
+        let severity: Severity = 'ok';
+        if (ValidationStatus.isError(status)) {
+            severity = 'error';
+        } else if (ValidationStatus.isWarning(status)) {
+            severity = 'warning';
+        }
+        return { message, severity };
+    }
+
+    export function createValidationRequestAction(value: string, labelId: string): RequestEditValidationAction {
+        return RequestEditValidationAction.create({ contextId: CONTEXT_ID, modelElementId: labelId, text: value });
+    }
+}
+
+@injectable()
+export class ServerEditLabelValidator implements IEditLabelValidator {
+    @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
+
+    async validate(value: string, label: EditableLabel & GModelElement): Promise<EditLabelValidationResult> {
+        const action = LabelEditValidation.createValidationRequestAction(value, label.id);
+        const response = await this.actionDispatcher.requestUntil(action);
+        return response ? this.getValidationResultFromResponse(response) : { severity: 'ok' };
+    }
+
+    getValidationResultFromResponse(action: Action): EditLabelValidationResult {
+        if (SetEditValidationResultAction.is(action)) {
+            return LabelEditValidation.toEditLabelValidationResult(action.status);
+        }
+        return { severity: 'ok' };
+    }
+}
+
+@injectable()
+export class BalloonLabelValidationDecorator implements IEditLabelValidationDecorator {
+    decorate(input: HTMLInputElement, result: EditLabelValidationResult): void {
+        const containerElement = input.parentElement;
+        if (!containerElement) {
+            return;
+        }
+        if (result.message) {
+            containerElement.setAttribute('data-balloon', result.message);
+            containerElement.setAttribute('data-balloon-pos', 'up-left');
+            containerElement.setAttribute('data-balloon-visible', 'true');
+        }
+        switch (result.severity) {
+            case 'ok':
+                containerElement.classList.add('validation-ok');
+                break;
+            case 'warning':
+                containerElement.classList.add('validation-warning');
+                break;
+            case 'error':
+                containerElement.classList.add('validation-error');
+                break;
+        }
+    }
+
+    dispose(input: HTMLInputElement): void {
+        const containerElement = input.parentElement;
+        if (containerElement) {
+            containerElement.removeAttribute('data-balloon');
+            containerElement.removeAttribute('data-balloon-pos');
+            containerElement.removeAttribute('data-balloon-visible');
+            containerElement.classList.remove('validation-ok', 'validation-warning', 'validation-error');
+        }
+    }
+}

package/src/features/label-edit/label-edit-module.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * 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 { ApplyLabelEditCommand, FeatureModule, TYPES, bindAsService, configureCommand } from '@eclipse-glsp/sprotty';
+import { DirectLabelEditTool } from './edit-label-tool';
+import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
+
+export const labelEditModule = new FeatureModule((bind, _unbind, isBound, _rebind) => {
+    bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);
+    bind(TYPES.IEditLabelValidationDecorator).to(BalloonLabelValidationDecorator);
+    bindAsService(bind, TYPES.IDefaultTool, DirectLabelEditTool);
+    configureCommand({ bind, isBound }, ApplyLabelEditCommand);
+});