@eclipse-glsp/client 0.9.0-next.c5944e10

package/src/base/di.config.ts

@@ -0,0 +1,96 @@
+/********************************************************************************
+ * Copyright (c) 2019-2021 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 '../../css/glsp-sprotty.css';
+
+import { InitializeResult } from '@eclipse-glsp/protocol';
+import { Container, ContainerModule } from 'inversify';
+import {
+    ActionHandlerRegistry,
+    configureActionHandler,
+    configureCommand,
+    ModelSource,
+    SetModelCommand,
+    TYPES
+} from 'sprotty';
+
+import { GLSPActionDispatcher } from './action-dispatcher';
+import { SetEditModeAction } from './actions/edit-mode-action';
+import { FocusStateChangedAction } from './actions/focus-change-action';
+import { GLSPCommandStack } from './command-stack';
+import { EditorContextService } from './editor-context';
+import { FocusTracker } from './focus-tracker';
+import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model-initialization-constraint';
+import { GLSPModelRegistry } from './model/model-registry';
+import { FeedbackAwareUpdateModelCommand, SetModelActionHandler } from './model/update-model-command';
+import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
+import { GLSPToolManager } from './tool-manager/glsp-tool-manager';
+import { GLSP_TYPES } from './types';
+import { GLSPViewRegistry } from './view/view-registry';
+
+const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) => {
+    const context = { bind, _unbind, isBound, rebind };
+    bind(EditorContextService).toSelf().inSingletonScope();
+    bind(GLSP_TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(ctx => () => new Promise<EditorContextService>((resolve, reject) => {
+        if (ctx.container.isBound(EditorContextService)) {
+            resolve(ctx.container.get<EditorContextService>(EditorContextService));
+        } else {
+            reject();
+        }
+    }));
+
+    configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
+
+    bind(FocusTracker).toSelf().inSingletonScope();
+    configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
+
+    // Model update initialization ------------------------------------
+    configureCommand(context, FeedbackAwareUpdateModelCommand);
+    configureActionHandler(context, SetModelCommand.KIND, SetModelActionHandler);
+
+    bind(TYPES.MouseListener).to(SelectionClearingMouseListener);
+
+    rebind(TYPES.ICommandStack).to(GLSPCommandStack);
+    bind(GLSPToolManager).toSelf().inSingletonScope();
+    bind(GLSP_TYPES.IGLSPToolManager).toService(GLSPToolManager);
+    rebind(TYPES.IToolManager).toService(GLSPToolManager);
+    bind(GLSPActionDispatcher).toSelf().inSingletonScope();
+    rebind(TYPES.IActionDispatcher).toService(GLSPActionDispatcher);
+
+    bind(ModelInitializationConstraint).to(DefaultModelInitializationConstraint).inSingletonScope();
+
+    // support re-registration of model elements and views
+    rebind(TYPES.SModelRegistry).to(GLSPModelRegistry).inSingletonScope();
+    rebind(TYPES.ViewRegistry).to(GLSPViewRegistry).inSingletonScope();
+});
+
+export default defaultGLSPModule;
+
+/**
+ * Utility function to configure the {@link ModelSource}, i.e. the `DiagramServer`, as action handler for all server actions for the given diagramType.
+ * @param result A promise that resolves after all server actions have been registered.
+ * @param diagramType The diagram type.
+ * @param container The di container.
+ */
+export async function configureServerActions(result: InitializeResult, diagramType: string, container: Container): Promise<void> {
+    const modelSource = container.get<ModelSource>(TYPES.ModelSource);
+    const actionHandlerRegistry = container.get<ActionHandlerRegistry>(ActionHandlerRegistry);
+    const serverActions = result.serverActions[diagramType];
+    if (serverActions.length === 0) {
+        throw new Error(`No server-handled actions could be derived from the initialize result for diagramType: ${diagramType}!`);
+    }
+    serverActions.forEach(actionKind => actionHandlerRegistry.register(actionKind, modelSource));
+}
+

package/src/base/drag-aware-mouse-listener.ts

