@eclipse-glsp/server 1.1.0-next.3d7585d.42

package/src/common/features/model/gmodel-serializer.ts

@@ -0,0 +1,175 @@
+/********************************************************************************
+ * Copyright (c) 2017-2023 TypeFox and other
+ *
+ * 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
+ ********************************************************************************/
+/* Derived from sprotty (https://github.com/eclipse/sprotty/blob/master/packages/sprotty/src/base/model/smodel-factory.ts) */
+import { GModelElement, GModelElementConstructor, GModelElementSchema, GModelRoot, GModelRootSchema } from '@eclipse-glsp/graph';
+import { SModelElementSchema, SModelRootSchema } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { DiagramConfiguration } from '../../diagram/diagram-configuration';
+import { GLSPServerError } from '../../utils/glsp-server-error';
+
+export const GModelSerializer = Symbol('GModelSerializer');
+
+/**
+ * The `GModelSerializer` is used to transform a graphical model received as serializable JSON schema into the ES6-class based
+ * model representation and vice versa. It has to be invoked for whenever a graphical model is received in JSON format
+ * (i.e. by the GLSP client) to derive the corresponding class based model which is used internally by the GLSP server. In addition,
+ * it has to be invoked before the graphical model is sent based to the client. This is necessary to resolve the parent-child cycles
+ * inside of the graphical model which ensures that the model is serializable.
+ */
+export interface GModelSerializer {
+    /**
+     * Transform the given {@link GModelRootSchema} into its {@link GModelRoot} representation.
+     * @throws An error if the received element cannot be transformed into a {@link GModelRoot}.
+     * @param schema The root schema that should be transformed.
+     * @returns The transformed {@link GModelRoot}.
+     */
+    createRoot(schema: GModelRootSchema): GModelRoot;
+
+    /**
+     * Transform the given {@link GModelRootSchema} into its {@link GModelElement} representation.
+     * @throws An error if the received element cannot be transformed into a {@link GModelElement}.
+     * @param schema The element schema that should be transformed.
+     * @returns The transformed {@link GModelElement}.
+     */
+    createElement(schema: GModelElementSchema, parent?: GModelElement): GModelElement;
+
+    /**
+     * Transforms the given {@link GModelElement} into its serializable {@link GModelElementSchema} representation.
+     * @param element The element that should be serialized.
+     * @returns The transformed {@link GModelElementSchema}.
+     */
+    createSchema(element: GModelElement): GModelElementSchema;
+
+    /**
+     * The set of reserved property keys that should be excluded from serialization. Typically
+     * this set contains at least the `children` and `parent` keys to avoid parent-child cycles.
+     */
+    reservedKeys: string[];
+}
+
+@injectable()
+export class DefaultGModelSerializer implements GModelSerializer {
+    @inject(DiagramConfiguration) protected diagramConfiguration: DiagramConfiguration;
+
+    reservedKeys = ['children', 'parent', 'index', 'source', 'target'];
+    createRoot(schema: SModelElementSchema): GModelRoot {
+        const constructor = this.getConfiguredConstructor(schema);
+        if (constructor) {
+            const element = new constructor();
+            if (!(element instanceof GModelRoot)) {
+                throw new GLSPServerError(`Element with type '${schema.type}' is expected to be a GModelRoot!`);
+            }
+            return this.initializeRoot(element, schema);
+        }
+        throw new GLSPServerError(`No constructor is configured in DiagramConfiguration for type ${schema.type}`);
+    }
+
+    getConfiguredConstructor(schema: SModelElementSchema): GModelElementConstructor | undefined {
+        let key = schema.type;
+        while (!this.diagramConfiguration.typeMapping.has(key)) {
+            const i = key.lastIndexOf(':');
+            if (i > 0) {
+                key = key.substring(0, i);
+            } else {
+                return undefined;
+            }
+        }
+
+        const constructor = this.diagramConfiguration.typeMapping.get(key)!;
+        if (key !== schema.type) {
+            this.diagramConfiguration.typeMapping.set(key, constructor);
+        }
+        return constructor;
+    }
+
+    createElement(schema: SModelElementSchema, parent?: GModelElement): GModelElement {
+        const constructor = this.getConfiguredConstructor(schema);
+        if (constructor) {
+            const element = new constructor();
+            if (element instanceof GModelRoot) {
+                throw new GLSPServerError(
+                    `Element with type '${schema.type}' is a GModelRoot! 'createElement()' is expected to only create child elements!`
+                );
+            }
+            return this.initializeChild(element, schema, parent);
+        }
+        throw new GLSPServerError(`No constructor is configured in DiagramConfiguration for type ${schema.type}`);
+    }
+
+    createSchema(element: GModelElement): SModelElementSchema {
+        const schema = {};
+        for (const key in element) {
+            if (!this.isReserved(element, key)) {
+                const value: any = (element as any)[key];
+                if (typeof value !== 'function') {
+                    (schema as any)[key] = value;
+                }
+            }
+        }
+        (schema as any)['children'] = (element.children ?? []).map(child => this.createSchema(child));
+
+        return schema as SModelElementSchema;
+    }
+
+    protected initializeRoot(root: GModelRoot, schema: SModelRootSchema): GModelRoot {
+        this.initializeParent(root, schema);
+        return root;
+    }
+
+    protected initializeElement(element: GModelElement, schema: SModelElementSchema): GModelElement {
+        for (const key in schema) {
+            if (!this.isReserved(element, key)) {
+                const value = (schema as any)[key];
+                if (typeof value !== 'function') {
+                    (element as any)[key] = value;
+                }
+            }
+        }
+        return element;
+    }
+
+    protected initializeChild(child: GModelElement, schema: SModelElementSchema, parent?: GModelElement): GModelElement {
+        this.initializeParent(child, schema);
+        if (parent) {
+            child.parent = parent;
+        }
+        return child;
+    }
+
+    protected initializeParent(parent: GModelElement, schema: SModelElementSchema): GModelElement {
+        this.initializeElement(parent, schema);
+        if (schema.children) {
+            parent.children = schema.children.map(childSchema => this.createElement(childSchema, parent));
+        }
+
+        return parent;
+    }
+
+    protected isReserved(element: GModelElement, propertyName: string): boolean {
+        if (this.reservedKeys.indexOf(propertyName) >= 0) {
+            return true;
+        }
+        let obj = element;
+        do {
+            const descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);
+            if (descriptor !== undefined) {
+                return descriptor.get !== undefined;
+            }
+            obj = Object.getPrototypeOf(obj);
+        } while (obj);
+        return false;
+    }
+}

