@eclipse-glsp/client 1.1.0-next.c40feb3.207 → 1.1.0-next.c5afbfa.273

package/src/base/tool-manager/tool-manager.ts

@@ -0,0 +1,183 @@
+/********************************************************************************
+ * 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, multiInject, optional } from 'inversify';
+import {
+    Action,
+    EditMode,
+    IActionHandler,
+    ICommand,
+    KeyListener,
+    SModelElement,
+    TYPES,
+    distinctAdd,
+    matchesKeystroke
+} from '~glsp-sprotty';
+import { EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
+import { EnableDefaultToolsAction, EnableToolsAction, Tool } from './tool';
+/**
+ * A tool manager coordinates the state of tools in the context of an editor.
+ *
+ * One instance of a tool manager is intended per editor, coordinating the state of all tools within
+ * this editor. A tool can be active or not. A tool manager ensures that activating a set of tools
+ * will disable all other tools, allowing them to invoke behavior when they become enabled or disabled.
+ */
+export interface IToolManager {
+    /** All tools managed by this tool manager. */
+    readonly managedTools: Tool[];
+
+    /** The tools that are enabled by default, whenever no other tool is enabled. */
+    readonly defaultTools: Tool[];
+
+    /** The currently active tools, which are either specifically enabled tools, or the default tools. */
+    readonly activeTools: Tool[];
+
+    /**
+     * Enables the tools with the specified `toolIds`.
+     * Therefore, this manager first disables currently active tools and then enable the
+     * tools indicated in `toolIds`, making them the currently active tools. If this manager
+     * doesn't manage one or more tools specified in `toolIds`, it'll do nothing. If not a
+     * single tool that shall be enabled was found in the managed tools, it'll fall back to
+     * the default tools.
+     *
+     * @param tools The tools to be enabled.
+     */
+    enable(toolIds: string[]): void;
+
+    /**
+     * Enables all default tools.
+     */
+    enableDefaultTools(): void;
+
+    /** Disables all currently active tools. After this call, no tool will be active anymore. */
+    disableActiveTools(): void;
+
+    registerDefaultTools(...tools: Tool[]): void;
+
+    registerTools(...tools: Tool[]): void;
+}
+
+/**
+ * The default {@link IToolManager} implementation. Allows
+ * registration of tools via Dependency Injection.
+ */
+@injectable()
+export class ToolManager implements IToolManager {
+    readonly actives: Tool[] = [];
+
+    protected editorContext?: EditorContextService;
+
+    constructor(
+        @multiInject(TYPES.ITool)
+        @optional()
+        readonly tools: Tool[] = [],
+        @multiInject(TYPES.IDefaultTool)
+        @optional()
+        readonly defaultTools: Tool[],
+        @inject(TYPES.IEditorContextServiceProvider) protected contextServiceProvider: EditorContextServiceProvider
+    ) {
+        this.registerTools(...this.tools);
+        this.registerDefaultTools(...this.defaultTools);
+        this.enableDefaultTools();
+        this.contextServiceProvider().then(editorContext => {
+            editorContext.onEditModeChanged(change => this.editModeChanged(change.newValue, change.oldValue));
+            this.editorContext = editorContext;
+        });
+    }
+
+    get managedTools(): Tool[] {
+        return this.defaultTools.concat(this.tools);
+    }
+
+    get activeTools(): Tool[] {
+        return this.actives;
+    }
+
+    registerDefaultTools(...tools: Tool[]): void {
+        distinctAdd(this.defaultTools, ...tools);
+    }
+
+    registerTools(...tools: Tool[]): void {
+        distinctAdd(this.tools, ...tools);
+    }
+
+    disableActiveTools(): void {
+        this.actives.forEach(tool => tool.disable());
+        this.actives.splice(0, this.actives.length);
+    }
+
+    enableDefaultTools(): void {
+        this.enable(this.defaultTools.map(tool => tool.id));
+    }
+
+    enable(toolIds: string[]): void {
+        this.disableActiveTools();
+        let tools = toolIds.map(id => this.tool(id));
+        if (this.editorContext && this.editorContext.isReadonly) {
+            tools = tools.filter(tool => !tool?.isEditTool);
+        }
+        tools.forEach(tool => {
+            if (tool !== undefined) {
+                tool.enable();
+                this.actives.push(tool);
+            }
+        });
+    }
+
+    tool(toolId: string): Tool | undefined {
+        return this.managedTools.find(tool => tool.id === toolId);
+    }
+
+    disableEditTools(): void {
+        this.disableActiveTools();
+        this.enable(this.defaultTools.filter(tool => !tool.isEditTool).map(tool => tool.id));
+    }
+
+    editModeChanged(newValue: string, oldValue: string): void {
+        if (oldValue === newValue) {
+            return;
+        }
+        if (newValue === EditMode.READONLY) {
+            this.disableEditTools();
+        } else if (newValue === EditMode.EDITABLE) {
+            this.enableDefaultTools();
+        }
+    }
+}
+
+@injectable()
+export class ToolManagerActionHandler implements IActionHandler {
+    @inject(TYPES.IToolManager)
+    readonly toolManager: IToolManager;
+
+    handle(action: Action): void | ICommand | Action {
+        if (EnableDefaultToolsAction.is(action)) {
+            this.toolManager.enableDefaultTools();
+        } else if (EnableToolsAction.is(action)) {
+            this.toolManager.enable((action as EnableToolsAction).toolIds);
+        }
+    }
+}
+
+@injectable()
+export class DefaultToolsEnablingKeyListener extends KeyListener {
+    override keyDown(element: SModelElement, event: KeyboardEvent): Action[] {
+        if (matchesKeystroke(event, 'Escape')) {
+            return [EnableDefaultToolsAction.create()];
+        }
+        return [];
+    }
+}

