@eclipse-glsp/client 0.9.0-next.d9bed812 → 0.9.0-next.eb280175

package/src/base/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * 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
@@ -13,38 +13,37 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import "../../css/glsp-sprotty.css";
-
-import { ContainerModule } from "inversify";
-import { configureActionHandler, configureCommand, SetModelCommand, TYPES } from "sprotty";
-
-import { GLSPActionDispatcher } from "./action-dispatcher";
-import { SetEditModeAction } from "./actions/edit-mode-action";
-import { FocusStateChangedAction } from "./actions/focus-change-action";
-import { ConfigureServerHandlersAction, ConfigureServerHandlersActionHandler } from "./actions/protocol-actions";
-import { GLSPCommandStack } from "./command-stack";
-import { EditorContextService } from "./editor-context";
-import { FocusTracker } from "./focus-tracker";
-import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from "./model-initialization-constraint";
-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 { InitializeResult, SetEditModeAction } from '@eclipse-glsp/protocol';
+import '@vscode/codicons/dist/codicon.css';
+import { Container, ContainerModule } from 'inversify';
+import { ActionHandlerRegistry, configureActionHandler, configureCommand, ModelSource, SetModelCommand, TYPES } from 'sprotty';
+import '../../css/glsp-sprotty.css';
+import { GLSPActionDispatcher } from './action-dispatcher';
+import { FocusStateChangedAction } from './actions/focus-change-action';
+import { GLSPCommandStack } from './command-stack';
+import { EditorContextService } from './editor-context-service';
+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 => {
-        return () => {
-            return new Promise<EditorContextService>((resolve, reject) => {
+    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);
 
@@ -55,9 +54,6 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
     configureCommand(context, FeedbackAwareUpdateModelCommand);
     configureActionHandler(context, SetModelCommand.KIND, SetModelActionHandler);
 
-    // Dynamically register all server-side action/operation handlers
-    configureActionHandler(context, ConfigureServerHandlersAction.KIND, ConfigureServerHandlersActionHandler);
-
     bind(TYPES.MouseListener).to(SelectionClearingMouseListener);
 
     rebind(TYPES.ICommandStack).to(GLSPCommandStack);
@@ -68,6 +64,27 @@ const defaultGLSPModule = new ContainerModule((bind, _unbind, isBound, rebind) =
     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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * 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
@@ -13,7 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, MouseListener, SModelElement } from "sprotty";
+import { Action } from '@eclipse-glsp/protocol';
+import { MouseListener, SModelElement } from 'sprotty';
 
 /**
  * A mouse listener that is aware of prior mouse dragging.
@@ -24,9 +25,8 @@ import { Action, MouseListener, SModelElement } from "sprotty";
  * of mouse up events.
  */
 export class DragAwareMouseListener extends MouseListener {
-
-    private _isMouseDown: boolean = false;
-    private _isMouseDrag: boolean = false;
+    private _isMouseDown = false;
+    private _isMouseDrag = false;
 
     mouseDown(target: SModelElement, event: MouseEvent): Action[] {
         this._isMouseDown = true;
@@ -58,12 +58,11 @@ export class DragAwareMouseListener extends MouseListener {
         return [];
     }
 
-    get isMouseDrag() {
+    get isMouseDrag(): boolean {
         return this._isMouseDrag;
     }
 
-    get isMouseDown() {
+    get isMouseDown(): boolean {
         return this._isMouseDown;
     }
-
 }

package/src/base/{editor-context.ts → editor-context-service.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,37 +13,12 @@
  *
  * 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;
-}
+import { Action, Args, distinctAdd, EditMode, EditorContext, isSetEditModeAction, remove } from '@eclipse-glsp/protocol';
+import { inject, injectable, multiInject, optional } from 'inversify';
+import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot, TYPES } from 'sprotty';
+import { SelectionService } from '../features/select/selection-service';
+import { isSourceUriAware } from './source-uri-aware';
+import { GLSP_TYPES } from './types';
 
 export interface EditModeListener {
     editModeChanged(newValue: string, oldvalue: string): void;
@@ -51,19 +26,18 @@ export interface EditModeListener {
 
 @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[] = []) { }
+    constructor(@multiInject(GLSP_TYPES.IEditModeListener) @optional() protected editModeListeners: EditModeListener[] = []) {}
 
-    register(editModeListener: EditModeListener) {
+    register(editModeListener: EditModeListener): void {
         distinctAdd(this.editModeListeners, editModeListener);
     }
 
-    deregister(editModeListener: EditModeListener) {
+    deregister(editModeListener: EditModeListener): void {
         remove(this.editModeListeners, editModeListener);
     }
 
@@ -83,7 +57,7 @@ export class EditorContextService implements IActionHandler {
         };
     }
 
-    handle(action: Action) {
+    handle(action: Action): void {
         if (isSetEditModeAction(action)) {
             const oldValue = this._editMode;
             this._editMode = action.editMode;
@@ -91,11 +65,11 @@ export class EditorContextService implements IActionHandler {
         }
     }
 
-    protected notifiyEditModeListeners(oldValue: string) {
+    protected notifiyEditModeListeners(oldValue: string): void {
         this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
     }
 
-    async getSourceUri() {
+    async getSourceUri(): Promise<string | undefined> {
         const modelSource = await this.modelSource();
         if (isSourceUriAware(modelSource)) {
             return modelSource.getSourceURI();
@@ -121,4 +95,3 @@ export class EditorContextService implements IActionHandler {
 }
 
 export type EditorContextServiceProvider = () => Promise<EditorContextService>;
-

package/src/base/focus-tracker.ts

@@ -13,14 +13,13 @@
  *
  * 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";
+import { Action } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { 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;
 
@@ -46,5 +45,4 @@ export class FocusTracker implements IActionHandler {
             }
         }
     }
-
 }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * 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
@@ -13,9 +13,9 @@
  *
  * 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, isSetModelAction, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
 import {
-    Action,
     ActionHandlerRegistry,
     Command,
     CommandActionHandler,
@@ -23,19 +23,16 @@ import {
     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";
+    TYPES,
+    UpdateModelCommand
+} from 'sprotty';
+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.*/
+ *  UpdateModel behaves the same as SetModel if no model is present yet.*/
 @injectable()
 export class SetModelActionHandler implements IActionHandler {
     handle(action: Action): Action | void {
@@ -45,18 +42,13 @@ export class SetModelActionHandler implements IActionHandler {
     }
 }
 
-export function isSetModelAction(action: Action): action is SetModelAction {
-    return action !== undefined && (action.kind === SetModelCommand.KIND)
-        && (<SetModelAction>action).newRoot !== undefined;
-}
-
 export interface SModelRootListener {
-    modelRootChanged(root: Readonly<SModelRoot>): void
+    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
+ * 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 {
@@ -73,7 +65,7 @@ export class FeedbackAwareUpdateModelCommand extends UpdateModelCommand {
 
     @postConstruct()
     protected initialize(): void {
-        this.actionHandlerRegistryProvider().then(registry => this.actionHandlerRegistry = registry);
+        this.actionHandlerRegistryProvider().then(registry => (this.actionHandlerRegistry = registry));
     }
 
     protected performUpdate(oldRoot: SModelRoot, newRoot: SModelRoot, context: CommandExecutionContext): CommandReturn {

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,9 +13,10 @@
  *
  * 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";
+import { Action, UpdateModelAction } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { InitializeCanvasBoundsAction } from 'sprotty';
+import { Deferred } from 'sprotty/lib/utils/async';
 
 /**
  * The constraint defining when the initialization of the GLSP model is completed.
@@ -38,23 +39,27 @@ import { Deferred } from "sprotty/lib/utils/async";
 @injectable()
 export abstract class ModelInitializationConstraint {
     protected completion: Deferred<void> = new Deferred();
-    protected completed: boolean = false;
+    protected completed = false;
 
     get isCompleted(): boolean {
         return this.completed;
     }
 
-    protected setCompleted(isCompleted: boolean) {
+    protected setCompleted(isCompleted: boolean): void {
         this.completed = isCompleted;
-        if (isCompleted) { this.completion.resolve(); }
+        if (isCompleted) {
+            this.completion.resolve();
+        }
     }
 
     onInitialized(): Promise<void> {
         return this.completion.promise;
     }
 
-    notifyDispatched(action: Action) {
-        if (this.isCompleted) { return; }
+    notifyDispatched(action: Action): void {
+        if (this.isCompleted) {
+            return;
+        }
         if (this.isInitializedAfter(action)) {
             this.setCompleted(true);
         }
@@ -69,9 +74,9 @@ export abstract class ModelInitializationConstraint {
  */
 @injectable()
 export class DefaultModelInitializationConstraint extends ModelInitializationConstraint {
-    protected seenNonEmptyUpdateModel: boolean = false;
+    protected seenNonEmptyUpdateModel = false;
 
-    isInitializedAfter(action: Action) {
+    isInitializedAfter(action: Action): boolean {
         if (this.isNonEmptyUpdateModel(action)) {
             this.seenNonEmptyUpdateModel = true;
         } else if (this.seenNonEmptyUpdateModel && action.kind === InitializeCanvasBoundsAction.KIND) {

package/src/base/selection-clearing-mouse-listener.ts

@@ -13,8 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from "inversify";
-import { MouseListener, SModelElement } from "sprotty";
+import { injectable } from 'inversify';
+import { MouseListener, SModelElement } from 'sprotty';
 
 /**
  * A mouse listener that clears the document selection on click
@@ -30,8 +30,9 @@ import { MouseListener, SModelElement } from "sprotty";
  */
 @injectable()
 export class SelectionClearingMouseListener extends MouseListener {
-    mouseDown(_target: SModelElement, event: MouseEvent) {
+    mouseDown(_target: SModelElement, event: MouseEvent): never[] {
         const selection = document.getSelection();
+        // eslint-disable-next-line no-null/no-null
         if (selection === null) {
             return [];
         }

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

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,13 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable, multiInject, optional, postConstruct } from "inversify";
-import { Tool, ToolManager } from "sprotty";
-
-import { distinctAdd } from "../../utils/array-utils";
-import { EditMode } from "../actions/edit-mode-action";
-import { EditModeListener, EditorContextService, EditorContextServiceProvider } from "../editor-context";
-import { GLSP_TYPES } from "../types";
+import { distinctAdd, EditMode } from '@eclipse-glsp/protocol';
+import { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
+import { Tool, ToolManager } from 'sprotty';
+import { EditModeListener, EditorContextService, EditorContextServiceProvider } from '../editor-context-service';
+import { GLSP_TYPES } from '../types';
 
 export interface IGLSPToolManager extends ToolManager {
     /* Disables all actives tools and activates only default tool with non-edit function*/
@@ -45,19 +43,19 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
         });
     }
 
-    registerDefaultTools(...tools: Tool[]) {
+    registerDefaultTools(...tools: Tool[]): void {
         for (const tool of tools) {
             distinctAdd(this.defaultTools, tool);
         }
     }
 
-    registerTools(...tools: Tool[]) {
+    registerTools(...tools: Tool[]): void {
         for (const tool of tools) {
             distinctAdd(this.tools, tool);
         }
     }
 
-    enable(toolIds: string[]) {
+    enable(toolIds: string[]): void {
         this.disableActiveTools();
         let tools = toolIds.map(id => this.tool(id));
         if (this.editorContext && this.editorContext.isReadonly) {
@@ -71,12 +69,12 @@ export class GLSPToolManager extends ToolManager implements IGLSPToolManager, Ed
         });
     }
 
-    disableEditTools() {
+    disableEditTools(): void {
         this.disableActiveTools();
         this.enable(this.defaultTools.filter(tool => !isGLSPTool(tool) || tool.isEditTool === false).map(tool => tool.id));
     }
 
-    editModeChanged(oldValue: string, newValue: string) {
+    editModeChanged(oldValue: string, newValue: string): void {
         if (oldValue === newValue) {
             return;
         }
@@ -93,5 +91,5 @@ export interface GLSPTool extends Tool {
 }
 
 export function isGLSPTool(tool: Tool): tool is GLSPTool {
-    return "isEditTool" in tool && typeof tool["isEditTool"] === "boolean";
+    return 'isEditTool' in tool && typeof tool['isEditTool'] === 'boolean';
 }

package/src/base/types.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * 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
@@ -14,24 +14,26 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 export const GLSP_TYPES = {
-    IAsyncClipboardService: Symbol.for("IAsyncClipboardService"),
-    ICommandPaletteActionProviderRegistry: Symbol.for("ICommandPaletteActionProviderRegistry"),
-    IEditorContextServiceProvider: Symbol.for("IEditorContextProvider"),
-    IFeedbackActionDispatcher: Symbol.for("IFeedbackActionDispatcher"),
-    IToolFactory: Symbol.for("Factory<Tool>"),
-    ITypeHintProvider: Symbol.for("ITypeHintProvider"),
-    IMovementRestrictor: Symbol.for("IMovmementRestrictor"),
-    SelectionService: Symbol.for("SelectionService"),
-    SelectionListener: Symbol.for("SelectionListener"),
-    SModelRootListener: Symbol.for("SModelRootListener"),
-    MouseTool: Symbol.for("MouseTool"),
-    IContextMenuService: Symbol.for("IContextMenuService"),
-    IContextMenuServiceProvider: Symbol.for("IContextMenuServiceProvider"),
-    IContextMenuProviderRegistry: Symbol.for("IContextMenuProviderRegistry"),
-    IContextMenuProvider: Symbol.for("IContextMenuProvider"),
-    ICopyPasteHandler: Symbol.for("ICopyPasteHandler"),
-    IGLSPToolManager: Symbol.for("IGLSPToolManager"),
-    ITool: Symbol.for("ITool"),
-    IDefaultTool: Symbol.for("IDefaultTool"),
-    IEditModeListener: Symbol.for("IEditModeListener")
+    IAsyncClipboardService: Symbol.for('IAsyncClipboardService'),
+    ICommandPaletteActionProviderRegistry: Symbol.for('ICommandPaletteActionProviderRegistry'),
+    IEditorContextServiceProvider: Symbol.for('IEditorContextProvider'),
+    IFeedbackActionDispatcher: Symbol.for('IFeedbackActionDispatcher'),
+    IToolFactory: Symbol.for('Factory<Tool>'),
+    ITypeHintProvider: Symbol.for('ITypeHintProvider'),
+    IMovementRestrictor: Symbol.for('IMovmementRestrictor'),
+    SelectionService: Symbol.for('SelectionService'),
+    SelectionListener: Symbol.for('SelectionListener'),
+    SModelRootListener: Symbol.for('SModelRootListener'),
+    MouseTool: Symbol.for('MouseTool'),
+    IContextMenuService: Symbol.for('IContextMenuService'),
+    IContextMenuServiceProvider: Symbol.for('IContextMenuServiceProvider'),
+    IContextMenuProviderRegistry: Symbol.for('IContextMenuProviderRegistry'),
+    IContextMenuProvider: Symbol.for('IContextMenuProvider'),
+    ICopyPasteHandler: Symbol.for('ICopyPasteHandler'),
+    IGLSPToolManager: Symbol.for('IGLSPToolManager'),
+    ITool: Symbol.for('ITool'),
+    IDefaultTool: Symbol.for('IDefaultTool'),
+    IEditModeListener: Symbol.for('IEditModeListener'),
+    LayoutRegistration: Symbol.for('LayoutRegistration'),
+    IMarqueeBehavior: Symbol.for('IMarqueeBehavior')
 };

package/src/{features/model-source-watcher/model-source-changed-action.ts → base/view/view-registry.ts}

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * 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
@@ -13,14 +13,19 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action } from "sprotty";
+import { injectable } from 'inversify';
+import { IView, ViewRegistry } from 'sprotty';
 
-export class ModelSourceChangedAction implements Action {
-    static KIND = 'modelSourceChanged';
-    readonly kind = ModelSourceChangedAction.KIND;
-    constructor(public readonly modelSourceName: string) { }
-}
-
-export function isModelSourceChangedAction(action: Action): action is ModelSourceChangedAction {
-    return action.kind === ModelSourceChangedAction.KIND;
+@injectable()
+export class GLSPViewRegistry extends ViewRegistry {
+    register(key: string, instance: IView): void {
+        if (key === undefined) {
+            throw new Error('Key is undefined');
+        }
+        if (this.hasKey(key)) {
+            // do not throw error but log overwriting
+            console.log(`View instance for type '${key}' will be overwritten.`);
+        }
+        this.elements.set(key, instance);
+    }
 }