package/src/common/features/model/model-state.ts

@@ -0,0 +1,101 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { GModelRoot } from '@eclipse-glsp/graph';
+import { EditMode } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ClientId } from '../../di/service-identifiers';
+import { GModelIndex } from './gmodel-index';
+import { GModelSerializer } from './gmodel-serializer';
+
+export const ModelState = Symbol('ModelState');
+
+export interface ModelState {
+    set<P>(key: string, property: P): void;
+    setAll(properties: Record<string, unknown>): void;
+    get<P>(key: string, guard?: (object: unknown) => object is P): P | undefined;
+    clear(key: string): void;
+    readonly root: GModelRoot;
+    updateRoot(newRoot: GModelRoot): void;
+    editMode: string;
+    isDirty: boolean;
+    sourceUri?: string;
+    clientId: string;
+    readonly isReadonly: boolean;
+    readonly index: GModelIndex;
+}
+
+export const SOURCE_URI_ARG = 'sourceUri';
+
+@injectable()
+export class DefaultModelState implements ModelState {
+    @inject(GModelIndex)
+    readonly index: GModelIndex;
+
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
+    @inject(ClientId)
+    readonly clientId: string;
+
+    protected properties = new Map<string, any>();
+
+    protected _root: GModelRoot;
+
+    editMode = EditMode.EDITABLE;
+
+    isDirty = false;
+
+    set<P>(key: string, property: P): void {
+        this.properties.set(key, property);
+    }
+
+    setAll(properties: Record<string, unknown>): void {
+        Object.keys(properties).forEach(key => this.properties.set(key, properties[key]));
+    }
+
+    get<P>(key: string, guard?: (object: unknown) => object is P): P | undefined {
+        const result = this.properties.get(key);
+        if (!guard) {
+            return result as P;
+        }
+        return guard(result) ? result : undefined;
+    }
+
+    get sourceUri(): string | undefined {
+        return this.get(SOURCE_URI_ARG);
+    }
+
+    clear(key: string): void {
+        this.properties.delete(key);
+    }
+
+    get isReadonly(): boolean {
+        return this.editMode === EditMode.READONLY;
+    }
+
+    public get root(): GModelRoot {
+        return this._root;
+    }
+
+    protected set root(root: GModelRoot) {
+        this._root = root;
+    }
+
+    updateRoot(newRoot: GModelRoot): void {
+        this.root = newRoot;
+        this.index.indexRoot(newRoot);
+    }
+}

