@eclipse-glsp/client 1.1.0-next.93fd4ec.241 → 1.1.0-next.976795c.271

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/client",
-  "version": "1.1.0-next.93fd4ec.241+93fd4ec",
+  "version": "1.1.0-next.976795c.271+976795c",
   "description": "A sprotty-based client for GLSP",
   "keywords": [
     "eclipse",
@@ -36,7 +36,7 @@
     "css"
   ],
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsc -b && tsc-alias",
     "clean": "rimraf lib tsconfig.tsbuildinfo  coverage .nyc_output",
     "lint": "eslint --ext .ts,.tsx ./src",
     "lint:ci": "yarn lint -o eslint.xml -f checkstyle",
@@ -47,15 +47,19 @@
     "watch": "tsc -w"
   },
   "dependencies": {
-    "@eclipse-glsp/protocol": "1.1.0-next.93fd4ec.241+93fd4ec",
+    "@eclipse-glsp/protocol": "1.1.0-next.976795c.271+976795c",
     "autocompleter": "5.1.0",
-    "sprotty": "0.13.0-next.f4445dd.342"
+    "lodash": "4.17.21",
+    "sprotty": "0.14.0-next.02bbac0.26"
   },
   "devDependencies": {
-    "@vscode/codicons": "^0.0.25"
+    "@types/file-saver": "^2.0.3",
+    "@types/lodash": "4.14.191",
+    "@vscode/codicons": "^0.0.25",
+    "tsc-alias": "^1.8.2"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "93fd4ece3dc9e1de392040d5bc481e8720a780b1"
+  "gitHead": "976795cf74566bacc8c90980b0e81b71087c0c69"
 }

