@eclipse-glsp/client 2.3.0-next.317 → 2.3.0-next.319

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

@@ -16,20 +16,21 @@
 
 import {
     Action,
+    BoundsData,
     ComputedBoundsAction,
     Deferred,
     EdgeRouterRegistry,
     ElementAndRoutingPoints,
     GModelElement,
-    GRoutableElement,
     HiddenBoundsUpdater,
     IActionDispatcher,
+    ModelIndexImpl,
     RequestAction,
     ResponseAction
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable, optional } from 'inversify';
 import { VNode } from 'snabbdom';
-import { calcElementAndRoute, isRoutable } from '../../utils/gmodel-util';
+import { BoundsAwareModelElement, calcElementAndRoute, getDescendantIds, isRoutable } from '../../utils/gmodel-util';
 import { LocalComputedBoundsAction, LocalRequestBoundsAction } from './local-bounds';
 
 /**
@@ -42,8 +43,10 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
     @inject(EdgeRouterRegistry) @optional() protected readonly edgeRouterRegistry?: EdgeRouterRegistry;
 
     protected element2route: ElementAndRoutingPoints[] = [];
-    protected edges: GRoutableElement[] = [];
-    protected nodes: VNode[] = [];
+
+    protected getElement2BoundsData(): Map<BoundsAwareModelElement, BoundsData> {
+        return this['element2boundsData'];
+    }
 
     override decorate(vnode: VNode, element: GModelElement): VNode {
         super.decorate(vnode, element);
@@ -54,6 +57,9 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
     }
 
     override postUpdate(cause?: Action): void {
+        if (LocalRequestBoundsAction.is(cause) && cause.elementIDs) {
+            this.focusOnElements(cause.elementIDs);
+        }
         const actions = this.captureActions(() => super.postUpdate(cause));
         actions
             .filter(action => ComputedBoundsAction.is(action))
@@ -61,6 +67,22 @@ export class GLSPHiddenBoundsUpdater extends HiddenBoundsUpdater {
         this.element2route = [];
     }
 
+    protected focusOnElements(elementIDs: string[]): void {
+        const data = this.getElement2BoundsData();
+        if (data.size > 0) {
+            // expand given IDs to their descendent element IDs as we need their bounding boxes as well
+            const index = [...data.keys()][0].index;
+            const relevantIds = new Set(elementIDs.flatMap(elementId => this.expandElementId(elementId, index, elementIDs)));
+
+            // ensure we only keep the bounds of the elements we are interested in
+            data.forEach((_bounds, element) => !relevantIds.has(element.id) && data.delete(element));
+        }
+    }
+
+    protected expandElementId(id: string, index: ModelIndexImpl, elementIDs: string[]): string[] {
+        return getDescendantIds(index.getById(id));
+    }
+
     protected captureActions(call: () => void): Action[] {
         const capturingActionDispatcher = new CapturingActionDispatcher();
         const actualActionDispatcher = this.actionDispatcher;

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

@@ -26,21 +26,38 @@ import {
     GModelRootSchema,
     RequestBoundsAction,
     TYPES,
-    ViewerOptions
+    ViewerOptions,
+    hasArrayProp
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
 import { ServerAction } from '../../base/model/glsp-model-source';
 
+export interface LocalRequestBoundsAction extends RequestBoundsAction {
+    elementIDs?: string[];
+}
+
 export namespace LocalRequestBoundsAction {
-    export function is(object: unknown): object is RequestBoundsAction {
-        return RequestBoundsAction.is(object) && !ServerAction.is(object);
+    export function is(object: unknown): object is LocalRequestBoundsAction {
+        return RequestBoundsAction.is(object) && !ServerAction.is(object) && hasArrayProp(object, 'elementIDs', true);
+    }
+
+    export function create(newRoot: GModelRootSchema, elementIDs?: string[]): LocalRequestBoundsAction {
+        return {
+            ...RequestBoundsAction.create(newRoot),
+            elementIDs
+        };
     }
 
-    export function fromCommand(context: CommandExecutionContext, actionDispatcher: ActionDispatcher, cause?: Action): CommandResult {
+    export function fromCommand(
+        { root }: CommandExecutionContext,
+        actionDispatcher: ActionDispatcher,
+        cause?: Action,
+        elementIDs?: string[]
+    ): 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));
+        actionDispatcher.dispatch(LocalRequestBoundsAction.create(root as unknown as GModelRootSchema, elementIDs));
         return {
-            model: context.root,
+            model: root,
             modelChanged: false,
             cause
         };

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

@@ -24,6 +24,7 @@ import {
     isLayoutContainer
 } from '@eclipse-glsp/sprotty';
 import { inject, injectable } from 'inversify';
+import { Ranked } from '../../base';
 import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 import { FeedbackCommand } from '../../base/feedback/feedback-command';
 import { LocalRequestBoundsAction } from './local-bounds';
@@ -48,7 +49,7 @@ export namespace SetBoundsFeedbackAction {
 export class SetBoundsFeedbackCommand extends SetBoundsCommand implements FeedbackCommand {
     static override readonly KIND: string = SetBoundsFeedbackAction.KIND;
 
-    readonly priority: number = 0;
+    readonly rank: number = Ranked.DEFAULT_RANK;
 
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
 
@@ -65,6 +66,7 @@ export class SetBoundsFeedbackCommand extends SetBoundsCommand implements Feedba
                 element.layoutOptions = options;
             }
         });
-        return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action);
+        const elementIDs = this.action.bounds.map(bounds => bounds.elementId);
+        return LocalRequestBoundsAction.fromCommand(context, this.actionDispatcher, this.action, elementIDs);
     }
 }

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

@@ -64,13 +64,14 @@ export class AddTemplateElementsFeedbackCommand extends FeedbackCommand {
     }
 
     override execute(context: CommandExecutionContext): CommandResult {
-        this.action.templates
+        const templateElements = 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);
+            .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);
     }
 
     protected applyRootCssClasses(element: GChildElement, addClasses?: string[], removeClasses?: string[]): GChildElement {

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

@@ -13,19 +13,18 @@
  *
  * 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,
+    IActionHandler,
+    RequestTypeHintsAction,
     SetTypeHintsAction,
     ShapeTypeHint,
     TYPES,
@@ -36,16 +35,17 @@ import {
     isConnectable,
     moveFeature
 } from '@eclipse-glsp/sprotty';
+import { inject, injectable } from 'inversify';
 
 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 { GEdge } from '../../model';
 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
@@ -78,7 +78,7 @@ type CanConnectFn = Connectable['canConnect'];
 @injectable()
 export class ApplyTypeHintsCommand extends FeedbackCommand {
     public static KIND = ApplyTypeHintsAction.KIND;
-    public override readonly priority = 10;
+    public override readonly rank: number = -10;
 
     @inject(TYPES.ITypeHintProvider)
     protected typeHintProvider: ITypeHintProvider;

package/src/utils/contribution-provider.ts

@@ -0,0 +1,65 @@
+/*******************************************************************************
+ * Copyright (C) 2017 TypeFox and others.
+ * Modifications: (c) 2024 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-only WITH Classpath-exception-2.0
+ *******************************************************************************/
+// eslint-disable-next-line max-len
+// based on https://github.com/eclipse-theia/theia/blob/9ff0cedff1d591b0eb4be97a05f6d992789d0a24/packages/core/src/common/contribution-provider.ts
+
+import { BindingContext, TYPES } from '@eclipse-glsp/sprotty';
+import { interfaces } from 'inversify';
+
+export interface IContributionProvider<T extends object> {
+    /**
+     * @param recursive `true` if the contributions should be collected from the parent containers as well. Otherwise, `false`.
+     * It is `false` by default.
+     */
+    getContributions(recursive?: boolean): T[];
+}
+
+class ContainerBasedContributionProvider<T extends object> implements IContributionProvider<T> {
+    protected services: T[] | undefined;
+
+    constructor(
+        protected readonly serviceIdentifier: interfaces.ServiceIdentifier<T>,
+        protected readonly container: interfaces.Container
+    ) {}
+
+    getContributions(recursive?: boolean): T[] {
+        if (this.services === undefined) {
+            const currentServices: T[] = [];
+            let currentContainer: interfaces.Container | undefined = this.container;
+            while (currentContainer !== undefined) {
+                if (currentContainer.isBound(this.serviceIdentifier)) {
+                    try {
+                        currentServices.push(...currentContainer.getAll(this.serviceIdentifier));
+                    } catch (error) {
+                        console.error(error);
+                    }
+                }
+                currentContainer = recursive === true && currentContainer.parent ? currentContainer.parent : undefined;
+            }
+            this.services = currentServices;
+        }
+        return this.services;
+    }
+}
+
+export function bindContributionProvider(context: Pick<BindingContext, 'bind'> | interfaces.Bind, id: symbol): void {
+    const bind = typeof context === 'object' ? context.bind.bind(context) : context;
+    bind(TYPES.IContributionProvider)
+        .toDynamicValue(ctx => new ContainerBasedContributionProvider(id, ctx.container))
+        .inSingletonScope()
+        .whenTargetNamed(id);
+}

