@eclipse-glsp/client 0.9.0-next.c5944e10

package/src/base/actions/edit-validation-actions.ts

@@ -0,0 +1,103 @@
+/********************************************************************************
+ * Copyright (c) 2020 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+import { Action, generateRequestId, RequestAction, ResponseAction } from 'sprotty';
+
+import { Args } from '../args';
+
+export class RequestEditValidationAction implements RequestAction<SetEditValidationResultAction> {
+    static readonly KIND = 'requestEditValidation';
+    constructor(
+        public readonly contextId: string,
+        public readonly modelElementId: string,
+        public readonly text: string,
+        public readonly requestId: string = generateRequestId(),
+        public readonly kind: string = RequestEditValidationAction.KIND) { }
+}
+
+export class SetEditValidationResultAction implements ResponseAction {
+    static readonly KIND = 'setEditValidationResult';
+    constructor(
+        public readonly status: ValidationStatus,
+        public readonly responseId: string = '',
+        public readonly args?: Args,
+        public readonly kind: string = SetEditValidationResultAction.KIND) { }
+}
+
+export function isSetEditValidationResultAction(action: Action): action is SetEditValidationResultAction {
+    return action !== undefined && (action.kind === SetEditValidationResultAction.KIND)
+        && (action as SetEditValidationResultAction).status !== undefined;
+}
+
+export interface ValidationStatus {
+    /**
+     * The severity of the validation returned by the server.
+     */
+    readonly severity: ValidationStatus.Severity;
+
+    /**
+     * The validation status message which may be rendered in the view.
+     */
+    readonly message?: string;
+
+    /**
+     * A potential error that encodes more details.
+     */
+    readonly error?: ResponseError;
+}
+
+export interface ResponseError {
+    /**
+     * Code identifying the error kind.
+     */
+    readonly code: number;
+
+    /**
+     * Error message.
+     */
+    readonly message: string;
+
+    /**
+     * Additional custom data, e.g., a serialized stacktrace.
+     */
+    readonly data: Record<string, any>;
+}
+
+export namespace ValidationStatus {
+
+    export enum Severity {
+        // eslint-disable-next-line no-shadow
+        FATAL, ERROR, WARNING, INFO, OK, NONE
+    }
+
+    export const NONE: ValidationStatus = {
+        severity: Severity.NONE, message: '', error: { code: -1, message: '', data: {} }
+    };
+
+    export function isOk(validationStatus: ValidationStatus): boolean {
+        return validationStatus.severity === Severity.OK
+            || validationStatus.severity === Severity.INFO
+            || validationStatus.severity === Severity.NONE;
+    }
+
+    export function isWarning(validationStatus: ValidationStatus): boolean {
+        return validationStatus.severity === Severity.WARNING;
+    }
+
+    export function isError(validationStatus: ValidationStatus): boolean {
+        return validationStatus.severity === Severity.ERROR
+            || validationStatus.severity === Severity.FATAL;
+    }
+}

package/src/base/actions/focus-change-action.ts

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * 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 { Action } from 'sprotty';
+
+export class FocusStateChangedAction implements Action {
+    static KIND = 'focusStateChanged';
+    readonly kind = FocusStateChangedAction.KIND;
+    constructor(public readonly hasFocus: boolean) { }
+}
+
+export function isFocusStateChangedAction(action: Action): action is FocusStateChangedAction {
+    return action.kind === FocusStateChangedAction.KIND;
+}

package/src/base/args.ts

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { SModelElement } from 'sprotty';
+
+export interface Args { [key: string]: string | number | boolean }
+
+export interface SArgumentable {
+    args: Args;
+}
+
+export function hasArguments(element?: SModelElement): element is SModelElement & SArgumentable {
+    return element !== undefined && 'args' in element;
+}

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

@@ -0,0 +1,24 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { LabeledAction } from 'sprotty/lib';
+
+export interface SetAutoCompleteValueAction extends LabeledAction {
+    readonly text: string;
+}
+
+export function isSetAutoCompleteValueAction(action: LabeledAction): action is SetAutoCompleteValueAction {
+    return action !== undefined && (action as SetAutoCompleteValueAction).text !== undefined;
+}

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

