@eclipse-glsp/client 2.8.0-next.8 → 2.8.0

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

@@ -25,6 +25,8 @@ import {
     ElementAndRoutingPoints,
     GChildElement,
     GModelElement,
+    GModelRoot,
+    GRoutableElement,
     HiddenBoundsUpdater,
     LayoutData,
     ModelIndexImpl,
@@ -34,6 +36,8 @@ import {
 import { inject, injectable, optional } from 'inversify';
 import { VNode } from 'snabbdom';
 import { EditorContextService } from '../../base/editor-context-service';
+import { feedbackFeature } from '../../base/feedback/feedback-action-dispatcher';
+import { ServerAction } from '../../base/model/glsp-model-source';
 import { BoundsAwareModelElement, calcElementAndRoute, getDescendantIds, isRoutable } from '../../utils/gmodel-util';
 import { LayoutAware } from './layout-data';
 import { LocalComputedBoundsAction, LocalRequestBoundsAction } from './local-bounds';
@@ -54,87 +58,156 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
 
     protected element2route: ElementAndRoutingPoints[] = [];
 
+    /**
+     * Ids of the routable elements of {@link element2route} that only exist as client-side feedback.
+     * Recorded while decorating, as the routes outlive the root they were collected from.
+     */
+    protected feedbackRouteIds = new Set<string>();
+
+    /**
+     * Root of the hidden rendering currently being collected, used to detect the start of the next
+     * one. Referenced weakly, as a hidden root is a throwaway copy of the whole model.
+     */
+    protected collectingForRoot?: WeakRef<GModelRoot>;
+
     protected getElement2BoundsData(): Map<BoundsAwareModelElement, BoundsDataExt> {
         return this['element2boundsData'];
     }
 
     override decorate(vnode: VNode, element: GModelElement): VNode {
+        this.resetOnNewRendering(element);
         super.decorate(vnode, element);
         if (isRoutable(element)) {
-            this.element2route.push(calcElementAndRoute(element, this.edgeRouterRegistry));
+            const route = this.calcElementRoute(element);
+            if (route) {
+                this.element2route.push(route);
+                if (this.isFeedbackElement(element)) {
+                    this.feedbackRouteIds.add(element.id);
+                }
+            }
         }
         return vnode;
     }
 
-    override postUpdate(cause?: Action): void {
-        if (cause === undefined || cause.kind !== RequestBoundsAction.KIND) {
-            return;
-        }
+    /**
+     * The route reported for the given element, or `undefined` to leave it out of the
+     * {@link ComputedBoundsAction} of this rendering. Override to substitute or to skip a route,
+     * which a later rendering reports again as soon as the edge can be routed.
+     *
+     * A route of fewer than two points, which is how a router reports an edge it cannot route, is
+     * skipped: approximating it from the endpoint positions would overwrite the route on the server.
+     */
+    protected calcElementRoute(element: GRoutableElement): ElementAndRoutingPoints | undefined {
+        const elementAndRoute = calcElementAndRoute(element, this.edgeRouterRegistry);
+        return (elementAndRoute.newRoutingPoints?.length ?? 0) < 2 ? undefined : elementAndRoute;
+    }
 
-        if (LocalRequestBoundsAction.is(cause) && cause.elementIDs) {
-            this.focusOnElements(cause.elementIDs);
+    /**
+     * Drops the data collected for the previous hidden rendering as soon as a new one starts.
+     * {@link postUpdate} cleans up on its way out, but a failing view or vdom patch aborts the
+     * rendering before the viewer gets there, leaving the collected bounds behind.
+     *
+     * Elements are decorated bottom-up, so the rendering is recognized by the root of the element
+     * at hand rather than by the root element itself.
+     */
+    protected resetOnNewRendering(element: GModelElement): void {
+        if (this.collectingForRoot?.deref() !== element.root) {
+            this.cleanUp();
+            this.collectingForRoot = new WeakRef(element.root);
         }
+    }
 
-        // collect bounds and layout data in element2BoundsData
-        this.getBoundsFromDOM();
-        this.layouter.layout(this.getElement2BoundsData());
-
-        // prepare data for action
-        const resizes: ElementAndBounds[] = [];
-        const alignments: ElementAndAlignment[] = [];
-        const layoutData: ElementAndLayoutData[] = [];
-        this.getElement2BoundsData().forEach((boundsData, element) => {
-            if (boundsData.boundsChanged && boundsData.bounds !== undefined) {
-                const resize: ElementAndBounds = {
-                    elementId: element.id,
-                    newSize: {
-                        width: boundsData.bounds.width,
-                        height: boundsData.bounds.height
-                    }
-                };
-                // don't copy position if the element is layouted by the server
-                if (element instanceof GChildElement && isLayoutContainer(element.parent)) {
-                    resize.newPosition = {
-                        x: boundsData.bounds.x,
-                        y: boundsData.bounds.y
-                    };
-                }
-                resizes.push(resize);
+    override postUpdate(cause?: Action): void {
+        try {
+            if (cause === undefined || cause.kind !== RequestBoundsAction.KIND) {
+                return;
             }
-            if (boundsData.alignmentChanged && boundsData.alignment !== undefined) {
-                alignments.push({
-                    elementId: element.id,
-                    newAlignment: boundsData.alignment
-                });
+
+            if (LocalRequestBoundsAction.is(cause) && cause.elementIDs) {
+                this.focusOnElements(cause.elementIDs);
             }
-            if (LayoutAware.is(boundsData)) {
-                layoutData.push({ elementId: element.id, layoutData: boundsData.layoutData });
+
+            // collect bounds and layout data in element2BoundsData
+            this.getBoundsFromDOM();
+            this.layouter.layout(this.getElement2BoundsData());
+
+            // the server can only resolve elements it sent us itself
+            const skipFeedback = ServerAction.is(cause);
+
+            // prepare data for action
+            const resizes: ElementAndBounds[] = [];
+            const alignments: ElementAndAlignment[] = [];
+            const layoutData: ElementAndLayoutData[] = [];
+            this.getElement2BoundsData().forEach((boundsData, element) => {
+                if (skipFeedback && this.isFeedbackElement(element)) {
+                    return;
+                }
+                if (boundsData.boundsChanged && boundsData.bounds !== undefined) {
+                    const resize: ElementAndBounds = {
+                        elementId: element.id,
+                        newSize: {
+                            width: boundsData.bounds.width,
+                            height: boundsData.bounds.height
+                        }
+                    };
+                    // don't copy position if the element is layouted by the server
+                    if (element instanceof GChildElement && isLayoutContainer(element.parent)) {
+                        resize.newPosition = {
+                            x: boundsData.bounds.x,
+                            y: boundsData.bounds.y
+                        };
+                    }
+                    resizes.push(resize);
+                }
+                if (boundsData.alignmentChanged && boundsData.alignment !== undefined) {
+                    alignments.push({
+                        elementId: element.id,
+                        newAlignment: boundsData.alignment
+                    });
+                }
+                if (LayoutAware.is(boundsData)) {
+                    layoutData.push({ elementId: element.id, layoutData: boundsData.layoutData });
+                }
+            });
+            const relevantRoutes = skipFeedback
+                ? this.element2route.filter(route => !this.feedbackRouteIds.has(route.elementId))
+                : this.element2route;
+            const routes = relevantRoutes.length === 0 ? undefined : relevantRoutes;
+
+            // prepare and dispatch action
+            const responseId = (cause as RequestBoundsAction).requestId;
+            const revision = this.root !== undefined ? this.root.revision : undefined;
+            const canvasBounds = this.editorContext.canvasBounds;
+            const viewport = this.editorContext.viewportData;
+            const computedBoundsAction = ComputedBoundsAction.create(resizes, {
+                revision,
+                alignments,
+                layoutData,
+                routes,
+                responseId,
+                canvasBounds,
+                viewport
+            });
+            if (LocalRequestBoundsAction.is(cause)) {
+                LocalComputedBoundsAction.mark(computedBoundsAction);
             }
-        });
-        const routes = this.element2route.length === 0 ? undefined : this.element2route;
-
-        // prepare and dispatch action
-        const responseId = (cause as RequestBoundsAction).requestId;
-        const revision = this.root !== undefined ? this.root.revision : undefined;
-        const canvasBounds = this.editorContext.canvasBounds;
-        const viewport = this.editorContext.viewportData;
-        const computedBoundsAction = ComputedBoundsAction.create(resizes, {
-            revision,
-            alignments,
-            layoutData,
-            routes,
-            responseId,
-            canvasBounds,
-            viewport
-        });
-        if (LocalRequestBoundsAction.is(cause)) {
-            LocalComputedBoundsAction.mark(computedBoundsAction);
+            this.actionDispatcher.dispatch(computedBoundsAction);
+        } finally {
+            // always reset collected data so hidden renderings with other causes (e.g. exports/failures) do not leak into the next run
+            this.cleanUp();
         }
-        this.actionDispatcher.dispatch(computedBoundsAction);
+    }
 
-        // cleanup
+    protected cleanUp(): void {
         this.getElement2BoundsData().clear();
         this.element2route = [];
+        this.feedbackRouteIds.clear();
+        this.collectingForRoot = undefined;
+        this.root = undefined;
+    }
+
+    protected isFeedbackElement(element: GModelElement): boolean {
+        return element.hasFeature(feedbackFeature);
     }
 
     protected focusOnElements(elementIDs: string[]): void {

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 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
@@ -16,6 +16,7 @@
 import {
     ClipboardData,
     CutOperation,
+    generateUuid,
     IActionDispatcher,
     PasteOperation,
     RequestClipboardDataAction,
@@ -24,7 +25,6 @@ import {
     ViewerOptions
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
-import { v4 as uuid } from 'uuid';
 import { EditorContextService } from '../../base/editor-context-service';
 
 export interface ICopyPasteHandler {
@@ -107,7 +107,7 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
 
     handleCopy(event: ClipboardEvent): void {
         if (event.clipboardData && this.shouldCopy(event)) {
-            const clipboardId = uuid();
+            const clipboardId = generateUuid();
             event.clipboardData.setData(CLIPBOARD_DATA_FORMAT, toClipboardId(clipboardId));
             this.actionDispatcher
                 .request<SetClipboardDataAction>(RequestClipboardDataAction.create(this.editorContext.get()))

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 EclipseSource and others.
+ * Copyright (c) 2023-2026 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
@@ -21,14 +21,16 @@ import {
     ElementTemplate,
     GChildElement,
     GModelElementSchema,
+    GParentElement,
     IActionDispatcher,
     TYPES,
     distinctAdd,
     remove
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import { feedbackFeature } from '../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
-import { isNotUndefined } from '../../utils/gmodel-util';
+import { enableFeatures, isNotUndefined } from '../../utils/gmodel-util';
 import { LocalRequestBoundsAction } from '../bounds/local-bounds';
 
 export interface AddTemplateElementsAction extends Action {
@@ -68,12 +70,25 @@ export class AddTemplateElementsFeedbackCommand extends FeedbackCommand {
             .map(template => templateToSchema(template, context))
             .filter(isNotUndefined)
             .map(schema => context.modelFactory.createElement(schema))
+            .map(element => this.markAsFeedback(element))
             .map(element => this.applyRootCssClasses(element, this.action.addClasses, this.action.removeClasses));
         templateElements.forEach(templateElement => context.root.add(templateElement));
         const templateElementIDs = templateElements.map(element => element.id);
         return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action, templateElementIDs);
     }
 
+    /**
+     * Marks the given template element as feedback to keep it out of the bounds reported to the
+     * server. The bounds pass tests every element on its own, so the whole subtree is marked.
+     */
+    protected markAsFeedback(element: GChildElement): GChildElement {
+        enableFeatures(element, feedbackFeature);
+        if (element instanceof GParentElement) {
+            element.children.forEach(child => this.markAsFeedback(child));
+        }
+        return element;
+    }
+
     protected applyRootCssClasses(element: GChildElement, addClasses?: string[], removeClasses?: string[]): GChildElement {
         element.cssClasses = modifyCssClasses(element.cssClasses, addClasses, removeClasses);
         return element;

package/src/features/export/glsp-svg-exporter.ts

@@ -18,6 +18,7 @@ import {
     Action,
     ExportSvgAction,
     ExportSvgOptions,
+    generateUuid,
     GModelRoot,
     RejectAction,
     RequestAction,
@@ -25,7 +26,6 @@ import {
     SvgExporter
 } from '@eclipse-glsp/sprotty';
 import { injectable } from 'inversify';
-import { v4 as uuid } from 'uuid';
 
 @injectable()
 export class GLSPSvgExporter extends SvgExporter {
@@ -82,7 +82,7 @@ export class GLSPSvgExporter extends SvgExporter {
         // createSvg requires the svg to have a non-empty id, so we generate one if necessary
         const originalId = svgElement.id;
         try {
-            svgElement.id = originalId || uuid();
+            svgElement.id = originalId || generateUuid();
             return super.createSvg(svgElement, root, options, cause);
         } finally {
             svgElement.id = originalId;

package/src/features/helper-lines/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2023-2024 EclipseSource and others.
+ * Copyright (c) 2023-2026 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
@@ -14,8 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Args, Bounds, Direction, GChildElement, GModelElement, GShapeElement, Point, Vector } from '@eclipse-glsp/sprotty';
-import { v4 as uuid } from 'uuid';
+import { Args, Bounds, Direction, GChildElement, GModelElement, GShapeElement, Point, Vector, generateUuid } from '@eclipse-glsp/sprotty';
 import { ArgsAware } from '../../base/args-feature';
 import { ResizeHandleLocation } from '../change-bounds/model';
 
@@ -46,7 +45,7 @@ export class HelperLine extends GChildElement implements ArgsAware {
         readonly lineType: HelperLineType = HelperLineType.Left
     ) {
         super();
-        this.id = uuid();
+        this.id = generateUuid();
         this.type = HELPER_LINE;
     }
 
@@ -86,7 +85,7 @@ export class SelectionBounds extends GShapeElement implements ArgsAware {
 
     constructor(bounds?: Bounds) {
         super();
-        this.id = uuid();
+        this.id = generateUuid();
         this.type = SELECTION_BOUNDS;
         if (bounds) {
             this.bounds = bounds;

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

@@ -580,11 +580,9 @@ export function createToolGroup(item: PaletteItem): HTMLElement {
 }
 
 export function changeCSSClass(element: Element, css: string): void {
-    element.classList.contains(css) ? element.classList.remove(css) : element.classList.add(css);
+    element.classList.toggle(css);
 }
 
 export function changeCodiconClass(element: Element, codiconId: string): void {
-    element.classList.contains(codiconCSSClasses(codiconId)[1])
-        ? element.classList.remove(codiconCSSClasses(codiconId)[1])
-        : element.classList.add(codiconCSSClasses(codiconId)[1]);
+    element.classList.toggle(codiconCSSClasses(codiconId)[1]);
 }

package/src/features/tools/edge-creation/dangling-edge-feedback.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 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
@@ -34,7 +34,7 @@ import {
 import { inject, injectable } from 'inversify';
 import { feedbackFeature } from '../../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
-import { isRoutable } from '../../../utils/gmodel-util';
+import { enableFeatures, isRoutable } from '../../../utils/gmodel-util';
 import { toAbsolutePosition } from '../../../utils/viewpoint-util';
 import { FeedbackEdgeEndView } from './view';
 
@@ -162,6 +162,8 @@ export function drawFeedbackEdge(
 
     const feedbackEdge = context.modelFactory.createElement(edgeSchema);
     if (isRoutable(feedbackEdge)) {
+        // created from the adopter's own edge type, so it needs to be marked as feedback explicitly
+        enableFeatures(feedbackEdge, feedbackFeature);
         edgeEnd.feedbackEdge = feedbackEdge;
         root.add(edgeEnd);
         root.add(feedbackEdge);

package/src/features/tools/edge-edit/edge-edit-tool-feedback.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 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
@@ -42,10 +42,10 @@ import {
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { DragAwareMouseListener } from '../../../base/drag-aware-mouse-listener';
-import { IFeedbackActionDispatcher } from '../../../base/feedback/feedback-action-dispatcher';
+import { IFeedbackActionDispatcher, feedbackFeature } from '../../../base/feedback/feedback-action-dispatcher';
 import { FeedbackCommand } from '../../../base/feedback/feedback-command';
 import { FeedbackEmitter } from '../../../base/feedback/feedback-emitter';
-import { forEachElement, getMatchingElements, isRoutable, isRoutingHandle } from '../../../utils/gmodel-util';
+import { enableFeatures, forEachElement, getMatchingElements, isRoutable, isRoutingHandle } from '../../../utils/gmodel-util';
 import { getAbsolutePosition, toAbsoluteBounds } from '../../../utils/viewpoint-util';
 import { addReconnectHandles, removeReconnectHandles } from '../../reconnect/model';
 import { IChangeBoundsManager } from '../change-bounds/change-bounds-manager';
@@ -375,6 +375,8 @@ export function drawFeedbackEdgeSource(context: CommandExecutionContext, targetI
 
     const feedbackEdge = context.modelFactory.createElement(feedbackEdgeSchema);
     if (isRoutable(feedbackEdge)) {
+        // created from the adopter's own edge type, so it needs to be marked as feedback explicitly
+        enableFeatures(feedbackEdge, feedbackFeature);
         edgeEnd.feedbackEdge = feedbackEdge;
         root.add(edgeEnd);
         root.add(feedbackEdge);

package/src/features/tools/marquee-selection/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2023 EclipseSource and others.
+ * Copyright (c) 2021-2026 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
@@ -14,9 +14,10 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { boundsFeature, Point, RectangularNode } from '@eclipse-glsp/sprotty';
+import { feedbackFeature } from '../../../base/feedback/feedback-action-dispatcher';
 
 export class MarqueeNode extends RectangularNode {
-    static override readonly DEFAULT_FEATURES = [boundsFeature];
+    static override readonly DEFAULT_FEATURES = [boundsFeature, feedbackFeature];
     startPoint: Point;
     endPoint: Point;
 }

package/src/features/tools/node-creation/insert-indicator.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2024 EclipseSource and others.
+ * Copyright (c) 2024-2026 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
@@ -14,18 +14,18 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Args, Dimension, FeatureSet, GNode, boundsFeature, createFeatureSet, moveFeature } from '@eclipse-glsp/sprotty';
-import { v4 as uuid } from 'uuid';
+import { Args, Dimension, FeatureSet, GNode, boundsFeature, createFeatureSet, generateUuid, moveFeature } from '@eclipse-glsp/sprotty';
 import { ArgsAware, argsFeature } from '../../../base/args-feature';
+import { feedbackFeature } from '../../../base/feedback/feedback-action-dispatcher';
 
 export const ARG_LENGTH = 'length';
 
 export class InsertIndicator extends GNode implements ArgsAware {
-    static override readonly DEFAULT_FEATURES = [boundsFeature, moveFeature, argsFeature];
+    static override readonly DEFAULT_FEATURES = [boundsFeature, moveFeature, argsFeature, feedbackFeature];
 
     static TYPE = 'node:insert-indicator';
 
-    override id: string = uuid();
+    override id: string = generateUuid();
     override type: string = InsertIndicator.TYPE;
     override features?: FeatureSet = createFeatureSet(InsertIndicator.DEFAULT_FEATURES);
     override cssClasses: string[] = ['insert-indicator', 'sprotty-node'];

package/src/features/validation/issue-marker.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2024 EclipseSource and others.
+ * Copyright (c) 2019-2026 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
@@ -25,6 +25,8 @@ import {
     SIssueMarkerImpl,
     isBoundsAware
 } from '@eclipse-glsp/sprotty';
+import { feedbackFeature } from '../../base/feedback/feedback-action-dispatcher';
+import { enableFeatures } from '../../utils/gmodel-util';
 
 export class GIssueMarker extends SIssueMarkerImpl implements Projectable {
     constructor() {
@@ -45,7 +47,7 @@ export class GIssueMarker extends SIssueMarkerImpl implements Projectable {
 /**
  * Retrieves the `GIssueMarker` contained by the provided model element as
  * direct child or a newly instantiated `GIssueMarker` if no child
- * `GIssueMarker` exists.
+ * `GIssueMarker` exists. A newly created marker is marked as client-side feedback.
  * @param modelElement for which the `GIssueMarker` should be retrieved or created.
  * @returns the child `GIssueMarker` or a new `GIssueMarker` if no such child exists.
  */
@@ -56,6 +58,9 @@ export function getOrCreateGIssueMarker(modelElement: GParentElement): GIssueMar
 
     if (issueMarker === undefined) {
         issueMarker = new GIssueMarker();
+        // a marker created here is unknown to the server, so it is kept out of server-bound
+        // requests. markers the server sends as part of the model keep reporting their bounds
+        enableFeatures(issueMarker, feedbackFeature);
         if (isBoundsAware(modelElement)) {
             issueMarker.projectedBounds = modelElement.parentToLocal(modelElement.bounds);
         }

package/src/utils/gmodel-util.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-2025 EclipseSource and others.
+ * Copyright (c) 2019-2026 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
@@ -31,6 +31,7 @@ import {
     RoutedPoint,
     Selectable,
     TypeGuard,
+    createFeatureSet,
     distinctAdd,
     getAbsoluteBounds,
     getZoom,
@@ -250,6 +251,27 @@ export function toggleCssClass(element: GModelElement, cssClass: string, toggle:
     return toggle ? addCssClasses(element, cssClass) : removeCssClasses(element, cssClass);
 }
 
+/**
+ * Enables the given model features on a single {@link GModelElement}.
+ *
+ * The feature set is shared by all instances of a registered element type, so the element is given
+ * a copy of it rather than having the shared one extended. A feature set that is not a `Set` cannot
+ * be enumerated and is left untouched.
+ *
+ * @param element The element for which the features should be enabled.
+ * @param features The features to enable.
+ */
+export function enableFeatures(element: GModelElement, features: symbol[]): void;
+export function enableFeatures(element: GModelElement, ...features: symbol[]): void;
+export function enableFeatures(element: GModelElement, ...features: symbol[] | [symbol[]]): void {
+    const toEnable = Array.isArray(features[0]) ? features[0] : (features as symbol[]);
+    if (element.features === undefined) {
+        element.features = createFeatureSet(toEnable);
+    } else if (element.features instanceof Set) {
+        element.features = createFeatureSet([...element.features], { enable: toEnable });
+    }
+}
+
 export function isNonRoutableSelectedMovableBoundsAware(element: GModelElement): element is SelectableBoundsAware {
     return isNonRoutableSelectedBoundsAware(element) && isMoveable(element);
 }