@eclipse-glsp/server 2.8.0-next.5 → 2.8.0-next.7

package/lib/common/features/directediting/context-edit-validator.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidateLabelEditAdapter = exports.ContextEditValidator = void 0;
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -16,7 +16,7 @@ exports.ValidateLabelEditAdapter = exports.ContextEditValidator = void 0;
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-const gmodel_element_1 = require("@eclipse-glsp/graph/lib/gmodel-element");
+const graph_1 = require("@eclipse-glsp/graph");
 const protocol_1 = require("@eclipse-glsp/protocol");
 const label_edit_validator_1 = require("./label-edit-validator");
 exports.ContextEditValidator = Symbol('ContextEditValidator');
@@ -30,7 +30,7 @@ class ValidateLabelEditAdapter {
     }
     validate(action) {
         const element = this.modelState.index.get(action.modelElementId);
-        if (element instanceof gmodel_element_1.GModelElement) {
+        if (element instanceof graph_1.GModelElement) {
             return this.labelEditValidator.validate(action.text, element);
         }
         return { severity: protocol_1.ValidationStatus.Severity.OK };

package/lib/common/features/directediting/context-edit-validator.js.map

@@ -1 +1 @@
-{"version":3,"file":"context-edit-validator.js","sourceRoot":"","sources":["../../../../src/common/features/directediting/context-edit-validator.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;kFAckF;AAClF,2EAAuE;AACvE,qDAAuF;AAEvF,iEAA4D;AAE/C,QAAA,oBAAoB,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAiBnE,MAAa,wBAAwB;IAEjC,YACa,UAAsB,EAC/B,kBAAsC;QAD7B,eAAU,GAAV,UAAU,CAAY;QAG/B,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;IACjD,CAAC;IAED,IAAI,SAAS;QACT,OAAO,yCAAkB,CAAC,UAAU,CAAC;IACzC,CAAC;IAED,QAAQ,CAAC,MAAmC;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACjE,IAAI,OAAO,YAAY,8BAAa,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,EAAE,QAAQ,EAAE,2BAAgB,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;IACtD,CAAC;CACJ;AApBD,4DAoBC"}
+{"version":3,"file":"context-edit-validator.js","sourceRoot":"","sources":["../../../../src/common/features/directediting/context-edit-validator.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;kFAckF;AAClF,+CAAoD;AACpD,qDAAuF;AAEvF,iEAA4D;AAE/C,QAAA,oBAAoB,GAAG,MAAM,CAAC,sBAAsB,CAAC,CAAC;AAiBnE,MAAa,wBAAwB;IAEjC,YACa,UAAsB,EAC/B,kBAAsC;QAD7B,eAAU,GAAV,UAAU,CAAY;QAG/B,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;IACjD,CAAC;IAED,IAAI,SAAS;QACT,OAAO,yCAAkB,CAAC,UAAU,CAAC;IACzC,CAAC;IAED,QAAQ,CAAC,MAAmC;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACjE,IAAI,OAAO,YAAY,qBAAa,EAAE,CAAC;YACnC,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,EAAE,QAAQ,EAAE,2BAAgB,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;IACtD,CAAC;CACJ;AApBD,4DAoBC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eclipse-glsp/server",
-  "version": "2.8.0-next.5",
+  "version": "2.8.0-next.7",
   "description": "A js server framework for Eclipse GLSP",
   "keywords": [
     "eclipse",
@@ -45,7 +45,10 @@
     "browser.d.ts",
     "browser.js",
     "common.d.ts",
-    "common.js"
+    "common.js",
+    "!**/*.spec.ts",
+    "!**/*.spec.tsx",
+    "!**/test/**"
   ],
   "dependencies": {
     "@eclipse-glsp/protocol": "next",
@@ -54,7 +57,7 @@
     "vscode-jsonrpc": "8.2.0",
     "winston": "^3.3.3",
     "ws": "^8.12.1",
-    "@eclipse-glsp/graph": "2.8.0-next.5"
+    "@eclipse-glsp/graph": "2.8.0-next.7"
   },
   "devDependencies": {
     "@types/ws": "^8.5.4"
@@ -68,11 +71,8 @@
   },
   "scripts": {
     "build": "tsc -b",
-    "clean": "rimraf lib *.tsbuildinfo coverage .nyc_output",
+    "clean": "rimraf lib *.tsbuildinfo coverage",
     "generate:index": "glsp generateIndex src/browser src/common src/node -s -f",
-    "lint": "eslint ./src",
-    "test": "mocha --config ../../.mocharc \"./src/**/*.spec.?(ts|tsx)\"",
-    "test:ci": "pnpm test --reporter mocha-ctrf-json-reporter",
-    "test:coverage": "nyc pnpm test:ci"
+    "lint": "eslint ./src"
   }
 }

package/src/common/features/directediting/context-edit-validator.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2022-2024 STMicroelectronics and others.
+ * Copyright (c) 2022-2026 STMicroelectronics and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,7 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement } from '@eclipse-glsp/graph/lib/gmodel-element';
+import { GModelElement } from '@eclipse-glsp/graph';
 import { RequestEditValidationAction, ValidationStatus } from '@eclipse-glsp/protocol';
 import { ModelState } from '../model/model-state';
 import { LabelEditValidator } from './label-edit-validator';

package/src/browser/di/browser-action-dispatch-scope.spec.ts

@@ -1,75 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2026 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 '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import { ClientAction } from '../../common/protocol/client-action';
-import * as mock from '../../common/test/mock-util';
-import { BrowserActionDispatchScope } from './browser-action-dispatch-scope';
-
-describe('BrowserActionDispatchScope', () => {
-    const action: Action = { kind: 'foo' };
-    const markedClientAction = ((): Action => {
-        const a: Action = { kind: 'bar' };
-        ClientAction.mark(a);
-        return a;
-    })();
-
-    let scope: BrowserActionDispatchScope;
-    beforeEach(() => {
-        scope = new BrowserActionDispatchScope();
-    });
-
-    it('isReentrant is false outside enter()', () => {
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('isReentrant is true during a synchronous enter()', () => {
-        scope.enter(() => {
-            expect(scope.isReentrant(action)).to.be.true;
-        });
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('isReentrant is true during an async enter() and false after settle', async () => {
-        const probe: Promise<boolean> = scope.enter(async () => {
-            await Promise.resolve();
-            return scope.isReentrant(action);
-        });
-        expect(await probe).to.be.true;
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('resets active flag when callback throws synchronously', () => {
-        expect(() =>
-            scope.enter(() => {
-                throw new Error('boom');
-            })
-        ).to.throw('boom');
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('resets active flag when async callback rejects', async () => {
-        await mock.expectToThrowAsync(() => scope.enter(() => Promise.reject(new Error('boom'))), 'boom');
-        expect(scope.isReentrant(action)).to.be.false;
-    });
-
-    it('isReentrant is false for client-originated actions even when scope is active', () => {
-        scope.enter(() => {
-            expect(scope.isReentrant(markedClientAction)).to.be.false;
-            expect(scope.isReentrant(action)).to.be.true;
-        });
-    });
-});

package/src/common/actions/action-handler-registry.spec.ts

@@ -1,52 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import * as mock from '../test/mock-util';
-import { ActionHandlerRegistry } from './action-handler-registry';
-import { expect } from 'chai';
-
-describe('Test ActionHandlerRegistry (only functionality that is not covered by "registry.spec.ts"', () => {
-    const singleAction = 'singleHandledAction';
-    const multiAction = 'multiHandledAction';
-
-    const h1 = new mock.StubActionHandler([singleAction]);
-    const h2 = new mock.StubActionHandler([multiAction]);
-    const h3 = new mock.StubActionHandler([multiAction]);
-    const h4 = new mock.StubActionHandler([multiAction]);
-    const registry: ActionHandlerRegistry = new ActionHandlerRegistry();
-
-    it('registerHandler - should register given handlers', () => {
-        // setup
-        registry.registerHandler(h1);
-        registry.registerHandler(h2);
-        registry.registerHandler(h3);
-        registry.registerHandler(h4);
-
-        const result = registry.getAll();
-        expect(result).to.have.length(4);
-        expect(result.includes(h1)).true;
-        expect(result.includes(h2)).true;
-        expect(result.includes(h3)).true;
-        expect(result.includes(h4)).true;
-    });
-
-    it('get - should return three handlers sorted by priority', () => {
-        const result = registry.get(multiAction);
-        expect(result.length).to.be.equal(3);
-        expect(result[0]).to.be.deep.equal(h4);
-        expect(result[1]).to.be.deep.equal(h2);
-        expect(result[2]).to.be.deep.equal(h3);
-    });
-});

package/src/common/actions/global-action-provider.spec.ts

@@ -1,68 +0,0 @@
-/********************************************************************************
- * Copyright (c) 2022-2023 STMicroelectronics and others.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0 which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the Eclipse
- * Public License v. 2.0 are satisfied: GNU General Public License, version 2
- * with the GNU Classpath Exception which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- ********************************************************************************/
-import { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import * as sinon from 'sinon';
-import { DiagramModules, InjectionContainer } from '../di/service-identifiers';
-import { ClientSessionInitializer } from '../session/client-session-initializer';
-import * as mock from '../test/mock-util';
-import { Logger } from '../utils/logger';
-import { ActionHandler } from './action-handler';
-import { ActionHandlerRegistry } from './action-handler-registry';
-import { DefaultGlobalActionProvider } from './global-action-provider';
-
-describe('test DefaultGlobalActionProvider', () => {
-    const container = new Container();
-    const serverActions = ['A1', 'A2', 'A3'];
-    const diagramType = 'myDiagramType';
-
-    const handler1Actions = ['A1', 'A2'];
-    const handler2Actions = ['A2', 'A3'];
-
-    const h1 = new mock.StubActionHandler(handler1Actions);
-    const h2 = new mock.StubActionHandler(handler2Actions);
-
-    const handlerRegistry = new ActionHandlerRegistry();
-    sinon.stub(handlerRegistry, 'getAll').returns([h1, h2]);
-
-    const diagramModule1 = new ContainerModule(bind => {
-        bind(ClientSessionInitializer).toConstantValue(new mock.StubClientSessionInitializer());
-        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler1Actions));
-        bind(ActionHandler).toConstantValue(new mock.StubActionHandler(handler2Actions));
-        bind(ActionHandlerRegistry).toConstantValue(handlerRegistry);
-    });
-
-    const diagramModules = new Map<string, ContainerModule[]>();
-    diagramModules.set(diagramType, [diagramModule1]);
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new mock.StubLogger());
-            bind(InjectionContainer).toConstantValue(container);
-            bind(DiagramModules).toConstantValue(diagramModules);
-        })
-    );
-
-    const actionProvider = container.resolve(DefaultGlobalActionProvider);
-
-    it('serverActionsKinds', () => {
-        const result = actionProvider.actionKinds;
-        expect(result.size).to.be.equal(1);
-        const resultServerActions = result.get(diagramType);
-        expect(resultServerActions).to.not.be.undefined;
-        expect(serverActions.every(action => resultServerActions!.includes(action))).true;
-    });
-});

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

@@ -1,239 +0,0 @@
-/********************************************************************************
- * 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 { expect } from 'chai';
-import { Container, ContainerModule } from 'inversify';
-import * as sinon from 'sinon';
-import { expectToThrowAsync, StubCommand, StubLogger } from '../test/mock-util';
-import { Logger } from '../utils/logger';
-import { DefaultCommandStack } from './command-stack';
-
-describe('test DefaultCommandStack', () => {
-    const sandbox = sinon.createSandbox();
-    const container = new Container();
-
-    const command1 = sandbox.stub(new StubCommand());
-    const command2 = sandbox.stub(new StubCommand());
-    let commandStack: DefaultCommandStack;
-
-    container.load(
-        new ContainerModule(bind => {
-            bind(Logger).toConstantValue(new StubLogger());
-        })
-    );
-    commandStack = container.resolve(DefaultCommandStack);
-
-    afterEach(() => {
-        sandbox.reset();
-        commandStack = container.resolve(DefaultCommandStack);
-    });
-
-    describe('execute', () => {
-        it('should execute the given command and become dirty', async () => {
-            expect(commandStack.isDirty).to.be.false;
-            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', async () => {
-            expect(commandStack.isDirty).to.be.false;
-            await commandStack.execute(command1);
-            await commandStack.execute(command2);
-
-            expect(command1.execute.calledOnce).to.be.true;
-            expect(command2.execute.calledOnce).to.be.true;
-            expect(command2.execute.calledAfter(command1.execute)).to.be.true;
-            expect(commandStack.isDirty).to.be.true;
-        });
-
-        it('should be able to undo after execute', async () => {
-            expect(commandStack.canUndo()).to.be.false;
-            await commandStack.execute(command1);
-            expect(commandStack.canUndo()).to.be.true;
-        });
-
-        it('should clear the redo stack after execution', async () => {
-            commandStack['commands'].push(command2);
-            commandStack['top'] = -1;
-            expect(commandStack.canRedo()).to.be.true;
-
-            await commandStack.execute(command1);
-            expect(commandStack.canRedo()).to.be.false;
-        });
-
-        it('should flush the stack in case of an execution error', async () => {
-            command2.execute.throwsException();
-            const flushSpy = sandbox.spy(commandStack, 'flush');
-
-            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', async () => {
-            expect(commandStack.isDirty).to.be.false;
-
-            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', 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;
-
-            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', 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;
-
-            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;
-
-            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', async () => {
-            command2.undo.throwsException();
-            const flushSpy = sandbox.spy(commandStack, 'flush');
-            commandStack['commands'].push(command2);
-            commandStack['top'] = 0;
-
-            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', async () => {
-            expect(commandStack.isDirty).to.be.false;
-
-            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', 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;
-
-            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', async () => {
-            commandStack['commands'].push(command2, command1);
-            commandStack['top'] = -1;
-            commandStack['saveIndex'] = -1;
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.true;
-
-            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;
-
-            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', async () => {
-            command2.redo.throwsException();
-            const flushSpy = sandbox.spy(commandStack, 'flush');
-            commandStack['commands'].push(command2);
-            commandStack['top'] = -1;
-
-            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', async () => {
-            commandStack['commands'].push(command1);
-            commandStack['top'] = -1;
-            expect(commandStack.canUndo()).to.be.false;
-            await commandStack.redo();
-            expect(commandStack.canUndo()).to.be.true;
-        });
-    });
-
-    describe('flush', () => {
-        it('should reset the internal state of the command stack', () => {
-            commandStack['commands'].push(command1, command1);
-            commandStack['top'] = 0;
-
-            commandStack.flush();
-            expect(commandStack.isDirty).to.be.false;
-            expect(commandStack.canUndo()).to.be.false;
-            expect(commandStack.canRedo()).to.be.false;
-        });
-    });
-
-    describe('isSaveDone', () => {
-        it('should become non-dirty after execution', () => {
-            commandStack['commands'].push(command1);
-            commandStack['top'] = 0;
-            expect(commandStack.isDirty).to.be.true;
-
-            commandStack.saveIsDone();
-            expect(commandStack.isDirty).to.be.false;
-        });
-        it('should maintain undo/redo history after execution', () => {
-            commandStack['commands'].push(command1, command2);
-            commandStack['top'] = 0;
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.canRedo()).to.be.true;
-
-            commandStack.saveIsDone();
-            expect(commandStack.canUndo()).to.be.true;
-            expect(commandStack.canRedo()).to.be.true;
-        });
-    });
-});

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

@@ -1,92 +0,0 @@
-/********************************************************************************
- * 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 { expect } from 'chai';
-import * as sinon from 'sinon';
-import { expectToThrowAsync, StubCommand } from '../test/mock-util';
-import { CompoundCommand } from './command';
-
-describe('CompoundCommand', () => {
-    const sandbox = sinon.createSandbox();
-
-    const command1 = sandbox.stub(new StubCommand());
-    const command2 = sandbox.stub(new StubCommand());
-    const command3 = sandbox.stub(new StubCommand());
-
-    const compoundCommand = new CompoundCommand(command1, command2, command3);
-
-    afterEach(() => {
-        sandbox.reset();
-    });
-
-    describe('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', async () => {
-            command3.execute.throwsException();
-
-            await expectToThrowAsync(() => 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.undo.calledOnce).to.be.true;
-            expect(command2.undo.calledOnce).to.be.true;
-        });
-    });
-
-    describe('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;
-            expect(command1.undo.calledAfter(command2.undo)).to.be.true;
-            expect(command2.undo.calledAfter(command3.undo)).to.be.true;
-        });
-
-        it('Should redo partially undone subcommands in  case of an error', async () => {
-            command1.undo.throwsException();
-            await expectToThrowAsync(() => compoundCommand.undo());
-
-            expect(command1.undo.calledOnce).to.be.true;
-            expect(command2.undo.calledOnce).to.be.true;
-            expect(command3.undo.calledOnce).to.be.true;
-            expect(command3.redo.calledOnce).to.be.true;
-            expect(command2.redo.calledOnce).to.be.true;
-        });
-    });
-
-    describe('canUndo', () => {
-        it('should return true if all subcommands can be undone', () => {
-            command1.canUndo?.returns(true);
-            command2.canUndo?.returns(true);
-            command3.canUndo?.returns(true);
-            expect(compoundCommand.canUndo()).to.be.true;
-        });
-        it('should return true if anyof the  subcommands cannot be undone', () => {
-            command1.canUndo?.returns(true);
-            command2.canUndo?.returns(false);
-            command3.canUndo?.returns(true);
-            expect(compoundCommand.canUndo()).to.be.true;
-        });
-    });
-});