package/src/common/features/model/model-submission-handler.ts

@@ -0,0 +1,106 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { GModelRootSchema } from '@eclipse-glsp/graph';
+import {
+    Action,
+    DirtyStateChangeReason,
+    MaybePromise,
+    RequestBoundsAction,
+    SetDirtyStateAction,
+    SetModelAction,
+    UpdateModelAction
+} from '@eclipse-glsp/protocol';
+import { inject, injectable, optional } from 'inversify';
+import { DiagramConfiguration, ServerLayoutKind } from '../../diagram/diagram-configuration';
+import { LayoutEngine } from '../layout/layout-engine';
+import { GModelFactory } from './gmodel-factory';
+import { GModelSerializer } from './gmodel-serializer';
+import { ModelState } from './model-state';
+
+@injectable()
+export class ModelSubmissionHandler {
+    @inject(DiagramConfiguration)
+    protected diagramConfiguration: DiagramConfiguration;
+
+    @inject(GModelSerializer)
+    protected serializer: GModelSerializer;
+
+    @inject(GModelFactory)
+    protected modelFactory: GModelFactory;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(LayoutEngine)
+    @optional()
+    protected layoutEngine: LayoutEngine;
+
+    /**
+     * Returns a list of actions to update the client-side model, based on the specified <code>modelState</code>.
+     *
+     * These actions are not processed by this {@link ModelSubmissionHandler}, but should be either manually dispatched
+     * to the `ActionDispatcher`, or simply returned as the result of an `ActionHandler.execute()` method.
+     *
+     * @param reason The optional reason that caused the model update.
+     * @returns A list of actions to be processed in order to submit the model.
+     */
+    submitModel(reason?: DirtyStateChangeReason): MaybePromise<Action[]> {
+        this.modelFactory.createModel();
+        this.modelState.root.revision = (this.modelState.root.revision ?? 0) + 1;
+        const root = this.serializeGModel();
+
+        if (this.diagramConfiguration.needsClientLayout) {
+            return [RequestBoundsAction.create(root), SetDirtyStateAction.create(this.modelState.isDirty, { reason })];
+        }
+        return [SetModelAction.create(root)];
+    }
+
+    /**
+     * Returns a list of actions to directly update the client-side model without any server- or client-side layouting.
+     *
+     * Typically `ActionHandler`s don't invoke this method but use {@link submitModel()}
+     * instead, as this is only used to eventually submit the model on the client directly after all layouting is already
+     * performed before. The only foreseen caller of this method is `ComputedBoundsActionHandler`.
+     *
+     * These actions are not processed by this {@link ModelSubmissionHandler}, but should be either manually dispatched
+     * to the `ActionDispatcher`, or simply returned as the result of an
+     * `ActionHandler.execute()` method.
+     *
+     * @param reason The optional reason that caused the model update.
+     * @returns A list of actions to be processed in order to submit the model.
+     */
+    async submitModelDirectly(reason?: DirtyStateChangeReason): Promise<Action[]> {
+        const root = this.serializeGModel();
+
+        if (this.diagramConfiguration.layoutKind === ServerLayoutKind.AUTOMATIC && this.layoutEngine) {
+            await this.layoutEngine.layout();
+        }
+        const result: Action[] = [];
+        result.push(
+            root.revision === 0
+                ? SetModelAction.create(root)
+                : UpdateModelAction.create(root, { animate: this.diagramConfiguration.animatedUpdate })
+        );
+        if (!this.diagramConfiguration.needsClientLayout) {
+            result.push(SetDirtyStateAction.create(this.modelState.isDirty, { reason }));
+        }
+        return result;
+    }
+
+    protected serializeGModel(): GModelRootSchema {
+        return this.serializer.createSchema(this.modelState.root);
+    }
+}