@@ -0,0 +1,69 @@
+/********************************************************************************
+ * Copyright (c) 2019 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, MouseListener, SModelElement } from 'sprotty';
+
+/**
+ * A mouse listener that is aware of prior mouse dragging.
+ *
+ * Therefore, this listener distinguishes between mouse up events after dragging and
+ * mouse up events without prior dragging. Subclasses may override the methods
+ * `draggingMouseUp` and/or `nonDraggingMouseUp` to react to only these specific kinds
+ * of mouse up events.
+ */
+export class DragAwareMouseListener extends MouseListener {
+
+    private _isMouseDown = false;
+    private _isMouseDrag = false;
+
+    mouseDown(target: SModelElement, event: MouseEvent): Action[] {
+        this._isMouseDown = true;
+        return [];
+    }
+
+    mouseMove(target: SModelElement, event: MouseEvent): Action[] {
+        if (this._isMouseDown) {
+            this._isMouseDrag = true;
+        }
+        return [];
+    }
+
+    mouseUp(element: SModelElement, event: MouseEvent): Action[] {
+        this._isMouseDown = false;
+        if (this._isMouseDrag) {
+            this._isMouseDrag = false;
+            return this.draggingMouseUp(element, event);
+        }
+
+        return this.nonDraggingMouseUp(element, event);
+    }
+
+    nonDraggingMouseUp(element: SModelElement, event: MouseEvent): Action[] {
+        return [];
+    }
+
+    draggingMouseUp(element: SModelElement, event: MouseEvent): Action[] {
+        return [];
+    }
+
+    get isMouseDrag(): boolean {
+        return this._isMouseDrag;
+    }
+
+    get isMouseDown(): boolean {
+        return this._isMouseDown;
+    }
+
+}

package/src/base/editor-context.ts

@@ -0,0 +1,124 @@
+/********************************************************************************
+ * Copyright (c) 2020 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, multiInject, optional } from 'inversify';
+import { Action, IActionHandler, ModelSource, MousePositionTracker, Point, SModelElement, SModelRoot, TYPES } from 'sprotty';
+
+import { SelectionService } from '../features/select/selection-service';
+import { distinctAdd, remove } from '../utils/array-utils';
+import { EditMode, isSetEditModeAction } from './actions/edit-mode-action';
+import { Args } from './args';
+import { isSourceUriAware } from './source-uri-aware';
+import { GLSP_TYPES } from './types';
+
+/**
+ * The `EditorContext` may be used to represent the current state of the editor for particular actions.
+ * It encompasses the last recorded mouse position, the list of selected elements, and may contain
+ * custom arguments to encode additional state information.
+ */
+export interface EditorContext {
+    /**
+     * The list of selected element identifiers.
+     */
+    readonly selectedElementIds: string[];
+
+    /**
+     * The last recorded mouse position.
+     */
+    readonly lastMousePosition?: Point;
+
+    /**
+     * Custom arguments.
+     */
+    readonly args?: Args;
+}
+
+export interface EditModeListener {
+    editModeChanged(newValue: string, oldvalue: string): void;
+}
+
+@injectable()
+export class EditorContextService implements IActionHandler {
+
+    @inject(GLSP_TYPES.SelectionService) protected selectionService: SelectionService;
+    @inject(MousePositionTracker) protected mousePositionTracker: MousePositionTracker;
+    @inject(TYPES.ModelSourceProvider) protected modelSource: () => Promise<ModelSource>;
+    protected _editMode: string;
+
+    constructor(@multiInject(GLSP_TYPES.IEditModeListener) @optional() protected editModeListeners: EditModeListener[] = []) { }
+
+    register(editModeListener: EditModeListener): void {
+        distinctAdd(this.editModeListeners, editModeListener);
+    }
+
+    deregister(editModeListener: EditModeListener): void {
+        remove(this.editModeListeners, editModeListener);
+    }
+
+    get(args?: Args): EditorContext {
+        return {
+            selectedElementIds: Array.from(this.selectionService.getSelectedElementIDs()),
+            lastMousePosition: this.mousePositionTracker.lastPositionOnDiagram,
+            args
+        };
+    }
+
+    getWithSelection(selectedElementIds: string[], args?: Args): EditorContext {
+        return {
+            selectedElementIds,
+            lastMousePosition: this.mousePositionTracker.lastPositionOnDiagram,
+            args
+        };
+    }
+
+    handle(action: Action): void {
+        if (isSetEditModeAction(action)) {
+            const oldValue = this._editMode;
+            this._editMode = action.editMode;
+            this.notifiyEditModeListeners(oldValue);
+        }
+    }
+
+    protected notifiyEditModeListeners(oldValue: string): void {
+        this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
+    }
+
+    async getSourceUri(): Promise<string | undefined> {
+        const modelSource = await this.modelSource();
+        if (isSourceUriAware(modelSource)) {
+            return modelSource.getSourceURI();
+        }
+        return undefined;
+    }
+
+    get editMode(): string {
+        return this._editMode;
+    }
+
+    get modelRoot(): Readonly<SModelRoot> {
+        return this.selectionService.getModelRoot();
+    }
+
+    get selectedElements(): Readonly<SModelElement>[] {
+        return this.selectionService.getSelectedElements();
+    }
+
+    get isReadonly(): boolean {
+        return this.editMode === EditMode.READONLY;
+    }
+}
+
+export type EditorContextServiceProvider = () => Promise<EditorContextService>;
+