package/src/utils/gmodel-util.ts

@@ -22,6 +22,7 @@ import {
     GChildElement,
     GModelElement,
     GModelElementSchema,
+    GParentElement,
     GRoutableElement,
     GRoutingHandle,
     ModelIndexImpl,
@@ -30,13 +31,12 @@ import {
     Selectable,
     TypeGuard,
     distinctAdd,
-    findParentByFeature,
     getAbsoluteBounds,
+    getZoom,
     isBoundsAware,
     isMoveable,
     isSelectable,
     isSelected,
-    isViewport,
     remove
 } from '@eclipse-glsp/sprotty';
 
@@ -346,8 +346,7 @@ export function findTopLevelElementByFeature<T>(
 
 export function calculateDeltaBetweenPoints(target: Point, source: Point, element: GModelElement): Point {
     const delta = Point.subtract(target, source);
-    const viewport = findParentByFeature(element, isViewport);
-    const zoom = viewport?.zoom ?? 1;
+    const zoom = getZoom(element);
     const adaptedDelta = { x: delta.x / zoom, y: delta.y / zoom };
     return adaptedDelta;
 }
@@ -362,3 +361,15 @@ export function isVisibleOnCanvas(model: BoundsAwareModelElement): boolean {
         modelBounds.y + modelBounds.height >= 0
     );
 }
+
+export function getDescendantIds(element?: GModelElement, skip?: (t: GModelElement) => boolean): string[] {
+    if (!element || skip?.(element)) {
+        return [];
+    }
+    const parent = element;
+    const ids = [parent.id];
+    if (parent instanceof GParentElement) {
+        ids.push(...parent.children.flatMap(child => getDescendantIds(child, skip)));
+    }
+    return ids;
+}