package/src/base/tool-manager/tool.ts

@@ -0,0 +1,85 @@
+/********************************************************************************
+ * Copyright (c) 2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import { Action, AnyObject, hasArrayProp, hasBooleanProp, hasFunctionProp, hasStringProp } from '~glsp-sprotty';
+
+/**
+ * Action to enable the tools of the specified `toolIds`.
+ */
+export interface EnableToolsAction extends Action {
+    kind: typeof EnableToolsAction.KIND;
+    toolIds: string[];
+}
+export namespace EnableToolsAction {
+    export const KIND = 'enable-tools';
+
+    export function is(object: unknown): object is EnableToolsAction {
+        return Action.hasKind(object, KIND) && hasArrayProp(object, 'toolIds');
+    }
+
+    export function create(toolIds: string[]): EnableToolsAction {
+        return {
+            kind: KIND,
+            toolIds
+        };
+    }
+}
+
+/**
+ * Action to disable the currently active tools and enable the default tools instead.
+ */
+export interface EnableDefaultToolsAction extends Action {
+    kind: typeof EnableDefaultToolsAction.KIND;
+}
+export namespace EnableDefaultToolsAction {
+    export const KIND = 'enable-default-tools';
+
+    export function is(object: unknown): object is EnableToolsAction {
+        return Action.hasKind(object, KIND);
+    }
+
+    export function create(): EnableDefaultToolsAction {
+        return {
+            kind: KIND
+        };
+    }
+}
+
+/** A tool that can be managed by a `ToolManager`.
+ */
+export interface Tool {
+    readonly id: string;
+    /* Notifies the tool to become active. */
+    enable(): void;
+    /* Notifies the tool to become inactive. */
+    disable(): void;
+    /** Optional flag indicating wether this tool is an edit tool.
+     *  Edit tools are inactive when a diagram is in `readonly` edit mode.
+     */
+    isEditTool?: boolean;
+}
+
+export namespace Tool {
+    export function is(object: unknown): object is Tool {
+        return (
+            AnyObject.is(object) &&
+            hasStringProp(object, 'id') &&
+            hasFunctionProp(object, 'enable') &&
+            hasFunctionProp(object, 'disable') &&
+            hasBooleanProp(object, 'isEditTool', true)
+        );
+    }
+}

package/src/base/view/key-tool.ts