package/src/base/focus-tracker.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * Copyright (c) 2021 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, IActionHandler, ICommand, TYPES, ViewerOptions } from 'sprotty';
+
+import { isFocusStateChangedAction } from './actions/focus-change-action';
+
+@injectable()
+export class FocusTracker implements IActionHandler {
+
+    protected inActiveCssClass = 'inactive';
+    protected _hasFocus = true;
+
+    @inject(TYPES.ViewerOptions) protected options: ViewerOptions;
+
+    get hasFocus(): boolean {
+        return this._hasFocus;
+    }
+
+    handle(action: Action): void | Action | ICommand {
+        if (isFocusStateChangedAction(action)) {
+            this._hasFocus = action.hasFocus;
+            const placeholder = document.getElementById(this.options.baseDiv);
+            if (!placeholder) {
+                return;
+            }
+            if (this.hasFocus) {
+                if (placeholder.classList.contains(this.inActiveCssClass)) {
+                    placeholder.classList.remove(this.inActiveCssClass);
+                }
+            } else {
+                placeholder.classList.add(this.inActiveCssClass);
+            }
+        }
+    }
+
+}

package/src/base/model/model-registry.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+ * Copyright (c) 2021 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 { SModelElement, SModelRegistry } from 'sprotty';
+
+@injectable()
+export class GLSPModelRegistry extends SModelRegistry {
+    register(key: string, factory: (u: void) => SModelElement): void {
+        if (key === undefined) {
+            throw new Error('Key is undefined');
+        }
+        if (this.hasKey(key)) {
+            // do not throw error but log overwriting
+            console.log(`Factory for model element '${key}' will be overwritten.`);
+        }
+        this.elements.set(key, factory);
+    }
+}

package/src/base/model/update-model-command.ts

@@ -0,0 +1,118 @@
+/********************************************************************************
+ * Copyright (c) 2019 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, multiInject, optional, postConstruct } from 'inversify';
+import {
+    Action,
+    ActionHandlerRegistry,
+    Command,
+    CommandActionHandler,
+    CommandExecutionContext,
+    CommandReturn,
+    IActionHandler,
+    ILogger,
+    SetModelAction,
+    SetModelCommand,
+    SModelRoot,
+    TYPES
+} from 'sprotty';
+import { UpdateModelAction, UpdateModelCommand } from 'sprotty/lib/features/update/update-model';
+
+import { IFeedbackActionDispatcher } from '../../features/tool-feedback/feedback-action-dispatcher';
+import { FeedbackCommand } from '../../features/tool-feedback/model';
+import { GLSP_TYPES } from '../types';
+
+/* ActionHandler that transforms a SetModelAction into an (feedback-aware) UpdateModelAction. This can be done because in sprotty
+*  UpdateModel behaves the same as SetModel if no model is present yet.*/
+@injectable()
+export class SetModelActionHandler implements IActionHandler {
+    handle(action: Action): Action | void {
+        if (isSetModelAction(action)) {
+            return new UpdateModelAction(action.newRoot, false);
+        }
+    }
+}
+
+export function isSetModelAction(action: Action): action is SetModelAction {
+    return action !== undefined && (action.kind === SetModelCommand.KIND)
+        && (action as SetModelAction).newRoot !== undefined;
+}
+
+export interface SModelRootListener {
+    modelRootChanged(root: Readonly<SModelRoot>): void;
+}
+
+/**
+ * A special`UpdateModelCommand` that retrieves all registered `actions` from the `IFeedbackActionDispatcher` (if present) and applies their feedback
+ * to the `newRoot` before performing the update
+ */
+@injectable()
+export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
+    @inject(TYPES.ILogger) protected logger: ILogger;
+    @inject(GLSP_TYPES.IFeedbackActionDispatcher) @optional() protected readonly feedbackActionDispatcher: IFeedbackActionDispatcher;
+    @inject(TYPES.ActionHandlerRegistryProvider) protected actionHandlerRegistryProvider: () => Promise<ActionHandlerRegistry>;
+    @multiInject(GLSP_TYPES.SModelRootListener) @optional() protected modelRootListeners: SModelRootListener[] = [];
+
+    protected actionHandlerRegistry?: ActionHandlerRegistry;
+
+    constructor(@inject(TYPES.Action) action: UpdateModelAction) {
+        super(action);
+    }
+
+    @postConstruct()
+    protected initialize(): void {
+        this.actionHandlerRegistryProvider().then(registry => this.actionHandlerRegistry = registry);
+    }
+
+    protected performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {
+        if (this.feedbackActionDispatcher && this.actionHandlerRegistry) {
+            // Create a temporary context wich defines the `newRoot` as `root`
+            // This way we do not corrupt the redo/undo behavior of the super class
+            const tempContext: CommandExecutionContext = {
+                root: newRoot,
+                duration: context.duration,
+                logger: context.logger,
+                modelChanged: context.modelChanged,
+                modelFactory: context.modelFactory,
+                syncer: context.syncer
+            };
+
+            const feedbackCommands = this.getFeedbackCommands(this.actionHandlerRegistry);
+            feedbackCommands.forEach(command => command.execute(tempContext));
+        }
+
+        this.modelRootListeners.forEach(listener => listener.modelRootChanged(newRoot));
+        return super.performUpdate(oldRoot, newRoot, context);
+    }
+
+    protected getFeedbackCommands(registry: ActionHandlerRegistry): Command[] {
+        const result: Command[] = [];
+        this.feedbackActionDispatcher.getRegisteredFeedback().forEach(action => {
+            const handler = registry.get(action.kind).find(h => h instanceof CommandActionHandler);
+            if (handler instanceof CommandActionHandler) {
+                result.push(handler.handle(action));
+            }
+        });
+        // sort commands descanding by priority
+        return result.sort((a, b) => getPriority(b) - getPriority(a));
+    }
+}
+
+function getPriority(command: Command): number {
+    if (command instanceof FeedbackCommand) {
+        return command.priority;
+    }
+    return 0;
+}