package/src/common/features/model/request-model-action-handler.ts

@@ -0,0 +1,67 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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, RequestModelAction, ServerMessageAction, ServerStatusAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionDispatcher } from '../../actions/action-dispatcher';
+import { ActionHandler } from '../../actions/action-handler';
+import { Logger } from '../../utils/logger';
+import { ModelState } from './model-state';
+import { ModelSubmissionHandler } from './model-submission-handler';
+import { SourceModelStorage } from './source-model-storage';
+
+@injectable()
+export class RequestModelActionHandler implements ActionHandler {
+    actionKinds = [RequestModelAction.KIND];
+
+    @inject(Logger)
+    private logger: Logger;
+
+    @inject(SourceModelStorage)
+    protected sourceModelStorage: SourceModelStorage;
+
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(ModelSubmissionHandler)
+    protected submissionHandler: ModelSubmissionHandler;
+
+    async execute(action: RequestModelAction): Promise<Action[]> {
+        this.logger.debug('Execute RequestModelAction:', action);
+        this.modelState.setAll(action.options ?? {});
+
+        this.notifyClient('Model loading in progress');
+        await this.sourceModelStorage.loadSourceModel(action);
+        // Clear the previous notification.
+        this.notifyClient();
+        return this.submissionHandler.submitModel();
+    }
+
+    /**
+     * Send a message and status notification with the given message to the client.
+     * An empty message is an indication for the client to clear previously received notifications.
+     * @param message The message that should be sent to the client
+     */
+    protected notifyClient(message = ''): void {
+        const severity = message.length > 0 ? 'INFO' : 'NONE';
+        this.actionDispatcher.dispatchAll(
+            ServerMessageAction.create(message, { severity }),
+            ServerStatusAction.create(message, { severity })
+        );
+    }
+}

package/src/common/features/model/save-model-action-handler.ts

@@ -0,0 +1,38 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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, SaveModelAction, SetDirtyStateAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionHandler } from '../../actions/action-handler';
+import { ModelState } from './model-state';
+import { SourceModelStorage } from './source-model-storage';
+
+@injectable()
+export class SaveModelActionHandler implements ActionHandler {
+    actionKinds = [SaveModelAction.KIND];
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(SourceModelStorage)
+    protected sourceModelStorage: SourceModelStorage;
+
+    async execute(action: SaveModelAction): Promise<Action[]> {
+        await this.sourceModelStorage.saveSourceModel(action);
+        this.modelState.isDirty = false; // TODO: call save is done when available
+
+        return [SetDirtyStateAction.create(this.modelState.isDirty, { reason: 'save' })];
+    }
+}