package/src/base/action-dispatcher.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019-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
@@ -13,14 +13,15 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, RequestAction, ResponseAction } from '@eclipse-glsp/protocol';
-import { inject } from 'inversify';
-import { ActionDispatcher } from 'sprotty';
+import { inject, injectable } from 'inversify';
+import { Action, ActionDispatcher, RequestAction, ResponseAction } from '~glsp-sprotty';
 import { ModelInitializationConstraint } from './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;
 
     override initialize(): Promise<void> {
@@ -39,6 +40,10 @@ export class GLSPActionDispatcher extends ActionDispatcher {
         return this.initializationConstraint.onInitialized();
     }
 
+    hasHandler(action: Action): boolean {
+        return this.actionHandlerRegistry.get(action.kind).length > 0;
+    }
+
     override dispatch(action: Action): Promise<void> {
         const result = super.dispatch(action);
         this.initializationConstraint.notifyDispatched(action);

package/src/base/argumentable.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Args } from '@eclipse-glsp/protocol';
-import { SModelElement } from 'sprotty';
+import { Args, SModelElement } from '~glsp-sprotty';
 
 export interface SArgumentable {
     args: Args;

package/src/base/auto-complete/auto-complete-actions.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2022 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { hasStringProp, LabeledAction } from '@eclipse-glsp/protocol';
+import { hasStringProp, LabeledAction } from '~glsp-sprotty';
 
 export interface AutoCompleteValue extends LabeledAction {
     readonly text: string;

package/src/base/auto-complete/auto-complete-widget.ts

@@ -13,11 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, LabeledAction, ValidationStatus } from '@eclipse-glsp/protocol';
 import { AutocompleteResult, AutocompleteSettings } from 'autocompleter';
-import { codiconCSSClasses, ILogger, SModelRoot } from 'sprotty';
-import { toArray } from 'sprotty/lib/utils/iterable';
-import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+import { Action, ILogger, LabeledAction, SModelRoot, ValidationStatus, codiconCSSClasses, matchesKeystroke, toArray } from '~glsp-sprotty';
 import { AutoCompleteValue } from './auto-complete-actions';
 import { IValidationDecorator } from './validation-decorator';
 
@@ -28,6 +25,7 @@ export interface AutoCompleteSettings {
     readonly showOnFocus?: boolean;
 }
 
+export type CloseReason = 'submission' | 'blur' | 'escape';
 export interface InputValidator {
     validate(input: string): Promise<ValidationStatus>;
 }
@@ -48,6 +46,11 @@ export interface TextSubmitHandler {
     executeFromTextOnlyInput(input: string): void;
 }
 
+export interface AutoCompleteWidgetOptions {
+    visibleSuggestionsChanged?: (suggestions: LabeledAction[]) => void;
+    selectedSuggestionChanged?: (suggestion?: LabeledAction) => void;
+}
+
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const configureAutocomplete: (settings: AutocompleteSettings<LabeledAction>) => AutocompleteResult = require('autocompleter');
 
@@ -78,8 +81,9 @@ export class AutoCompleteWidget {
         public suggestionProvider: SuggestionProvider,
         public suggestionSubmitHandler: SuggestionSubmitHandler,
         // eslint-disable-next-line @typescript-eslint/no-empty-function
-        protected notifyClose: () => void = () => {},
-        protected logger?: ILogger
+        protected notifyClose: (reason: CloseReason) => void = () => {},
+        protected logger?: ILogger,
+        protected options?: AutoCompleteWidgetOptions
     ) {}
 
     configureValidation(
@@ -109,13 +113,18 @@ export class AutoCompleteWidget {
         inputElement.autocomplete = 'false';
         inputElement.style.width = '100%';
         inputElement.addEventListener('keydown', event => this.handleKeyDown(event));
-        inputElement.addEventListener('blur', () => window.setTimeout(() => this.notifyClose(), 200));
+        inputElement.addEventListener('blur', () => {
+            if (this.containerElement.style.visibility !== 'hidden') {
+                window.setTimeout(() => this.notifyClose('blur'), 200);
+            }
+        });
+
         return inputElement;
     }
 
     protected handleKeyDown(event: KeyboardEvent): void {
         if (matchesKeystroke(event, 'Escape')) {
-            this.notifyClose();
+            this.notifyClose('escape');
             return;
         }
         if (matchesKeystroke(event, 'Enter') && !this.isInputElementChanged() && this.isSuggestionAvailable()) {
@@ -133,7 +142,7 @@ export class AutoCompleteWidget {
         }
         if (this.textSubmitHandler) {
             this.executeFromTextOnlyInput();
-            this.notifyClose();
+            this.notifyClose('submission');
         }
     }
 
@@ -175,6 +184,17 @@ export class AutoCompleteWidget {
         // move container into our UIExtension container as this is already positioned correctly
         if (this.containerElement) {
             this.containerElement.appendChild(container);
+
+            if (this.options && this.options.selectedSuggestionChanged) {
+                const selectedElement = container.querySelector('.selected');
+                // eslint-disable-next-line no-null/no-null
+                if (selectedElement !== null && selectedElement !== undefined) {
+                    const index = Array.from(container.children).indexOf(selectedElement);
+                    this.options.selectedSuggestionChanged(this.contextActions?.[index]);
+                } else {
+                    this.options.selectedSuggestionChanged(undefined);
+                }
+            }
         }
     }
 
@@ -189,6 +209,7 @@ export class AutoCompleteWidget {
             .then(actions => {
                 this.contextActions = this.filterActions(text, actions);
                 update(this.contextActions);
+                this.options?.visibleSuggestionsChanged?.(this.contextActions);
                 this.onLoaded('success');
             })
             .catch(reason => {
@@ -228,7 +249,7 @@ export class AutoCompleteWidget {
         if (item.icon) {
             this.renderIcon(itemElement, item.icon);
         }
-        itemElement.innerHTML += item.label.replace(regex, match => '<em>' + match + '</em>');
+        itemElement.innerHTML += item.label.replace(regex, match => '<em>' + match + '</em>').replace(/ /g, '&nbsp;');
         return itemElement;
     }
 
@@ -257,7 +278,7 @@ export class AutoCompleteWidget {
             window.setTimeout(() => this.inputElement.dispatchEvent(new Event('keyup')));
         } else {
             this.executeFromSuggestion(item);
-            this.notifyClose();
+            this.notifyClose('submission');
         }
     }
 

package/src/base/auto-complete/validation-decorator.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020-2021 EclipseSource and others.
+ * Copyright (c) 2020-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
@@ -13,8 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { codiconCSSString } from 'sprotty/lib/utils/codicon';
-import { ValidationStatus } from '@eclipse-glsp/protocol';
+import { ValidationStatus, codiconCSSString } from '~glsp-sprotty';
 
 export interface IValidationDecorator {
     decorateValidationResult(status: ValidationStatus): void;

package/src/base/command-stack.ts

@@ -13,11 +13,51 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from 'inversify';
-import { CommandStack, SModelRoot } from 'sprotty';
+import { injectable, multiInject, optional, preDestroy } from 'inversify';
+import {
+    CommandStack,
+    Disposable,
+    DisposableCollection,
+    Emitter,
+    Event,
+    ICommand,
+    SModelRoot,
+    SetModelCommand,
+    TYPES,
+    UpdateModelCommand
+} from '~glsp-sprotty';
+
+/**
+ * A hook to listen for model root changes. Will be called after a server update
+ * has been processed
+ */
+export interface ISModelRootListener {
+    modelRootChanged(root: Readonly<SModelRoot>): void;
+}
 
 @injectable()
-export class GLSPCommandStack extends CommandStack {
+export class GLSPCommandStack extends CommandStack implements Disposable {
+    @multiInject(TYPES.ISModelRootListener)
+    @optional()
+    protected modelRootListeners: ISModelRootListener[] = [];
+    protected toDispose = new DisposableCollection();
+
+    protected override initialize(): void {
+        super.initialize();
+        this.toDispose.push(this.onModelRootChangedEmitter);
+        this.modelRootListeners.forEach(listener => this.onModelRootChanged(root => listener.modelRootChanged(root)));
+    }
+
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
+    protected onModelRootChangedEmitter = new Emitter<Readonly<SModelRoot>>();
+    get onModelRootChanged(): Event<Readonly<SModelRoot>> {
+        return this.onModelRootChangedEmitter.event;
+    }
+
     override undo(): Promise<SModelRoot> {
         this.logger.warn(
             this,
@@ -33,4 +73,16 @@ export class GLSPCommandStack extends CommandStack {
         );
         return this.currentModel;
     }
+
+    override execute(command: ICommand): Promise<SModelRoot> {
+        const result = super.execute(command);
+        if (command instanceof SetModelCommand || command instanceof UpdateModelCommand) {
+            result.then(root => this.notifyListeners(root));
+        }
+        return result;
+    }
+
+    protected notifyListeners(root: Readonly<SModelRoot>): void {
+        this.onModelRootChangedEmitter.fire(root);
+    }
 }

package/src/base/default.module.ts

@@ -0,0 +1,115 @@
+/********************************************************************************
+ * 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 '@vscode/codicons/dist/codicon.css';
+import {
+    FeatureModule,
+    KeyTool,
+    LocationPostprocessor,
+    MouseTool,
+    MoveCommand,
+    SetDirtyStateAction,
+    SetEditModeAction,
+    TYPES,
+    bindAsService,
+    bindOrRebind,
+    configureActionHandler,
+    configureCommand,
+    sprottyDefaultModule
+} from '~glsp-sprotty';
+import '../../css/glsp-sprotty.css';
+import { GLSPActionDispatcher } from './action-dispatcher';
+import { GLSPCommandStack } from './command-stack';
+import { EditorContextService } from './editor-context-service';
+import { ModifyCssFeedbackCommand } from './feedback/css-feedback';
+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 { 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 { GLSPKeyTool } from './view/key-tool';
+import { GLSPMouseTool } from './view/mouse-tool';
+import { GLSPViewRegistry } from './view/view-registry';
+
+/**
+ * The default module provides all of GLSP's base functionality and services.
+ * It builds on top of sprotty's default module {@link `sprottyDefaultModule`}.
+ */
+export const defaultModule = new FeatureModule((bind, unbind, isBound, rebind, ...rest) => {
+    // load bindings from sprotty's default module to avoid code duplication
+    sprottyDefaultModule.registry(bind, unbind, isBound, rebind, ...rest);
+    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();
+                }
+            })
+    );
+
+    configureActionHandler(context, SetEditModeAction.KIND, EditorContextService);
+    configureActionHandler(context, SetDirtyStateAction.KIND, EditorContextService);
+
+    bind(FocusTracker).toSelf().inSingletonScope();
+    configureActionHandler(context, FocusStateChangedAction.KIND, FocusTracker);
+
+    // Model update initialization ------------------------------------
+    bind(TYPES.IFeedbackActionDispatcher).to(FeedbackActionDispatcher).inSingletonScope();
+    configureCommand(context, FeedbackAwareUpdateModelCommand);
+
+    bind(GLSPMouseTool).toSelf().inSingletonScope();
+    bindOrRebind(context, MouseTool).toService(GLSPMouseTool);
+    bind(GLSPKeyTool).toSelf().inSingletonScope();
+    bindOrRebind(context, KeyTool).toService(GLSPKeyTool);
+
+    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);
+
+    bindAsService(context, TYPES.ModelSource, GLSPModelSource);
+    bind(DiagramLoader).toSelf().inSingletonScope();
+    bind(ModelInitializationConstraint).to(DefaultModelInitializationConstraint).inSingletonScope();
+
+    // support re-registration of model elements and views
+    bindOrRebind(context, TYPES.SModelRegistry).to(GLSPModelRegistry).inSingletonScope();
+    bindOrRebind(context, TYPES.ViewRegistry).to(GLSPViewRegistry).inSingletonScope();
+
+    bind(SelectionService).toSelf().inSingletonScope();
+    bind(TYPES.ISModelRootListener).toService(SelectionService);
+
+    // Feedback Support ------------------------------------
+    // Generic re-usable feedback modifying css classes
+    configureCommand(context, ModifyCssFeedbackCommand);
+    // We support using sprotty's MoveCommand as client-side visual feedback
+    configureCommand(context, MoveCommand);
+
+    bindAsService(context, TYPES.IVNodePostprocessor, LocationPostprocessor);
+    bind(TYPES.HiddenVNodePostprocessor).toService(LocationPostprocessor);
+});

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

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

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

@@ -13,17 +13,36 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, Args, distinctAdd, EditMode, EditorContext, remove, SetEditModeAction } from '@eclipse-glsp/protocol';
-import { inject, injectable, multiInject, optional } from 'inversify';
-import { IActionHandler, ModelSource, MousePositionTracker, SModelElement, SModelRoot } from 'sprotty';
-import { SelectionService } from '../features/select/selection-service';
-import { isSourceUriAware } from './source-uri-aware';
-import { TYPES } from './types';
-
-export interface EditModeListener {
+import { inject, injectable, multiInject, optional, postConstruct, preDestroy } from 'inversify';
+import {
+    Action,
+    Args,
+    Disposable,
+    DisposableCollection,
+    EditMode,
+    EditorContext,
+    Emitter,
+    Event,
+    GLSPClient,
+    IActionHandler,
+    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';
+
+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,
@@ -37,28 +56,49 @@ export interface EditModeListener {
  *    position, etc.).
  */
 @injectable()
-export class EditorContextService implements IActionHandler {
-    @inject(TYPES.SelectionService)
+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: EditModeListener[] = [];
+    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();
 
-    register(editModeListener: EditModeListener): void {
-        distinctAdd(this.editModeListeners, editModeListener);
+    @postConstruct()
+    protected initialize(): void {
+        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))
+        );
     }
 
-    deregister(editModeListener: EditModeListener): void {
-        remove(this.editModeListeners, editModeListener);
+    @preDestroy()
+    dispose(): void {
+        this.toDispose.dispose();
     }
 
     get(args?: Args): EditorContext {
@@ -79,28 +119,45 @@ export class EditorContextService implements IActionHandler {
 
     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 {
-        this.editModeListeners.forEach(listener => listener.editModeChanged(oldValue, this.editMode));
+    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 glspClient(): GLSPClient {
+        return this.diagramOptions.glspClient;
+    }
+
     get modelRoot(): Readonly<SModelRoot> {
         return this.selectionService.getModelRoot();
     }
@@ -112,6 +169,14 @@ export class EditorContextService implements IActionHandler {
     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>;