package/src/base/model-initialization-constraint.ts

@@ -0,0 +1,94 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { Action, InitializeCanvasBoundsAction, UpdateModelAction } from 'sprotty';
+import { Deferred } from 'sprotty/lib/utils/async';
+
+/**
+ * The constraint defining when the initialization of the GLSP model is completed.
+ *
+ * Many actions, such as the `CenterAction`, can only be successfully processed if
+ * the GLSP model initialization is completed, that is, the model has been set,
+ * its bounds have been computed, the canvas bounds are available, etc.
+ *
+ * An injectable implementation of this constraint will be used by the
+ * `GLSPActionDispatcher` to determine when the initialization is completed.
+ * The action dispatcher therefore provides a promise via `onceInitialized()`
+ * to trigger clients that want to dispatch an action, once the initialization
+ * is done.
+ *
+ * For most of the cases `DefaultInitializationConstraint` can be used. In fact,
+ * it is bound by default. However, custom implementations can rebind other
+ * implementations of this constraint to, for instance, delay further before the
+ * `onceInitialized()` promise is fulfilled by the `GLSPActionDispatcher`.
+ */
+@injectable()
+export abstract class ModelInitializationConstraint {
+    protected completion: Deferred<void> = new Deferred();
+    protected completed = false;
+
+    get isCompleted(): boolean {
+        return this.completed;
+    }
+
+    protected setCompleted(isCompleted: boolean): void {
+        this.completed = isCompleted;
+        if (isCompleted) {
+            this.completion.resolve();
+        }
+    }
+
+    onInitialized(): Promise<void> {
+        return this.completion.promise;
+    }
+
+    notifyDispatched(action: Action): void {
+        if (this.isCompleted) {
+            return;
+        }
+        if (this.isInitializedAfter(action)) {
+            this.setCompleted(true);
+        }
+    }
+
+    abstract isInitializedAfter(action: Action): boolean;
+}
+
+/**
+ * Default initialization constraint triggers after a non-empty `UpdateModelAction`
+ * and a subsequent `InitializeCanvasBoundsAction`.
+ */
+@injectable()
+export class DefaultModelInitializationConstraint extends ModelInitializationConstraint {
+    protected seenNonEmptyUpdateModel = false;
+
+    isInitializedAfter(action: Action): boolean {
+        if (this.isNonEmptyUpdateModel(action)) {
+            this.seenNonEmptyUpdateModel = true;
+        } else if (this.seenNonEmptyUpdateModel && action.kind === InitializeCanvasBoundsAction.KIND) {
+            return true;
+        }
+        return false;
+    }
+
+    protected isNonEmptyUpdateModel(action: Action): boolean {
+        if (action && action.kind === UpdateModelAction.KIND) {
+            const updateModelAction = action as UpdateModelAction;
+            return updateModelAction.newRoot !== undefined && updateModelAction.newRoot.type !== 'NONE';
+        }
+        return false;
+    }
+}