@@ -0,0 +1,314 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { AutocompleteResult, AutocompleteSettings } from 'autocompleter';
+import { Action, ILogger, isAction, isLabeledAction, LabeledAction, SModelRoot } from 'sprotty/lib';
+import { toArray } from 'sprotty/lib/utils/iterable';
+import { matchesKeystroke } from 'sprotty/lib/utils/keyboard';
+
+import { ValidationStatus } from '../actions/edit-validation-actions';
+import { isSetAutoCompleteValueAction } from './auto-complete-actions';
+import { IValidationDecorator } from './validation-decorator';
+
+export interface AutoCompleteSettings {
+    readonly noSuggestionsMessage?: string;
+    readonly suggestionsClass?: string;
+    readonly debounceWaitMs?: number;
+    readonly showOnFocus?: boolean;
+}
+
+export interface InputValidator {
+    validate(input: string): Promise<ValidationStatus>;
+}
+
+export interface SuggestionProvider {
+    provideSuggestions(input: string): Promise<LabeledAction[]>;
+}
+
+export interface InputValueInitializer {
+    initializeValue(containerElement: HTMLElement, root: Readonly<SModelRoot>, ...contextElementIds: string[]): string;
+}
+
+export interface SuggestionSubmitHandler {
+    executeFromSuggestion(input: LabeledAction | Action | Action[]): void;
+}
+
+export interface TextSubmitHandler {
+    executeFromTextOnlyInput(input: string): void;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const configureAutocomplete: (settings: AutocompleteSettings<LabeledAction>) => AutocompleteResult = require('autocompleter');
+
+export class AutoCompleteWidget {
+    loadingIndicatorClasses = ['loading', 'fa', 'fa-spinner', 'fa-pulse', 'fa-3x', 'fa-fw'];
+
+    protected containerElement: HTMLElement;
+    protected inputElement: HTMLInputElement;
+    protected loadingIndicator: HTMLSpanElement;
+    protected autoCompleteResult: AutocompleteResult;
+    protected contextActions?: LabeledAction[];
+    protected previousContent?: string;
+
+    protected inputValidator?: InputValidator;
+    protected validationDecorator: IValidationDecorator = IValidationDecorator.NO_DECORATION;
+
+    protected textSubmitHandler?: TextSubmitHandler;
+
+    constructor(
+        public autoSuggestionSettings: AutoCompleteSettings,
+        public suggestionProvider: SuggestionProvider,
+        public suggestionSubmitHandler: SuggestionSubmitHandler,
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        protected notifyClose: () => void = () => { },
+        protected logger?: ILogger
+    ) { }
+
+    configureValidation(inputValidator: InputValidator,
+        validationDecorator: IValidationDecorator = IValidationDecorator.NO_DECORATION): void {
+        this.inputValidator = inputValidator;
+        this.validationDecorator = validationDecorator;
+    }
+
+    configureTextSubmitHandler(textSubmitHandler: TextSubmitHandler): void {
+        this.textSubmitHandler = textSubmitHandler;
+    }
+
+    initialize(containerElement: HTMLElement): void {
+        this.containerElement = containerElement;
+        this.inputElement = this.createInputElement();
+        this.containerElement.appendChild(this.inputElement);
+        this.containerElement.style.position = 'absolute';
+    }
+
+    protected createInputElement(): HTMLInputElement {
+        const inputElement = document.createElement('input');
+        inputElement.style.position = 'absolute';
+        inputElement.spellcheck = false;
+        inputElement.autocapitalize = 'false';
+        inputElement.autocomplete = 'false';
+        inputElement.style.width = '100%';
+        inputElement.addEventListener('keydown', event => this.handleKeyDown(event));
+        inputElement.addEventListener('blur', () => window.setTimeout(() => this.notifyClose(), 200));
+        return inputElement;
+    }
+
+    protected handleKeyDown(event: KeyboardEvent): void {
+        if (matchesKeystroke(event, 'Escape')) {
+            this.notifyClose();
+            return;
+        }
+        if (matchesKeystroke(event, 'Enter') && !this.isInputElementChanged() && this.isSuggestionAvailable()) {
+            return;
+        }
+        if (this.isInputElementChanged()) {
+            this.invalidateValidationResultAndContextActions();
+        }
+        if (!matchesKeystroke(event, 'Enter') || this.isSuggestionAvailable()) {
+            return;
+        }
+        if (!this.validationDecorator.isValidatedOk()) {
+            event.stopImmediatePropagation();
+            return;
+        }
+        if (this.textSubmitHandler) {
+            this.executeFromTextOnlyInput();
+            this.notifyClose();
+        }
+    }
+
+    protected isInputElementChanged(): boolean {
+        return this.inputElement.value !== this.previousContent;
+    }
+
+    protected invalidateValidationResultAndContextActions(): void {
+        this.contextActions = undefined;
+        this.validationDecorator.invalidate();
+    }
+
+    open(root: Readonly<SModelRoot>, ...contextElementIds: string[]): void {
+        this.contextActions = undefined;
+        this.autoCompleteResult = configureAutocomplete(this.autocompleteSettings(root));
+        this.previousContent = this.inputElement.value;
+        this.inputElement.setSelectionRange(0, this.inputElement.value.length);
+        this.inputElement.focus();
+    }
+
+    protected autocompleteSettings(root: Readonly<SModelRoot>): AutocompleteSettings<LabeledAction> {
+        return {
+            input: this.inputElement,
+            emptyMsg: this.autoSuggestionSettings.noSuggestionsMessage,
+            className: this.autoSuggestionSettings.suggestionsClass,
+            showOnFocus: this.autoSuggestionSettings.showOnFocus,
+            debounceWaitMs: this.autoSuggestionSettings.debounceWaitMs,
+            minLength: -1,
+            fetch: (text: string, update: (items: LabeledAction[]) => void) =>
+                this.updateSuggestions(update, text, root),
+            onSelect: (item: LabeledAction) => this.onSelect(item),
+            render: (item: LabeledAction, currentValue: string): HTMLDivElement | undefined =>
+                this.renderSuggestions(item, currentValue),
+            customize: (input: HTMLInputElement, inputRect: ClientRect | DOMRect, container: HTMLDivElement, maxHeight: number) => {
+                this.customizeInputElement(input, inputRect, container, maxHeight);
+            }
+        };
+    }
+
+    protected customizeInputElement(input: HTMLInputElement, inputRect: ClientRect | DOMRect, container: HTMLDivElement, maxHeight: number): void {
+        // move container into our UIExtension container as this is already positioned correctly
+        if (this.containerElement) {
+            this.containerElement.appendChild(container);
+        }
+    }
+
+    protected updateSuggestions(update: (items: LabeledAction[]) => void, text: string, root: Readonly<SModelRoot>, ...contextElementIds: string[]): void {
+        this.onLoading();
+        this.doUpdateSuggestions(text, root)
+            .then(actions => {
+                this.contextActions = this.filterActions(text, actions);
+                update(this.contextActions);
+                this.onLoaded('success');
+            })
+            .catch(reason => {
+                if (this.logger) {
+                    this.logger.error(this, 'Failed to obtain suggestions', reason);
+                }
+                this.onLoaded('error');
+            });
+    }
+
+    protected onLoading(): void {
+        if (this.loadingIndicator && this.containerElement.contains(this.loadingIndicator)) {
+            return;
+        }
+        this.loadingIndicator = document.createElement('span');
+        this.loadingIndicator.classList.add(...this.loadingIndicatorClasses);
+        this.containerElement.appendChild(this.loadingIndicator);
+    }
+
+    protected doUpdateSuggestions(text: string, root: Readonly<SModelRoot>, ...contextElementIds: string[]): Promise<LabeledAction[]> {
+        return this.suggestionProvider.provideSuggestions(text);
+    }
+
+    protected onLoaded(_success: 'success' | 'error'): void {
+        if (this.containerElement.contains(this.loadingIndicator)) {
+            this.containerElement.removeChild(this.loadingIndicator);
+        }
+        this.validationDecorator.invalidate();
+        this.validateInputIfNoContextActions();
+        this.previousContent = this.inputElement.value;
+    }
+
+    protected renderSuggestions(item: LabeledAction, value: string): HTMLDivElement {
+        const itemElement = document.createElement('div');
+        const wordMatcher = this.espaceForRegExp(value).split(' ').join('|');
+        const regex = new RegExp(wordMatcher, 'gi');
+        if (item.icon) {
+            this.renderIcon(itemElement, item.icon);
+        }
+        itemElement.innerHTML += item.label.replace(regex, match => '<em>' + match + '</em>');
+        return itemElement;
+    }
+
+    protected espaceForRegExp(value: string): string {
+        return value.replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1');
+    }
+
+    protected renderIcon(itemElement: HTMLDivElement, icon: string): void {
+        itemElement.innerHTML += `<span class="icon ${icon}"></span>`;
+    }
+
+    protected filterActions(filterText: string, actions: LabeledAction[]): LabeledAction[] {
+        return toArray(actions.filter(action => {
+            const label = action.label.toLowerCase();
+            const searchWords = filterText.split(' ');
+            return searchWords.every(word => label.indexOf(word.toLowerCase()) !== -1);
+        }));
+    }
+
+    protected onSelect(item: LabeledAction): void {
+        if (isSetAutoCompleteValueAction(item)) {
+            this.inputElement.value = item.text;
+            // trigger update of suggestions with an keyup event
+            window.setTimeout(() => this.inputElement.dispatchEvent(new Event('keyup')));
+        } else {
+            this.executeFromSuggestion(item);
+            this.notifyClose();
+        }
+    }
+
+    protected validateInputIfNoContextActions(): void {
+        if (this.isNoOrExactlyOneMatchingContextAction()) {
+            this.validateInput();
+        } else {
+            this.validationDecorator.dispose();
+        }
+    }
+
+    private isNoOrExactlyOneMatchingContextAction(): boolean | undefined {
+        return !this.isSuggestionAvailable()
+            || (this.contextActions
+                && this.contextActions.length === 1
+                && this.inputElement.value.endsWith(this.contextActions[0].label));
+    }
+
+    protected isSuggestionAvailable(): boolean | undefined {
+        return this.contextActions && this.contextActions.length > 0;
+    }
+
+    validateInput(): void {
+        if (this.inputValidator) {
+            this.inputValidator.validate(this.inputElement.value)
+                .then(result => this.validationDecorator.decorateValidationResult(result))
+                .catch(error => this.handleErrorDuringValidation(error));
+        }
+    }
+
+    protected handleErrorDuringValidation(error: Error): void {
+        if (this.logger) {
+            this.logger.error(this, 'Failed to validate input', error);
+        }
+        this.validationDecorator.dispose();
+    }
+
+    protected executeFromSuggestion(input: LabeledAction | Action[] | Action): void {
+        this.suggestionSubmitHandler.executeFromSuggestion(input);
+    }
+
+    protected executeFromTextOnlyInput(): void {
+        if (this.textSubmitHandler) {
+            this.textSubmitHandler.executeFromTextOnlyInput(this.inputElement.value);
+        }
+    }
+
+    get inputField(): HTMLInputElement {
+        return this.inputElement;
+    }
+
+    dispose(): void {
+        this.validationDecorator.dispose();
+        if (this.autoCompleteResult) {
+            this.autoCompleteResult.destroy();
+        }
+    }
+}
+
+export function toActionArray(input: LabeledAction | Action[] | Action): Action[] {
+    if (isLabeledAction(input)) {
+        return input.actions;
+    } else if (isAction(input)) {
+        return [input];
+    }
+    return [];
+}

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

@@ -0,0 +1,126 @@
+/********************************************************************************
+ * Copyright (c) 2020 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 { ValidationStatus } from '../actions/edit-validation-actions';
+
+export interface IValidationDecorator {
+    decorateValidationResult(status: ValidationStatus): void;
+    isValidatedOk(): boolean;
+    invalidate(): void;
+    dispose(): void;
+}
+
+export namespace IValidationDecorator {
+    export const NO_DECORATION: IValidationDecorator = {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        decorateValidationResult(_status: ValidationStatus) { },
+        isValidatedOk(): boolean {
+            return false;
+        },
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        invalidate() { },
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        dispose() { }
+    };
+}
+
+export class ValidationDecorator implements IValidationDecorator {
+    warningClasses = ['warning'];
+    warningIconClasses = ['fa', 'fa-question-circle'];
+    errorClasses = ['error'];
+    errorIconClasses = ['fa', 'fa-exclamation-circle'];
+
+    isValidated = false;
+    hasValidationError = false;
+
+    protected decorationDiv?: HTMLDivElement;
+
+    constructor(protected containerElement: HTMLElement) { }
+
+    decorateValidationResult(status: ValidationStatus): void {
+        if (ValidationStatus.isError(status)) {
+            this.hasValidationError = true;
+            this.decorateError(status.message ? status.message : 'Error');
+        } else if (ValidationStatus.isWarning(status)) {
+            this.hasValidationError = false;
+            this.decorateWarning(status.message ? status.message : 'Warning');
+        } else {
+            this.hasValidationError = false;
+            this.dispose();
+        }
+        this.isValidated = true;
+    }
+
+    protected decorateError(message: string): void {
+        this.switchCssClasses(this.containerElement, this.errorClasses);
+        const div = this.createDecorationDiv();
+        this.switchCssClasses(div, this.errorClasses);
+        div.innerHTML = `<span class="${this.errorIconClasses.join(' ')}"></span> ${message}`;
+        this.adjustPosition();
+    }
+
+    protected decorateWarning(message: string): void {
+        this.switchCssClasses(this.containerElement, this.warningClasses);
+        const div = this.createDecorationDiv();
+        this.switchCssClasses(div, this.warningClasses);
+        div.innerHTML = `<span class="${this.warningIconClasses.join(' ')}"></span> ${message}`;
+        this.adjustPosition();
+    }
+
+    protected switchCssClasses(element: HTMLElement, cssClasses: string[]): void {
+        element.classList.remove(...this.errorClasses, ...this.warningClasses);
+        element.classList.add(...cssClasses);
+    }
+
+    protected createDecorationDiv(): HTMLDivElement {
+        if (!this.decorationDiv) {
+            this.containerElement.classList.add('validation');
+            this.decorationDiv = document.createElement('div');
+            this.decorationDiv.style.width = `${this.decorationContainerWidth()}px`;
+            this.decorationDiv.classList.add('validation-decorator');
+            this.containerElement.appendChild(this.decorationDiv);
+        }
+        return this.decorationDiv;
+    }
+
+    protected decorationContainerWidth(): number {
+        return this.containerElement.clientWidth - 22;
+    }
+
+    protected adjustPosition(): void {
+        if (this.decorationDiv) {
+            const height = this.decorationDiv.clientHeight + 2;
+            this.decorationDiv.style.top = `-${height}px`;
+        }
+    }
+
+    isValidatedOk(): boolean {
+        return this.isValidated && !this.hasValidationError;
+    }
+
+    invalidate(): void {
+        this.isValidated = false;
+    }
+
+    dispose(): void {
+        this.hasValidationError = false;
+        this.isValidated = false;
+        if (this.decorationDiv && this.containerElement && this.containerElement.contains(this.decorationDiv)) {
+            this.containerElement.removeChild(this.decorationDiv);
+            this.switchCssClasses(this.containerElement, []);
+            this.decorationDiv = undefined;
+        }
+    }
+}

package/src/base/command-stack.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2019 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 } from 'inversify';
+import { CommandStack, IActionDispatcher, SModelRoot, TYPES } from 'sprotty';
+
+import { RedoOperation, UndoOperation } from '../features/undo-redo/model';
+
+@injectable()
+export class GLSPCommandStack extends CommandStack {
+
+    @inject(TYPES.IActionDispatcherProvider) protected actionDispatcher: () => Promise<IActionDispatcher>;
+
+    undo(): Promise<SModelRoot> {
+        this.actionDispatcher().then(dispatcher => dispatcher.dispatch(new UndoOperation()));
+        return this.thenUpdate();
+    }
+
+    redo(): Promise<SModelRoot> {
+        this.actionDispatcher().then(dispatcher => dispatcher.dispatch(new RedoOperation()));
+        return this.thenUpdate();
+    }
+}
+