@eclipse-glsp/client 1.1.0-next.383e4e9.264 → 1.1.0-next.3d1b3e6.280

package/src/base/action-dispatcher.ts

@@ -15,14 +15,15 @@
  ********************************************************************************/
 import { inject, injectable } from 'inversify';
 import { Action, ActionDispatcher, RequestAction, ResponseAction } from '~glsp-sprotty';
-import { ModelInitializationConstraint } from './model-initialization-constraint';
+import { ModelInitializationConstraint } from './model/model-initialization-constraint';
 
 @injectable()
 export class GLSPActionDispatcher extends ActionDispatcher {
     protected readonly timeouts: Map<string, NodeJS.Timeout> = new Map();
     protected initializedConstraint = false;
 
-    @inject(ModelInitializationConstraint) protected initializationConstraint: ModelInitializationConstraint;
+    @inject(ModelInitializationConstraint)
+    protected initializationConstraint: ModelInitializationConstraint;
 
     override initialize(): Promise<void> {
         return super.initialize().then(() => this.startModelInitialization());
@@ -31,7 +32,7 @@ export class GLSPActionDispatcher extends ActionDispatcher {
     startModelInitialization(): void {
         if (!this.initializedConstraint) {
             this.logger.log(this, 'Starting model initialization mode');
-            this.initializationConstraint.onInitialized().then(() => this.logger.log(this, 'Model initialization completed'));
+            this.initializationConstraint.onInitialized(() => this.logger.log(this, 'Model initialization completed'));
             this.initializedConstraint = true;
         }
     }
@@ -44,8 +45,17 @@ export class GLSPActionDispatcher extends ActionDispatcher {
         return this.actionHandlerRegistry.get(action.kind).length > 0;
     }
 
-    override dispatch(action: Action): Promise<void> {
-        const result = super.dispatch(action);
+    /**
+     * Processes all given actions, by dispatching them to the corresponding handlers, after the model initialization is completed.
+     *
+     * @param actions The actions that should be dispatched after the model initialization
+     */
+    dispatchOnceModelInitialized(...actions: Action[]): void {
+        this.initializationConstraint.onInitialized(() => this.dispatchAll(actions));
+    }
+
+    override async dispatch(action: Action): Promise<void> {
+        const result = await super.dispatch(action);
         this.initializationConstraint.notifyDispatched(action);
         return result;
     }
@@ -59,11 +69,11 @@ export class GLSPActionDispatcher extends ActionDispatcher {
                 this.timeouts.delete(action.responseId);
             }
 
-            // we might have reached a timeout, so we simply drop the response
+            // Check if we have a pending request for the response.
+            // If not the  we clear the responseId => action will be dispatched normally
             const deferred = this.requests.get(action.responseId);
             if (deferred === undefined) {
-                this.logger.log(this, 'No matching request for response', action);
-                return Promise.resolve();
+                action.responseId = '';
             }
         }
         return super.handleAction(action);
@@ -87,7 +97,11 @@ export class GLSPActionDispatcher extends ActionDispatcher {
      * If `rejectOnTimeout` is set to false (default) the returned promise will be resolved with
      * no value, otherwise it will be rejected.
      */
-    requestUntil<Res extends ResponseAction>(action: RequestAction<Res>, timeoutMs = 2000, rejectOnTimeout = false): Promise<Res> {
+    requestUntil<Res extends ResponseAction>(
+        action: RequestAction<Res>,
+        timeoutMs = 2000,
+        rejectOnTimeout = false
+    ): Promise<Res | undefined> {
         if (!action.requestId && action.requestId === '') {
             // No request id has been specified. So we use a generated one.
             action.requestId = RequestAction.generateRequestId();
@@ -112,6 +126,6 @@ export class GLSPActionDispatcher extends ActionDispatcher {
         }, timeoutMs);
         this.timeouts.set(requestId, timeout);
 
-        return super.request(action);
+        return super.request<Res>(action);
     }
 }

package/src/{features/tools/base-glsp-creation-tool.ts → base/action-handler-registry.ts}

@@ -13,28 +13,18 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+
 import { injectable } from 'inversify';
-import { Action, EnableToolsAction, IActionHandler } from '~glsp-sprotty';
-import { BaseGLSPTool } from './base-glsp-tool';
+import { ActionHandlerRegistry } from '~glsp-sprotty';
 
 @injectable()
-export abstract class BaseGLSPCreationTool<T extends Action> extends BaseGLSPTool implements IActionHandler {
-    protected abstract isTriggerAction: (obj: any) => obj is T;
-    protected triggerAction: T;
-
-    handle(action: Action): Action | void {
-        if (this.isTriggerAction(action)) {
-            this.triggerAction = action;
-            return EnableToolsAction.create([this.id]);
-        }
+export class GLSPActionHandlerRegistry extends ActionHandlerRegistry {
+    /**
+     * Retrieve a set of all action kinds for which (at least) one
+     * handler is registered
+     * @returns the set of handled action kinds
+     */
+    getHandledActionKinds(): string[] {
+        return Array.from(this.elements.keys());
     }
-
-    override enable(): void {
-        if (this.triggerAction === undefined) {
-            throw new TypeError(`Could not enable tool ${this.id}. The triggerAction cannot be undefined.`);
-        }
-        this.doEnable();
-    }
-
-    protected abstract doEnable(): void;
 }

package/src/base/default.module.ts

@@ -14,16 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import '@vscode/codicons/dist/codicon.css';
-import { Container } from 'inversify';
 import {
     ActionHandlerRegistry,
     FeatureModule,
-    InitializeResult,
     KeyTool,
     LocationPostprocessor,
-    ModelSource,
     MouseTool,
     MoveCommand,
+    SetDirtyStateAction,
     SetEditModeAction,
     TYPES,
     bindAsService,
@@ -34,6 +32,7 @@ import {
 } from '~glsp-sprotty';
 import '../../css/glsp-sprotty.css';
 import { GLSPActionDispatcher } from './action-dispatcher';
+import { GLSPActionHandlerRegistry } from './action-handler-registry';
 import { GLSPCommandStack } from './command-stack';
 import { EditorContextService } from './editor-context-service';
 import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
@@ -41,11 +40,14 @@ import { FeedbackActionDispatcher } from './feedback/feedback-action-dispatcher'
 import { FeedbackAwareUpdateModelCommand } from './feedback/update-model-command';
 import { FocusStateChangedAction } from './focus/focus-state-change-action';
 import { FocusTracker } from './focus/focus-tracker';
-import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model-initialization-constraint';
+import { DiagramLoader } from './model/diagram-loader';
+import { GLSPModelSource } from './model/glsp-model-source';
+import { DefaultModelInitializationConstraint, ModelInitializationConstraint } from './model/model-initialization-constraint';
 import { GLSPModelRegistry } from './model/model-registry';
 import { SelectionClearingMouseListener } from './selection-clearing-mouse-listener';
 import { SelectionService } from './selection-service';
-import { GLSPToolManager } from './tool-manager/glsp-tool-manager';
+import { EnableDefaultToolsAction, EnableToolsAction } from './tool-manager/tool';
+import { DefaultToolsEnablingKeyListener, ToolManager, ToolManagerActionHandler } from './tool-manager/tool-manager';
 import { GLSPKeyTool } from './view/key-tool';
 import { GLSPMouseTool } from './view/mouse-tool';
 import { GLSPViewRegistry } from './view/view-registry';
@@ -60,18 +62,10 @@ export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, .
     const context = { bind, unbind, isBound, rebind };
 
     bind(EditorContextService).toSelf().inSingletonScope();
-    bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(
-        ctx => () =>
-            new Promise<EditorContextService>((resolve, reject) => {
-                if (ctx.container.isBound(EditorContextService)) {
-                    resolve(ctx.container.get<EditorContextService>(EditorContextService));
-                } else {
-                    reject();
-                }
-            })
-    );
+    bind(TYPES.IEditorContextServiceProvider).toProvider<EditorContextService>(ctx => async () => ctx.container.get(EditorContextService));
 
     configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
+    configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
 
     bind(FocusTracker).toSelf().inSingletonScope();
     configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
@@ -88,11 +82,13 @@ export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, .
     bindAsService(context, TYPES.MouseListener, SelectionClearingMouseListener);
 
     bindOrRebind(context, TYPES.ICommandStack).to(GLSPCommandStack).inSingletonScope();
-    bind(GLSPToolManager).toSelf().inSingletonScope();
-    bindOrRebind(context, TYPES.IToolManager).toService(GLSPToolManager);
     bind(GLSPActionDispatcher).toSelf().inSingletonScope();
     bindOrRebind(context, TYPES.IActionDispatcher).toService(GLSPActionDispatcher);
+    bind(GLSPActionHandlerRegistry).toSelf().inSingletonScope();
+    bindOrRebind(context, ActionHandlerRegistry).toService(GLSPActionHandlerRegistry);
 
+    bindAsService(context, TYPES.ModelSource, GLSPModelSource);
+    bind(DiagramLoader).toSelf().inSingletonScope();
     bind(ModelInitializationConstraint).to(DefaultModelInitializationConstraint).inSingletonScope();
 
     // support re-registration of model elements and views
@@ -110,21 +106,12 @@ export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, .
 
     bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
     bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
-});
 
-/**
- * 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));
-}
+    // Tool manager initialization ------------------------------------
+    bind(TYPES.IToolManager).to(ToolManager).inSingletonScope();
+    bind(DefaultToolsEnablingKeyListener).toSelf().inSingletonScope();
+    bind(TYPES.KeyListener).toService(DefaultToolsEnablingKeyListener);
+    bind(ToolManagerActionHandler).toSelf().inSingletonScope();
+    configureActionHandler(context, EnableDefaultToolsAction.KIND, ToolManagerActionHandler);
+    configureActionHandler(context, EnableToolsAction.KIND, ToolManagerActionHandler);
+});

package/src/base/editor-context-service.ts

@@ -24,21 +24,24 @@ import {
     Emitter,
     Event,
     IActionHandler,
-    ModelSource,
+    MaybePromise,
     MousePositionTracker,
     SModelElement,
     SModelRoot,
+    SetDirtyStateAction,
     SetEditModeAction,
     TYPES,
     ValueChange
 } from '~glsp-sprotty';
+import { GLSPActionDispatcher } from './action-dispatcher';
+import { IDiagramOptions, IDiagramStartup } from './model/diagram-loader';
 import { SelectionService } from './selection-service';
-import { isSourceUriAware } from './source-uri-aware';
 
 export interface IEditModeListener {
     editModeChanged(newValue: string, oldValue: string): void;
 }
 
+export type DirtyStateChange = Pick<SetDirtyStateAction, 'isDirty' | 'reason'>;
 /**
  * The `EditorContextService` is a central injectable component that gives read-only access to
  * certain aspects of the diagram, such as the currently selected elements, the model root,
@@ -52,32 +55,41 @@ export interface IEditModeListener {
  *    position, etc.).
  */
 @injectable()
-export class EditorContextService implements IActionHandler, Disposable {
+export class EditorContextService implements IActionHandler, Disposable, IDiagramStartup {
     @inject(SelectionService)
     protected selectionService: SelectionService;
 
     @inject(MousePositionTracker)
     protected mousePositionTracker: MousePositionTracker;
 
+    @inject(TYPES.IDiagramOptions)
+    protected diagramOptions: IDiagramOptions;
+
     @multiInject(TYPES.IEditModeListener)
     @optional()
     protected editModeListeners: IEditModeListener[] = [];
 
-    @inject(TYPES.ModelSourceProvider)
-    protected modelSourceProvider: () => Promise<ModelSource>;
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
 
     protected _editMode: string;
-
     protected onEditModeChangedEmitter = new Emitter<ValueChange<string>>();
     get onEditModeChanged(): Event<ValueChange<string>> {
         return this.onEditModeChangedEmitter.event;
     }
 
+    protected _isDirty: boolean;
+    protected onDirtyStateChangedEmitter = new Emitter<DirtyStateChange>();
+    get onDirtyStateChanged(): Event<DirtyStateChange> {
+        return this.onDirtyStateChangedEmitter.event;
+    }
+
     protected toDispose = new DisposableCollection();
 
     @postConstruct()
     protected initialize(): void {
-        this.toDispose.push(this.onEditModeChangedEmitter);
+        this._editMode = this.diagramOptions.editMode ?? EditMode.EDITABLE;
+        this.toDispose.push(this.onEditModeChangedEmitter, this.onDirtyStateChangedEmitter);
         this.editModeListeners.forEach(listener =>
             this.onEditModeChanged(change => listener.editModeChanged(change.newValue, change.oldValue))
         );
@@ -106,28 +118,41 @@ export class EditorContextService implements IActionHandler, Disposable {
 
     handle(action: Action): void {
         if (SetEditModeAction.is(action)) {
-            const oldValue = this._editMode;
-            this._editMode = action.editMode;
-            this.notifyEditModeListeners(oldValue);
+            this.handleSetEditModeAction(action);
+        } else if (SetDirtyStateAction.is(action)) {
+            this.handleSetDirtyStateAction(action);
         }
     }
 
-    protected notifyEditModeListeners(oldValue: string): void {
+    protected handleSetEditModeAction(action: SetEditModeAction): void {
+        const oldValue = this._editMode;
+        this._editMode = action.editMode;
         this.onEditModeChangedEmitter.fire({ newValue: this.editMode, oldValue });
     }
 
-    async getSourceUri(): Promise<string | undefined> {
-        const modelSource = await this.modelSourceProvider();
-        if (isSourceUriAware(modelSource)) {
-            return modelSource.sourceURI;
+    protected handleSetDirtyStateAction(action: SetDirtyStateAction): void {
+        if (action.isDirty !== this._isDirty) {
+            this._isDirty = action.isDirty;
+            this.onDirtyStateChangedEmitter.fire(action);
         }
-        return undefined;
+    }
+
+    get sourceUri(): string | undefined {
+        return this.diagramOptions.sourceUri;
     }
 
     get editMode(): string {
         return this._editMode;
     }
 
+    get diagramType(): string {
+        return this.diagramOptions.diagramType;
+    }
+
+    get clientId(): string {
+        return this.diagramOptions.clientId;
+    }
+
     get modelRoot(): Readonly<SModelRoot> {
         return this.selectionService.getModelRoot();
     }
@@ -139,6 +164,14 @@ export class EditorContextService implements IActionHandler, Disposable {
     get isReadonly(): boolean {
         return this.editMode === EditMode.READONLY;
     }
+
+    get isDirty(): boolean {
+        return this._isDirty;
+    }
+
+    postRequestModel(): MaybePromise<void> {
+        this.actionDispatcher.dispatch(SetEditModeAction.create(this.editMode));
+    }
 }
 
 export type EditorContextServiceProvider = () => Promise<EditorContextService>;

package/src/base/feedback/feedback-action-dispatcher.ts

@@ -67,14 +67,16 @@ export class FeedbackActionDispatcher implements IFeedbackActionDispatcher {
     @inject(TYPES.ILogger) protected logger: ILogger;
 
     registerFeedback(feedbackEmitter: IFeedbackEmitter, feedbackActions: Action[], cleanupActions?: Action[] | undefined): Disposable {
-        this.registeredFeedback.set(feedbackEmitter, feedbackActions);
-        this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        if (feedbackActions.length > 0) {
+            this.registeredFeedback.set(feedbackEmitter, feedbackActions);
+            this.dispatchFeedback(feedbackActions, feedbackEmitter);
+        }
         return Disposable.create(() => this.deregisterFeedback(feedbackEmitter, cleanupActions));
     }
 
     deregisterFeedback(feedbackEmitter: IFeedbackEmitter, cleanupActions?: Action[] | undefined): void {
         this.registeredFeedback.delete(feedbackEmitter);
-        if (cleanupActions) {
+        if (cleanupActions && cleanupActions.length > 0) {
             this.dispatchFeedback(cleanupActions, feedbackEmitter);
         }
     }

package/src/base/focus/focus-tracker.ts

@@ -21,6 +21,8 @@ import { FocusStateChangedAction } from './focus-state-change-action';
 export class FocusTracker implements IActionHandler {
     protected inActiveCssClass = 'inactive';
     protected _hasFocus = true;
+    protected _focusElement: HTMLOrSVGElement | null;
+    protected _diagramElement: HTMLElement | null;
 
     @inject(TYPES.ViewerOptions) protected options: ViewerOptions;
 
@@ -28,19 +30,28 @@ export class FocusTracker implements IActionHandler {
         return this._hasFocus;
     }
 
+    get focusElement(): HTMLOrSVGElement | null {
+        return this._focusElement;
+    }
+
+    get diagramElement(): HTMLElement | null {
+        return this._diagramElement;
+    }
+
     handle(action: Action): void | Action | ICommand {
         if (FocusStateChangedAction.is(action)) {
             this._hasFocus = action.hasFocus;
-            const placeholder = document.getElementById(this.options.baseDiv);
-            if (!placeholder) {
+            this._focusElement = document.activeElement as HTMLOrSVGElement | null;
+            this._diagramElement = document.getElementById(this.options.baseDiv);
+            if (!this._diagramElement) {
                 return;
             }
             if (this.hasFocus) {
-                if (placeholder.classList.contains(this.inActiveCssClass)) {
-                    placeholder.classList.remove(this.inActiveCssClass);
+                if (this._diagramElement.classList.contains(this.inActiveCssClass)) {
+                    this._diagramElement.classList.remove(this.inActiveCssClass);
                 }
             } else {
-                placeholder.classList.add(this.inActiveCssClass);
+                this._diagramElement.classList.add(this.inActiveCssClass);
             }
         }
     }

package/src/base/model/diagram-loader.ts

@@ -0,0 +1,215 @@
+/********************************************************************************
+ * 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 { inject, injectable, multiInject, optional, postConstruct } from 'inversify';
+import {
+    AnyObject,
+    ApplicationIdProvider,
+    Args,
+    EMPTY_ROOT,
+    GLSPClient,
+    InitializeParameters,
+    MaybePromise,
+    RequestModelAction,
+    SetModelAction,
+    StatusAction,
+    TYPES,
+    hasNumberProp
+} from '~glsp-sprotty';
+import { GLSPActionDispatcher } from '../action-dispatcher';
+import { Ranked } from '../ranked';
+import { GLSPModelSource } from './glsp-model-source';
+import { ModelInitializationConstraint } from './model-initialization-constraint';
+
+/**
+ * Configuration options for a specific GLSP diagram instance.
+ */
+export interface IDiagramOptions {
+    /**
+     * Unique id associated with this diagram. Used on the server side to identify the
+     * corresponding client session.
+     */
+    clientId: string;
+    /**
+     * The diagram type i.e. diagram language this diagram is associated with.
+     */
+    diagramType: string;
+    /**
+     * The provider function to retrieve the GLSP client used by this diagram to communicate with the server.
+     * Multiple invocations of the provder function should always return the same `GLSPClient` instance.
+     */
+    glspClientProvider: () => Promise<GLSPClient>;
+    /**
+     * The file source URI associated with this diagram.
+     */
+    sourceUri?: string;
+    /**
+     * The initial edit mode of diagram. Defaults to `editable`.
+     */
+    editMode?: string;
+}
+
+/**
+ * Services that implement startup hooks which are invoked during the {@link DiagramLoader.load} process.
+ * Typically used to dispatch additional initial actions and/or activate UI extensions on startup.
+ * Execution order is derived by the `rank` property of the service. If not present, the {@link Ranked.DEFAULT_RANK} will be assumed.
+ */
+export interface IDiagramStartup extends Partial<Ranked> {
+    /**
+     * Hook for services that should be executed before the underlying GLSP client is configured and the server is initialized.
+     */
+    preInitialize?(): MaybePromise<void>;
+    /**
+     * Hook for services that should be executed before the initial model loading request (i.e. `RequestModelAction`) but
+     * after the underlying GLSP client has been configured and the server is initialized.
+     */
+    preRequestModel?(): MaybePromise<void>;
+    /**
+     * Hook for services that should be executed after the initial model loading request (i.e. `RequestModelAction`).
+     * Note that this hook is invoked directly after the `RequestModelAction` has been dispatched. It does not necessarily wait
+     * until the client-server update roundtrip is completed. If you need to wait until the diagram is fully initialized use the
+     * {@link postModelInitialization} hook.
+     */
+    postRequestModel?(): MaybePromise<void>;
+    /* Hook for services that should be executed after the diagram model is fully initialized
+     * (i.e. `ModelInitializationConstraint` is completed).
+     */
+    postModelInitialization?(): MaybePromise<void>;
+}
+
+export namespace IDiagramStartup {
+    export function is(object: unknown): object is IDiagramStartup {
+        return (
+            AnyObject.is(object) &&
+            hasNumberProp(object, 'rank', true) &&
+            ('preInitialize' in object ||
+                'preRequestModel' in object ||
+                'postRequestModel' in object ||
+                'postModelInitialization' in object)
+        );
+    }
+}
+
+export interface DiagramLoadingOptions {
+    /**
+     * Optional custom options that should be used the initial {@link RequestModelAction}.
+     * These options will be merged with the default options (`diagramType` and `sourceUri`).
+     * Defaults to an empty object if not defined.
+     */
+    requestModelOptions?: Args;
+
+    /**
+     * Optional partial {@link InitializeParameters} that should be used for `initializeServer` request if the underlying
+     * {@link GLSPClient} has not been initialized yet.
+     */
+    initializeParameters?: Partial<InitializeParameters>;
+
+    /**
+     * Flag to enable/disable client side notifications during the loading process.
+     * Defaults to `true` if not defined
+     */
+    enableNotifications?: boolean;
+}
+
+export interface ResolvedDiagramLoadingOptions {
+    requestModelOptions: Args;
+    initializeParameters: InitializeParameters;
+    enableNotifications: boolean;
+}
+
+/**
+ * The central component responsible for initializing the diagram and loading the graphical model
+ * from the GLSP server.
+ * Invoking the {@link DiagramLoader.load} method is typically the first operation that is executed after
+ * a diagram DI container has been created.
+ */
+@injectable()
+export class DiagramLoader {
+    @inject(TYPES.IDiagramOptions)
+    protected options: IDiagramOptions;
+
+    @inject(GLSPActionDispatcher)
+    protected actionDispatcher: GLSPActionDispatcher;
+
+    @multiInject(TYPES.IDiagramStartup)
+    @optional()
+    protected diagramStartups: IDiagramStartup[] = [];
+
+    @inject(GLSPModelSource)
+    protected modelSource: GLSPModelSource;
+
+    @inject(ModelInitializationConstraint)
+    protected modelInitializationConstraint: ModelInitializationConstraint;
+
+    @postConstruct()
+    protected postConstruct(): void {
+        this.diagramStartups.sort((a, b) => Ranked.getRank(a) - Ranked.getRank(b));
+    }
+
+    async load(options: DiagramLoadingOptions = {}): Promise<void> {
+        const resolvedOptions: ResolvedDiagramLoadingOptions = {
+            requestModelOptions: {
+                sourceUri: this.options.sourceUri ?? '',
+                diagramType: this.options.diagramType,
+                ...options.requestModelOptions
+            },
+            initializeParameters: {
+                applicationId: ApplicationIdProvider.get(),
+                protocolVersion: GLSPClient.protocolVersion,
+                ...options.initializeParameters
+            },
+            enableNotifications: options.enableNotifications ?? true
+        };
+        // Set empty place holder model until actual model from server is available
+        await this.actionDispatcher.dispatch(SetModelAction.create(EMPTY_ROOT));
+        await this.invokeStartupHook('preInitialize');
+        await this.initialize(resolvedOptions);
+        await this.invokeStartupHook('preRequestModel');
+        await this.requestModel(resolvedOptions);
+        await this.invokeStartupHook('postRequestModel');
+        this.modelInitializationConstraint.onInitialized(() => this.invokeStartupHook('postModelInitialization'));
+    }
+
+    protected async invokeStartupHook(hook: keyof Omit<IDiagramStartup, 'rank'>): Promise<void> {
+        for (const startup of this.diagramStartups) {
+            await startup[hook]?.();
+        }
+    }
+
+    protected async requestModel(options: ResolvedDiagramLoadingOptions): Promise<void> {
+        const response = await this.actionDispatcher.request<SetModelAction>(
+            RequestModelAction.create({ options: options.requestModelOptions })
+        );
+        return this.actionDispatcher.dispatch(response);
+    }
+
+    protected async initialize(options: ResolvedDiagramLoadingOptions): Promise<void> {
+        if (options.enableNotifications) {
+            await this.actionDispatcher.dispatch(StatusAction.create('Initializing...', { severity: 'INFO' }));
+        }
+
+        const glspClient = await this.options.glspClientProvider();
+        await glspClient.start();
+        if (!glspClient.initializeResult) {
+            await glspClient.initializeServer(options.initializeParameters);
+        }
+        this.modelSource.configure(glspClient);
+
+        if (options.enableNotifications) {
+            this.actionDispatcher.dispatch(StatusAction.create('', { severity: 'NONE' }));
+        }
+    }
+}