package/src/common/features/model/source-model-storage.ts

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { MaybePromise, RequestModelAction, SaveModelAction } from '@eclipse-glsp/protocol';
+
+export const SourceModelStorage = Symbol('SourceModelStorage');
+
+/**
+ * A source model storage handles the persistence of source models, i.e. loading and saving it from/into the model state.
+ *
+ * A `source model` is an arbitrary model from which the graph model of the diagram is to be created.
+ * Implementations of source model loaders are specific to the type of source model or persistence format that is used
+ * for a type of source model. A source model loader obtains the information on which source model shall loaded from a
+ * {@link RequestModelAction}; typically its client options. Once the source model is loaded, a model loader is expected
+ * to put the loaded source model into the model state for further processing, such as transforming the loaded model
+ * into a graph model (see GModelFactory).
+ * On `saveSourceModel(SaveModelAction)`, the source model storage persists the source model from the model state.
+ *
+ * @see ClientOptionsUtil
+ * @see GModelFactory
+ */
+export interface SourceModelStorage {
+    /**
+     * Loads a source model into the `modelState`.
+     *
+     * @param action Action sent by the client to specifying the information needed to load the source model.
+     */
+    loadSourceModel(action: RequestModelAction): MaybePromise<void>;
+
+    /**
+     * Saves the source model from the `modelState`.
+     * Implementations are expected to throw an error if the save didn't work.
+     *
+     * @param action Action sent by the client to specifying the information needed to save the source model.
+     */
+    saveSourceModel(action: SaveModelAction): MaybePromise<void>;
+}

package/src/common/features/navigation/json-opener-options.ts

@@ -0,0 +1,69 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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
+ ********************************************************************************/
+export class JsonOpenerOptions {
+    selection: TextSelection;
+
+    constructor(selection?: TextSelection) {
+        if (selection) {
+            this.selection = selection;
+        }
+    }
+
+    public toString(): string {
+        return `JsonOpenerOptions [selection=${this.selection}]`;
+    }
+
+    public toJson(): string {
+        return JsonOpenerOptions.toJson(this);
+    }
+
+    public static toJson(options: JsonOpenerOptions): string {
+        return JSON.stringify(options);
+    }
+
+    public static fromJson(options: string): JsonOpenerOptions | undefined {
+        const parsed = JSON.parse(options);
+        return parsed instanceof JsonOpenerOptions ? parsed : undefined;
+    }
+}
+
+export class TextSelection {
+    start: LinePosition;
+    end: LinePosition;
+
+    constructor(start: LinePosition, end: LinePosition) {
+        this.start = start;
+        this.end = end;
+    }
+
+    public toString(): string {
+        return `TextSelection [start=${this.start}, end=${this.end}]`;
+    }
+}
+
+export class LinePosition {
+    line: number;
+    character: number;
+
+    constructor(line: number, character: number) {
+        this.line = line;
+        this.character = character;
+    }
+
+    public toString(): string {
+        return `LinePosition [line=${this.line}, character=${this.character}]`;
+    }
+}

package/src/common/features/navigation/navigation-target-provider-registry.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2022-2023 STMicroelectronics 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 { multiInject, optional } from 'inversify';
+import { NavigationTargetProviders } from '../../di/service-identifiers';
+import { Registry } from '../../utils/registry';
+import { NavigationTargetProvider } from './navigation-target-provider';
+
+export const NavigationTargetProviderRegistry = Symbol('NavigationTargetProviderRegistry');
+
+/**
+ * This registry keeps track of registered {@link NavigationTargetProvider} for a certain target types.
+ */
+export interface NavigationTargetProviderRegistry extends Registry<string, NavigationTargetProvider> {}
+
+export class DefaultNavigationTargetProviderRegistry
+    extends Registry<string, NavigationTargetProvider>
+    implements NavigationTargetProviderRegistry
+{
+    constructor(@multiInject(NavigationTargetProviders) @optional() navigationTargetProviders: NavigationTargetProvider[] = []) {
+        super();
+        navigationTargetProviders.forEach(provider => this.register(provider.targetTypeId, provider));
+    }
+}