@eclipse-glsp/server 1.1.0-RC05 → 1.1.0-RC07

package/src/common/command/command-stack.spec.ts

@@ -16,7 +16,7 @@
 import { expect } from 'chai';
 import { Container, ContainerModule } from 'inversify';
 import * as sinon from 'sinon';
-import { StubCommand, StubLogger } from '../test/mock-util';
+import { expectToThrowAsync, StubCommand, StubLogger } from '../test/mock-util';
 import { Logger } from '../utils/logger';
 import { DefaultCommandStack } from './command-stack';
 
@@ -41,17 +41,17 @@ describe('test DefaultCommandStack', () => {
     });
 
     describe('execute', () => {
-        it('should execute the given command and become dirty', () => {
+        it('should execute the given command and become dirty', async () => {
             expect(commandStack.isDirty).to.be.false;
-            commandStack.execute(command1);
+            await commandStack.execute(command1);
             expect(command1.execute.calledOnce).to.be.true;
             expect(commandStack.isDirty).to.be.true;
         });
 
-        it('should execute the given commands in order and become dirty', () => {
+        it('should execute the given commands in order and become dirty', async () => {
             expect(commandStack.isDirty).to.be.false;
-            commandStack.execute(command1);
-            commandStack.execute(command2);
+            await commandStack.execute(command1);
+            await commandStack.execute(command2);
 
             expect(command1.execute.calledOnce).to.be.true;
             expect(command2.execute.calledOnce).to.be.true;
@@ -59,112 +59,112 @@ describe('test DefaultCommandStack', () => {
             expect(commandStack.isDirty).to.be.true;
         });
 
-        it('should be able to undo after execute', () => {
+        it('should be able to undo after execute', async () => {
             expect(commandStack.canUndo()).to.be.false;
-            commandStack.execute(command1);
+            await commandStack.execute(command1);
             expect(commandStack.canUndo()).to.be.true;
         });
 
-        it('should clear the redo stack after execution', () => {
+        it('should clear the redo stack after execution', async () => {
             commandStack['commands'].push(command2);
             commandStack['top'] = -1;
             expect(commandStack.canRedo()).to.be.true;
 
-            commandStack.execute(command1);
+            await commandStack.execute(command1);
             expect(commandStack.canRedo()).to.be.false;
         });
 
-        it('should flush the stack in case of an execution error', () => {
+        it('should flush the stack in case of an execution error', async () => {
             command2.execute.throwsException();
             const flushSpy = sandbox.spy(commandStack, 'flush');
 
-            expect(() => commandStack.execute(command2)).to.throw();
+            await expectToThrowAsync(() => commandStack.execute(command2));
             expect(command2.execute.calledOnce).to.be.true;
             expect(flushSpy.calledOnce).to.be.true;
         });
     });
 
     describe('undo', () => {
-        it('should do nothing if the command stack is empty', () => {
+        it('should do nothing if the command stack is empty', async () => {
             expect(commandStack.isDirty).to.be.false;
 
-            commandStack.undo();
+            await commandStack.undo();
             expect(commandStack.canUndo()).to.be.false;
             expect(commandStack.canRedo()).to.be.false;
             expect(commandStack.isDirty).to.be.false;
         });
 
-        it('should undo the command and become non-dirty again', () => {
+        it('should undo the command and become non-dirty again', async () => {
             commandStack['commands'].push(command1);
             commandStack['top'] = 0;
             expect(commandStack.isDirty).to.be.true;
             expect(commandStack.canUndo()).to.be.true;
             expect(commandStack.canRedo()).to.be.false;
 
-            commandStack.undo();
+            await commandStack.undo();
             expect(command1.undo.calledOnce).to.be.true;
             expect(commandStack.isDirty).to.be.false;
             expect(commandStack.canRedo()).to.be.true;
             expect(commandStack.canUndo()).to.be.false;
         });
 
-        it('should undo multiple command and become non-dirty again', () => {
+        it('should undo multiple command and become non-dirty again', async () => {
             commandStack['commands'].push(command1, command2);
             commandStack['top'] = 1;
             expect(commandStack.isDirty).to.be.true;
             expect(commandStack.canUndo()).to.be.true;
             expect(commandStack.canRedo()).to.be.false;
 
-            commandStack.undo();
+            await commandStack.undo();
             expect(command2.undo.calledOnce).to.be.true;
             expect(commandStack.canRedo()).to.be.true;
             expect(commandStack.canUndo()).to.be.true;
             expect(commandStack.isDirty).to.be.true;
 
-            commandStack.undo();
+            await commandStack.undo();
             expect(command1.undo.calledOnce).to.be.true;
             expect(command1.undo.calledAfter(command2.undo)).to.be.true;
             expect(commandStack.isDirty).to.be.false;
             expect(commandStack.canRedo()).to.be.true;
             expect(commandStack.canUndo()).to.be.false;
         });
-        it('should flush the stack in case of an execution error', () => {
+        it('should flush the stack in case of an execution error', async () => {
             command2.undo.throwsException();
             const flushSpy = sandbox.spy(commandStack, 'flush');
             commandStack['commands'].push(command2);
             commandStack['top'] = 0;
 
-            expect(() => commandStack.undo()).to.throw();
+            await expectToThrowAsync(() => commandStack.undo());
             expect(command2.undo.calledOnce).to.be.true;
             expect(flushSpy.calledOnce).to.be.true;
         });
     });
 
     describe('redo', () => {
-        it('should do nothing if the command stack is empty', () => {
+        it('should do nothing if the command stack is empty', async () => {
             expect(commandStack.isDirty).to.be.false;
 
-            commandStack.redo();
+            await commandStack.redo();
             expect(commandStack.canUndo()).to.be.false;
             expect(commandStack.canRedo()).to.be.false;
             expect(commandStack.isDirty).to.be.false;
         });
 
-        it('should redo the command and become dirty again', () => {
+        it('should redo the command and become dirty again', async () => {
             commandStack['commands'].push(command1);
             commandStack['top'] = -1;
             expect(commandStack.isDirty).to.be.false;
             expect(commandStack.canUndo()).to.be.false;
             expect(commandStack.canRedo()).to.be.true;
 
-            commandStack.redo();
+            await commandStack.redo();
             expect(command1.redo.calledOnce).to.be.true;
             expect(commandStack.isDirty).to.be.true;
             expect(commandStack.canRedo()).to.be.false;
             expect(commandStack.canUndo()).to.be.true;
         });
 
-        it('should undo multiple command and become non-dirty again', () => {
+        it('should undo multiple command and become non-dirty again', async () => {
             commandStack['commands'].push(command2, command1);
             commandStack['top'] = -1;
             commandStack['saveIndex'] = -1;
@@ -172,34 +172,34 @@ describe('test DefaultCommandStack', () => {
             expect(commandStack.canUndo()).to.be.false;
             expect(commandStack.canRedo()).to.be.true;
 
-            commandStack.redo();
+            await commandStack.redo();
             expect(command2.redo.calledOnce).to.be.true;
             expect(commandStack.canRedo()).to.be.true;
             expect(commandStack.canUndo()).to.be.true;
             expect(commandStack.isDirty).to.be.true;
 
-            commandStack.redo();
+            await commandStack.redo();
             expect(command1.redo.calledOnce).to.be.true;
             expect(command1.redo.calledAfter(command2.redo)).to.be.true;
             expect(commandStack.isDirty).to.be.true;
             expect(commandStack.canRedo()).to.be.false;
             expect(commandStack.canUndo()).to.be.true;
         });
-        it('should flush the stack in case of an execution error', () => {
+        it('should flush the stack in case of an execution error', async () => {
             command2.redo.throwsException();
             const flushSpy = sandbox.spy(commandStack, 'flush');
             commandStack['commands'].push(command2);
             commandStack['top'] = -1;
 
-            expect(() => commandStack.redo()).to.throw();
+            await expectToThrowAsync(() => commandStack.redo());
             expect(command2.redo.calledOnce).to.be.true;
             expect(flushSpy.calledOnce).to.be.true;
         });
-        it('should be able to undo after redo', () => {
+        it('should be able to undo after redo', async () => {
             commandStack['commands'].push(command1);
             commandStack['top'] = -1;
             expect(commandStack.canUndo()).to.be.false;
-            commandStack.redo();
+            await commandStack.redo();
             expect(commandStack.canUndo()).to.be.true;
         });
     });

package/src/common/command/command-stack.ts

@@ -14,6 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { inject, injectable } from 'inversify';
+import { MaybePromise } from '..';
 import { Logger } from '../utils/logger';
 import { Command } from './command';
 
@@ -31,12 +32,12 @@ export interface CommandStack {
      * Clears any redoable commands not yet redone, adds the command to the stack and then invokes {@link Command.execute}.
      * @param command the command to execute.
      */
-    execute(command: Command): void;
+    execute(command: Command): MaybePromise<void>;
 
     /**
      * Removes the topmost (i.e. last executed) command from the stack and invokes {@link Command.undo}.
      */
-    undo(): void;
+    undo(): MaybePromise<void>;
 
     /**
      * Returns `true` if the top command on the stack can be undone.
@@ -46,7 +47,7 @@ export interface CommandStack {
     /**
      * Re-adds the last undo command on top of the stack and invokes {@link Command.redo}
      */
-    redo(): void;
+    redo(): MaybePromise<void>;
 
     /**
      * Returns `true` if there are  redoable commands in the stack.
@@ -86,9 +87,9 @@ export class DefaultCommandStack implements CommandStack {
      */
     protected saveIndex = -1;
 
-    execute(command: Command): void {
+    async execute(command: Command): Promise<void> {
         try {
-            command.execute();
+            await command.execute();
         } catch (error) {
             this.handleError(error);
         }
@@ -104,11 +105,11 @@ export class DefaultCommandStack implements CommandStack {
         }
     }
 
-    undo(): void {
+    async undo(): Promise<void> {
         if (this.canUndo()) {
             const command = this.commands[this.top--];
             try {
-                command.undo();
+                await command.undo();
             } catch (error) {
                 this.handleError(error);
             }
@@ -121,11 +122,11 @@ export class DefaultCommandStack implements CommandStack {
             : false;
     }
 
-    redo(): void {
+    async redo(): Promise<void> {
         if (this.canRedo()) {
             const command = this.commands[++this.top];
             try {
-                command.redo();
+                await command.redo();
             } catch (error) {
                 this.handleError(error);
             }

package/src/common/command/command.spec.ts

@@ -15,7 +15,7 @@
  ********************************************************************************/
 import { expect } from 'chai';
 import * as sinon from 'sinon';
-import { StubCommand } from '../test/mock-util';
+import { expectToThrowAsync, StubCommand } from '../test/mock-util';
 import { CompoundCommand } from './command';
 
 describe('CompoundCommand', () => {
@@ -32,18 +32,18 @@ describe('CompoundCommand', () => {
     });
 
     describe('execute', () => {
-        it('Should execute the subcommands in order', () => {
-            compoundCommand.execute();
+        it('Should execute the subcommands in order', async () => {
+            await compoundCommand.execute();
             expect(command1.execute.calledOnce).to.be.true;
             expect(command2.execute.calledOnce).to.be.true;
             expect(command3.execute.calledOnce).to.be.true;
             expect(command1.execute.calledBefore(command2.execute)).to.be.true;
             expect(command2.execute.calledBefore(command3.execute)).to.be.true;
         });
-        it('Should undo partially executed subcommands in  case of an error', () => {
+        it('Should undo partially executed subcommands in  case of an error', async () => {
             command3.execute.throwsException();
 
-            expect(() => compoundCommand.execute()).to.throw();
+            await expectToThrowAsync(() => compoundCommand.execute());
 
             expect(command1.execute.calledOnce).to.be.true;
             expect(command2.execute.calledOnce).to.be.true;
@@ -54,8 +54,8 @@ describe('CompoundCommand', () => {
     });
 
     describe('undo', () => {
-        it('Should undo the subcommands in reverse order', () => {
-            compoundCommand.undo();
+        it('Should undo the subcommands in reverse order', async () => {
+            await compoundCommand.undo();
             expect(command1.undo.calledOnce).to.be.true;
             expect(command2.undo.calledOnce).to.be.true;
             expect(command3.undo.calledOnce).to.be.true;
@@ -63,10 +63,9 @@ describe('CompoundCommand', () => {
             expect(command2.undo.calledAfter(command3.undo)).to.be.true;
         });
 
-        it('Should redo partially undone subcommands in  case of an error', () => {
+        it('Should redo partially undone subcommands in  case of an error', async () => {
             command1.undo.throwsException();
-
-            expect(() => compoundCommand.undo()).to.throw();
+            await expectToThrowAsync(() => compoundCommand.undo());
 
             expect(command1.undo.calledOnce).to.be.true;
             expect(command2.undo.calledOnce).to.be.true;

package/src/common/command/command.ts

@@ -14,7 +14,7 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { flatPush, MaybeArray } from '@eclipse-glsp/protocol';
+import { flatPush, MaybeArray, MaybePromise } from '@eclipse-glsp/protocol';
 
 /**
  * A command implements a specific modification of the source model, which can be applied by invoking `execute()`.
@@ -30,19 +30,19 @@ export interface Command {
     /**
      * Performs the command activity required for the effect (e.g. source model change).
      */
-    execute(): void;
+    execute(): MaybePromise<void>;
 
     /**
      * Performs the command activity required to `undo` the effects of a preceding `execute` (or `redo`).
      * The effect, if any, of calling `undo` before `execute` or `redo` have been called, is undefined.
      */
-    undo(): void;
+    undo(): MaybePromise<void>;
 
     /**
      * Performs the command activity required to `redo` the effect after undoing the effect.
      * The effect, if any, of calling `redo` before `undo` is called is undefined.
      */
-    redo(): void;
+    redo(): MaybePromise<void>;
 
     /**
      * Returns whether the command can be undone.
@@ -71,18 +71,18 @@ export class CompoundCommand implements Command {
         flatPush(this.commands, commands);
     }
 
-    execute(): void {
+    async execute(): Promise<void> {
         const alreadyExecuted: Command[] = [];
 
         try {
-            this.commands.forEach(command => {
-                command.execute();
+            for (const command of this.commands) {
+                await command.execute();
                 alreadyExecuted.unshift(command);
-            });
+            }
         } catch (err) {
             for (const command of alreadyExecuted) {
                 if (Command.canUndo(command)) {
-                    command.undo();
+                    await command.undo();
                 } else {
                     break;
                 }
@@ -91,29 +91,33 @@ export class CompoundCommand implements Command {
         }
     }
 
-    undo(): void {
+    async undo(): Promise<void> {
         const alreadyUndone: Command[] = [];
         try {
-            [...this.commands].reverse().forEach(command => {
-                command.undo();
+            for (const command of [...this.commands].reverse()) {
+                await command.undo();
                 alreadyUndone.unshift(command);
-            });
+            }
         } catch (err) {
-            alreadyUndone.forEach(command => command.redo());
+            for (const command of alreadyUndone) {
+                await command.redo();
+            }
             throw err;
         }
     }
 
-    redo(): void {
+    async redo(): Promise<void> {
         const alreadyRedone: Command[] = [];
 
         try {
-            this.commands.forEach(command => {
-                command.redo();
+            for (const command of this.commands) {
+                await command.redo();
                 alreadyRedone.unshift(command);
-            });
+            }
         } catch (err) {
-            alreadyRedone.forEach(command => command.undo());
+            for (const command of alreadyRedone) {
+                await command.undo();
+            }
             throw err;
         }
     }

package/src/common/command/recording-command.spec.ts

@@ -39,36 +39,36 @@ describe('RecordingCommand', () => {
         beforeState = JSON.parse(JSON.stringify(jsonObject));
     });
 
-    it('should be undoable after execution', () => {
+    it('should be undoable after execution', async () => {
         // eslint-disable-next-line @typescript-eslint/no-empty-function
         const command = new RecordingCommand(jsonObject, () => {});
         expect(command.canUndo()).to.be.false;
-        command.execute();
+        await command.execute();
         expect(command.canUndo()).to.be.true;
     });
 
-    it('should restore the pre execution state when undo is called', () => {
+    it('should restore the pre execution state when undo is called', async () => {
         const command = new RecordingCommand(jsonObject, () => {
             jsonObject.string = 'bar';
             jsonObject.flag = false;
             jsonObject.maybe = { hello: 'world' };
         });
-        command.execute();
+        await command.execute();
         expect(jsonObject).to.not.be.deep.equals(beforeState);
-        command.undo();
+        await command.undo();
         expect(jsonObject).to.be.deep.equals(beforeState);
     });
 
-    it('should restore the post execution state when redo is called', () => {
+    it('should restore the post execution state when redo is called', async () => {
         const command = new RecordingCommand(jsonObject, () => {
             jsonObject.string = 'bar';
             jsonObject.flag = false;
             jsonObject.maybe = { hello: 'world' };
         });
-        command.execute();
+        await command.execute();
         const afterState = JSON.parse(JSON.stringify(jsonObject));
         jsonObject = JSON.parse(JSON.stringify(afterState));
-        command.redo();
+        await command.redo();
         expect(jsonObject).to.be.deep.equals(afterState);
     });
 });

package/src/common/command/recording-command.ts

@@ -15,7 +15,7 @@
  ********************************************************************************/
 
 import { GModelRootSchema } from '@eclipse-glsp/graph';
-import { AnyObject } from '@eclipse-glsp/protocol';
+import { AnyObject, MaybePromise } from '@eclipse-glsp/protocol';
 import * as jsonPatch from 'fast-json-patch';
 import { GModelSerializer } from '../features/model/gmodel-serializer';
 import { ModelState } from '../features/model/model-state';
@@ -28,10 +28,10 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
     protected undoPatch?: jsonPatch.Operation[];
     protected redoPatch?: jsonPatch.Operation[];
 
-    execute(): void {
-        const beforeState = this.deepClone(this.getJsonObject());
-        this.doExecute();
-        const afterState = this.getJsonObject();
+    async execute(): Promise<void> {
+        const beforeState = this.deepClone(await this.getJsonObject());
+        await this.doExecute();
+        const afterState = await this.getJsonObject();
         this.undoPatch = jsonPatch.compare(afterState, beforeState);
         this.redoPatch = jsonPatch.compare(beforeState, afterState);
     }
@@ -41,14 +41,14 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
      * right after {@link AbstractRecordingCommand.doExecute} to derive the undo & redo patches.
      * @returns The current state of the JSON object
      */
-    protected abstract getJsonObject(): JsonObject;
+    protected abstract getJsonObject(): MaybePromise<JsonObject>;
 
     /**
      * The actual execution i.e. series of changes applied to the JSOn object that should be captured.
      */
-    protected abstract doExecute(): void;
+    protected abstract doExecute(): MaybePromise<void>;
 
-    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): void {
+    protected applyPatch(object: JsonObject, patch: jsonPatch.Operation[]): MaybePromise<void> {
         jsonPatch.applyPatch(object, patch, false, true);
     }
 
@@ -62,15 +62,15 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
         return jsonPatch.deepClone(object);
     }
 
-    undo(): void {
+    async undo(): Promise<void> {
         if (this.undoPatch) {
-            this.applyPatch(this.getJsonObject(), this.undoPatch);
+            return this.applyPatch(await this.getJsonObject(), this.undoPatch);
         }
     }
 
-    redo(): void {
+    async redo(): Promise<void> {
         if (this.redoPatch) {
-            this.applyPatch(this.getJsonObject(), this.redoPatch);
+            return this.applyPatch(await this.getJsonObject(), this.redoPatch);
         }
     }
 
@@ -84,11 +84,11 @@ export abstract class AbstractRecordingCommand<JsonObject extends AnyObject> imp
  * the the given `doExecute` function.
  */
 export class RecordingCommand<JsonObject extends AnyObject = AnyObject> extends AbstractRecordingCommand<JsonObject> {
-    constructor(protected jsonObject: JsonObject, protected doExecute: () => void) {
+    constructor(protected jsonObject: JsonObject, protected doExecute: () => MaybePromise<void>) {
         super();
     }
 
-    protected getJsonObject(): JsonObject {
+    protected getJsonObject(): MaybePromise<JsonObject> {
         return this.jsonObject;
     }
 }
@@ -98,20 +98,20 @@ export class RecordingCommand<JsonObject extends AnyObject = AnyObject> extends
  * to the `GModelRoot` ({@link ModelState.root}) during the given `doExecute` function
  */
 export class GModelRecordingCommand extends AbstractRecordingCommand<GModelRootSchema> {
-    constructor(protected modelState: ModelState, protected serializer: GModelSerializer, protected doExecute: () => void) {
+    constructor(protected modelState: ModelState, protected serializer: GModelSerializer, protected doExecute: () => MaybePromise<void>) {
         super();
     }
 
-    override execute(): void {
-        super.execute();
+    override async execute(): Promise<void> {
+        await super.execute();
         this.modelState.index.indexRoot(this.modelState.root);
     }
 
-    protected getJsonObject(): GModelRootSchema {
+    protected getJsonObject(): MaybePromise<GModelRootSchema> {
         return this.serializer.createSchema(this.modelState.root);
     }
 
-    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): void {
+    protected override applyPatch(rootSchema: GModelRootSchema, patch: jsonPatch.Operation[]): MaybePromise<void> {
         super.applyPatch(rootSchema, patch);
         const newRoot = this.serializer.createRoot(rootSchema);
         this.modelState.updateRoot(newRoot);

package/src/common/command/undo-redo-action-handler.ts

@@ -39,17 +39,17 @@ export class UndoRedoActionHandler implements ActionHandler {
         return [];
     }
 
-    protected undo(): MaybePromise<Action[]> {
+    protected async undo(): Promise<Action[]> {
         if (this.commandStack.canUndo()) {
-            this.commandStack.undo();
+            await this.commandStack.undo();
             return this.modelSubmissionHandler.submitModel('undo');
         }
         return [];
     }
 
-    protected redo(): MaybePromise<Action[]> {
+    protected async redo(): Promise<Action[]> {
         if (this.commandStack.canRedo()) {
-            this.commandStack.redo();
+            await this.commandStack.redo();
             return this.modelSubmissionHandler.submitModel('redo');
         }
         return [];

package/src/common/features/layout/computed-bounds-action-handler.ts

@@ -17,7 +17,7 @@ import { GModelRoot } from '@eclipse-glsp/graph';
 import { Action, ComputedBoundsAction, MaybePromise } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../../actions/action-handler';
-import { applyAlignment, applyBounds, applyRoute } from '../../utils/layout-util';
+import { applyAlignment, applyElementAndBounds, applyRoute } from '../../utils/layout-util';
 import { ModelState } from '../model/model-state';
 import { ModelSubmissionHandler } from '../model/model-submission-handler';
 
@@ -47,7 +47,7 @@ export class ComputedBoundsActionHandler implements ActionHandler {
 
     protected applyBounds(root: GModelRoot, action: ComputedBoundsAction): void {
         const index = this.modelState.index;
-        action.bounds.forEach(bounds => applyBounds(bounds, index));
+        action.bounds.forEach(bounds => applyElementAndBounds(bounds, index));
         (action.alignments ?? []).forEach(alignment => applyAlignment(alignment, index));
         (action.routes ?? []).forEach(route => applyRoute(route, index));
     }

package/src/common/index.ts

@@ -23,6 +23,8 @@ export * from './actions/client-action-handler';
 export * from './actions/global-action-provider';
 export * from './command/command';
 export * from './command/command-stack';
+export * from './command/recording-command';
+export * from './command/undo-redo-action-handler';
 export * from './di/binding-target';
 export * from './di/client-session-module';
 export * from './di/diagram-module';
@@ -65,7 +67,6 @@ export * from './features/popup/popup-model-factory';
 export * from './features/popup/request-popup-model-action-handler';
 export * from './features/validation/model-validator';
 export * from './features/validation/request-markers-handler';
-export * from './gmodel/cut-operation-handler';
 export * from './gmodel/index';
 export * from './launch/glsp-server-launcher';
 export * from './operations/compound-operation-handler';
@@ -84,6 +85,7 @@ export * from './session/client-session-manager';
 export * from './utils/args-util';
 export * from './utils/client-options-util';
 export * from './utils/glsp-server-error';
+export * from './utils/layout-util';
 export * from './utils/logger';
 export * from './utils/promise-queue';
 export * from './utils/registry';