@@ -0,0 +1,25 @@
+/********************************************************************************
+ * Copyright (c) 2023 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { injectable } from 'inversify';
+import { Disposable, KeyListener, KeyTool } from '~glsp-sprotty';
+
+@injectable()
+export class GLSPKeyTool extends KeyTool {
+    registerListener(keyListener: KeyListener): Disposable {
+        super.register(keyListener);
+        return Disposable.create(() => this.deregister(keyListener));
+    }
+}

package/src/base/view/mouse-tool.ts

@@ -0,0 +1,105 @@
+/********************************************************************************
+ * 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 { injectable, multiInject, optional } from 'inversify';
+import { Action, Disposable, MouseListener, MouseTool, SModelElement, SModelRoot, TYPES } from '~glsp-sprotty';
+import { Ranked } from '../ranked';
+
+/**
+ * Custom helper type to declare the explicit mouse listener methods
+ * of {@link MouseListener} i.e. omitting the `decorate` method.
+ */
+type MouseListenerMethods = keyof Omit<MouseListener, 'decorate'>;
+
+@injectable()
+export class GLSPMouseTool extends MouseTool {
+    protected rankedMouseListeners: Map<number, MouseListener[]>;
+
+    constructor(@multiInject(TYPES.MouseListener) @optional() protected override mouseListeners: MouseListener[] = []) {
+        super(mouseListeners);
+        this.rankedMouseListeners = groupBy(mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    override register(mouseListener: MouseListener): void {
+        super.register(mouseListener);
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    registerListener(mouseListener: MouseListener): Disposable {
+        this.register(mouseListener);
+        return Disposable.create(() => this.deregister(mouseListener));
+    }
+
+    override deregister(mouseListener: MouseListener): void {
+        super.deregister(mouseListener);
+        this.rankedMouseListeners = groupBy(this.mouseListeners, listener => Ranked.getRank(listener));
+    }
+
+    protected override handleEvent<K extends MouseListenerMethods>(methodName: K, model: SModelRoot, event: MouseEvent): void {
+        this.focusOnMouseEvent(methodName, model);
+        const element = this.getTargetElement(model, event);
+        if (!element) {
+            return;
+        }
+        this.notifyListenersByRank(element, methodName, event);
+    }
+
+    protected async notifyListenersByRank<K extends MouseListenerMethods>(
+        element: SModelElement,
+        methodName: K,
+        event: MouseEvent
+    ): Promise<void> {
+        for (const rank of this.rankedMouseListeners) {
+            await this.dispatchActions(rank[1], methodName, element, event);
+        }
+    }
+
+    protected async dispatchActions<K extends MouseListenerMethods>(
+        mouseListeners: MouseListener[],
+        methodName: K,
+        element: SModelElement,
+        event: MouseEvent
+    ): Promise<void> {
+        const actions = mouseListeners.map(listener => listener[methodName](element, event as WheelEvent)).reduce((a, b) => a.concat(b));
+        if (actions.length > 0) {
+            event.preventDefault();
+            for (const actionOrPromise of actions) {
+                if (Action.is(actionOrPromise)) {
+                    await this.actionDispatcher.dispatch(actionOrPromise);
+                } else {
+                    actionOrPromise.then((action: Action) => {
+                        this.actionDispatcher.dispatch(action);
+                    });
+                }
+            }
+        }
+    }
+}
+
+function groupBy<K, T>(array: Array<T>, keyFunction: (x: T) => K): Map<K, T[]> {
+    const unsortedMap = array.reduce((result: Map<K, T[]>, item: T) => {
+        const key = keyFunction(item);
+        if (!result.has(key)) {
+            result.set(key, [item]);
+        } else {
+            const entries = result.get(key);
+            if (entries) {
+                entries.push(item);
+            }
+        }
+        return result;
+    }, new Map<K, T[]>());
+    return new Map<K, T[]>([...unsortedMap.entries()].sort());
+}

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2021-2022 EclipseSource and others.
+ * 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
@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { injectable } from 'inversify';
-import { IView, ViewRegistry } from 'sprotty';
+import { IView, ViewRegistry } from '~glsp-sprotty';
 
 @injectable()
 export class GLSPViewRegistry extends ViewRegistry {

package/src/default-modules.ts

@@ -0,0 +1,197 @@
+/********************************************************************************
+ * Copyright (c) 2021-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 { Container, ContainerModule } from 'inversify';
+import {
+    BindingContext,
+    ContainerConfiguration,
+    FeatureModule,
+    TYPES,
+    ViewerOptions,
+    buttonModule,
+    configureViewerOptions,
+    edgeIntersectionModule,
+    edgeLayoutModule,
+    expandModule,
+    fadeModule,
+    labelEditUiModule,
+    modelSourceModule,
+    resolveContainerConfiguration,
+    zorderModule
+} from '~glsp-sprotty';
+import { defaultModule } from './base/default.module';
+import { IDiagramOptions } from './base/model/diagram-loader';
+import { boundsModule } from './features/bounds/bounds-module';
+import { commandPaletteModule } from './features/command-palette/command-palette-module';
+import { contextMenuModule } from './features/context-menu/context-menu-module';
+import { copyPasteModule } from './features/copy-paste/copy-paste-modules';
+import { decorationModule } from './features/decoration/decoration-module';
+import { exportModule } from './features/export/export-modules';
+import { typeHintsModule } from './features/hints/type-hints-module';
+import { hoverModule } from './features/hover/hover-module';
+import { labelEditModule } from './features/label-edit/label-edit-module';
+import { layoutModule } from './features/layout/layout-module';
+import { navigationModule } from './features/navigation/navigation-module';
+import { routingModule } from './features/routing/routing-module';
+import { selectModule } from './features/select/select-module';
+import { sourceModelWatcherModule } from './features/source-model-watcher/source-model-wacher-module';
+import { statusModule } from './features/status/status-module';
+import { svgMetadataModule } from './features/svg-metadata/svg-metadata-module';
+import { toolPaletteModule } from './features/tool-palette/tool-palette-module';
+import { changeBoundsToolModule } from './features/tools/change-bounds/change-boounds-tool-module';
+import { deletionToolModule } from './features/tools/deletion/deletion-tool-module';
+import { edgeCreationToolModule } from './features/tools/edge-creation/edege-creation-module';
+import { edgeEditToolModule } from './features/tools/edge-edit/edge-edit-module';
+import { marqueeSelectionToolModule } from './features/tools/marquee-selection/marquee-selection-module';
+import { nodeCreationToolModule } from './features/tools/node-creation/node-creation-module';
+import { toolFocusLossModule } from './features/tools/tool-focus-loss-module';
+import { markerNavigatorModule, validationModule } from './features/validation/validation-modules';
+import { viewportModule } from './features/viewport/viewport-modules';
+
+export const DEFAULT_MODULES = [
+    defaultModule,
+    buttonModule,
+    edgeIntersectionModule,
+    edgeLayoutModule,
+    expandModule,
+    exportModule,
+    fadeModule,
+    boundsModule,
+    commandPaletteModule,
+    contextMenuModule,
+    decorationModule,
+    labelEditModule,
+    hoverModule,
+    selectModule,
+    copyPasteModule,
+    viewportModule,
+    labelEditUiModule,
+    layoutModule,
+    markerNavigatorModule,
+    typeHintsModule,
+    modelSourceModule,
+    sourceModelWatcherModule,
+    navigationModule,
+    routingModule,
+    toolPaletteModule,
+    edgeCreationToolModule,
+    edgeEditToolModule,
+    deletionToolModule,
+    nodeCreationToolModule,
+    changeBoundsToolModule,
+    marqueeSelectionToolModule,
+    toolFocusLossModule,
+    validationModule,
+    zorderModule,
+    svgMetadataModule,
+    statusModule
+] as const;
+
+/**
+ * Wraps the {@link configureDiagramOptions} utility function in a module. Adopters can either include this
+ * module into the container {@link ModuleConfiguration} or configure the container after its creation
+ * (e.g. using the {@link configureDiagramOptions} utility function).
+ * @param options The diagram instance specific configuration options
+ * @returns The corresponding {@link FeatureModule}
+ */
+export function createDiagramOptionsModule(options: IDiagramOptions): FeatureModule {
+    return new FeatureModule((bind, unbind, isBound, rebind) => configureDiagramOptions({ bind, unbind, isBound, rebind }, options));
+}
+
+/**
+ * Utility function to bind the diagram instance specific configuration options.
+ * In addition to binding the {@link IDiagramOptions} this function also overrides the
+ * {@link ViewerOptions} to match the given client id.
+ * @param context The binding context
+ * @param options The {@link IDiagramOptions} that should be bound
+ */
+export function configureDiagramOptions(context: BindingContext, options: IDiagramOptions): void {
+    const viewerOptions: Partial<ViewerOptions> = {
+        baseDiv: options.clientId,
+        hiddenDiv: options.clientId + '_hidden'
+    };
+    configureViewerOptions(context, viewerOptions);
+
+    context.bind(TYPES.IDiagramOptions).toConstantValue(options);
+}
+
+/**
+ *  Initializes a GLSP Diagram container with the GLSP default modules and the specified custom `modules`.
+ *  Additional modules can be passed as direct arguments or as part of a {@link ModuleConfiguration}.
+ *  ```typescript
+ *  const container= createDiagramContainer(myModule1, myModule2)
+ *  // or
+ *  const container= createDiagramContainer({ add: [myModule1, myModule2]})
+ *  ```
+ *  Default modules can be excluded using {@link ModuleConfiguration}s.
+ *  This means, you can still customize the default modules in two ways.
+ *
+ * First, you can exclude default modules and add a module with your custom code.
+ *
+ * ```typescript
+ * const container = createDiagramContainer({ add:myModelSourceWatcherModule, remove: modelSourceWatcherModule} );
+ * ```
+ *
+ * Second, you can unbind or rebind implementations that are originally bound in one of the default modules.
+ *
+ * ```typescript
+ * rebind(NavigationTargetResolver).to(MyNavigationTargetResolver);
+ * ```
+ * @param container The container that should be initialized
+ * @param containerConfigurations
+ *          Custom modules to be loaded in addition to the default modules and/or default modules that should be excluded.
+ * @throws An error if the first module to load is not the `defaultModule` (or an equivalent custom replacement module)
+ * @returns The initialized container.
+ */
+export function initializeDiagramContainer(container: Container, ...containerConfigurations: ContainerConfiguration): Container {
+    const modules = resolveContainerConfiguration(...DEFAULT_MODULES, ...containerConfigurations);
+    // The `defaultModule` (or a custom replacement module with the same `featureId`) should be the first module that is
+    // loaded into the container
+    const firstModule = modules[0];
+    if (!firstModule || !(firstModule instanceof FeatureModule && firstModule.featureId === defaultModule.featureId)) {
+        throw new Error(
+            'Invalid module configuration. The first module to load should be the `defaultModule` (or an equivalent replacement module)'
+        );
+    }
+    container.load(...modules);
+    return container;
+}
+
+/**
+ * Creates a GLSP Client container with the GLSP default modules and the specified custom `modules`.
+ *
+ * You can still customize the default modules in two ways.
+ *
+ * First, you can unload default modules and load them again with your custom code.
+ *
+ * ```typescript
+ * const container = createClientContainer(myModule1, myModule2);
+ * container.unload(modelSourceWatcherModule);
+ * container.load(myModelSourceWatcherModule);
+ * ```
+ *
+ * Second, you can unbind or rebind implementations that are originally bound in one of the default modules.
+ *
+ * ```typescript
+ * rebind(NavigationTargetResolver).to(MyNavigationTargetResolver);
+ * ```
+ * @param modules Custom modules to be loaded in addition to the default modules.
+ * @returns The created container.
+ * @deprecated Please use `initializeDiagramContainer` from `@eclipse-glsp/client` instead
+ */
+export function createClientContainer(...modules: ContainerModule[]): Container {
+    return initializeDiagramContainer(new Container(), ...modules);
+}