@eclipse-glsp/server 1.1.0-next.3d7585d.42 → 1.1.0-next.44aae0c.44

package/src/common/operations/create-operation-handler.ts

@@ -13,94 +13,37 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { GModelElement } from '@eclipse-glsp/graph';
 import {
     CreateEdgeOperation,
     CreateNodeOperation,
-    CreateOperation,
-    MaybePromise,
-    Operation,
-    Point,
+    hasArrayProp,
+    hasFunctionProp,
+    hasStringProp,
     TriggerEdgeCreationAction,
     TriggerNodeCreationAction
 } from '@eclipse-glsp/protocol';
-import { inject, injectable } from 'inversify';
-import { ModelState } from '../features/model/model-state';
-import { getRelativeLocation } from '../utils/layout-util';
 import { OperationHandler } from './operation-handler';
 
 /**
  * A special {@link OperationHandler} that is responsible for the handling of {@link CreateOperation}s. Depending on its
  * operation type the triggered actions are {@link TriggerNodeCreationAction} or {@link TriggerEdgeCreationAction}s.
  */
-@injectable()
-export abstract class CreateOperationHandler implements OperationHandler {
-    abstract operationType: string;
-    abstract readonly label: string;
-    abstract elementTypeIds: string[];
-
-    abstract execute(operation: Operation): MaybePromise<void>;
-
-    /**
-     * Returns a list of {@link TriggerElementCreationAction}s for registered element types.
-     *
-     * @returns A list of {@link TriggerElementCreationAction}s.
-     */
-    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[] {
-        if (this.operationType === CreateNodeOperation.KIND) {
-            return this.elementTypeIds.map(typeId => TriggerNodeCreationAction.create(typeId));
-        } else if (this.operationType === CreateEdgeOperation.KIND) {
-            return this.elementTypeIds.map(typeId => TriggerEdgeCreationAction.create(typeId));
-        }
-        return [];
-    }
-
-    handles(operation: CreateOperation): boolean {
-        return this.elementTypeIds.includes(operation.elementTypeId);
-    }
+export interface CreateOperationHandler extends OperationHandler {
+    readonly label: string;
+    elementTypeIds: string[];
+    operationType: CreateOperationKind;
+    getTriggerActions(): (TriggerEdgeCreationAction | TriggerNodeCreationAction)[];
 }
 
-/**
- * Abstract base implementation for {@link CreateOperationHandler} that
- * create an element that is represented with a {@link GNode} in the graphical model.
- */
-@injectable()
-export abstract class CreateNodeOperationHandler extends CreateOperationHandler {
-    @inject(ModelState)
-    protected modelState: ModelState;
-
-    get operationType(): string {
-        return CreateNodeOperation.KIND;
-    }
-
-    /**
-     * Retrieve the graphical model element that should contain the newly created {@link GNode}.
-     * If `undefined` is returned the {@link GNode} should be added directly to the diagram root.
-     * @param operation The currently handled operation.
-     * @returns The container {@link GModeElement} or `undefined`.
-     */
-    getContainer(operation: CreateNodeOperation): GModelElement | undefined {
-        const index = this.modelState.index;
-        return operation.containerId ? index.get(operation.containerId) : undefined;
-    }
-
-    getLocation(operation: CreateNodeOperation): Point | undefined {
-        return operation.location;
-    }
+export type CreateOperationKind = typeof CreateNodeOperation.KIND | typeof CreateEdgeOperation.KIND;
 
-    /**
-     * Retrieves the diagram absolute location and the target container from the given {@link CreateNodeOperation}
-     * and converts the absolute location to coordinates relative to the given container.
-     *  Relative coordinates can only be retrieved if the given container element is part of
-     * a hierarchy of {@link GBoundsAware} elements. This means each (recursive) parent element need to
-     * implement {@link GBoundsAware}. If that is not the case this method returns `undefined`.
-     * @param absoluteLocation The diagram absolute position.
-     * @param container The container element.
-     * @returns The relative position or `undefined`.
-     */
-    getRelativeLocation(operation: CreateNodeOperation): Point | undefined {
-        const container = this.getContainer(operation) ?? this.modelState.root;
-        const absoluteLocation = this.getLocation(operation) ?? Point.ORIGIN;
-        return getRelativeLocation(absoluteLocation, container);
+export namespace CreateOperationHandler {
+    export function is(object: unknown): object is CreateOperationHandler {
+        return (
+            object instanceof OperationHandler &&
+            hasStringProp(object, 'label') &&
+            hasArrayProp(object, 'elementTypeIds') &&
+            hasFunctionProp(object, 'getTriggerActions')
+        );
     }
 }

package/src/common/operations/operation-action-handler.ts

@@ -13,57 +13,81 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Action, CreateOperation, MaybePromise, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
+import { Action, MaybePromise, Operation, ServerMessageAction } from '@eclipse-glsp/protocol';
 import { inject, injectable } from 'inversify';
 import { ActionHandler } from '../actions/action-handler';
+import { Command } from '../command/command';
+import { CommandStack } from '../command/command-stack';
 import { Operations } from '../di/service-identifiers';
 import { ModelState } from '../features/model/model-state';
 import { ModelSubmissionHandler } from '../features/model/model-submission-handler';
+import { GLSPServerError } from '../utils/glsp-server-error';
 import { OperationHandler } from './operation-handler';
 import { OperationHandlerRegistry } from './operation-handler-registry';
 
 @injectable()
 export class OperationActionHandler implements ActionHandler {
-    @inject(OperationHandlerRegistry) protected operationHandlerRegistry: OperationHandlerRegistry;
-    @inject(ModelSubmissionHandler) protected modelSubmissionHandler: ModelSubmissionHandler;
-    @inject(ModelState) protected modelState: ModelState;
+    @inject(OperationHandlerRegistry)
+    protected operationHandlerRegistry: OperationHandlerRegistry;
+
+    @inject(ModelSubmissionHandler)
+    protected modelSubmissionHandler: ModelSubmissionHandler;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(CommandStack)
+    protected commandStack: CommandStack;
 
     constructor(@inject(Operations) readonly actionKinds: string[]) {}
 
     execute(action: Operation): MaybePromise<Action[]> {
-        if (this.handles(action)) {
-            if (this.modelState.isReadonly) {
-                return [
-                    ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
-                        severity: 'WARNING'
-                    })
-                ];
-            }
-            const operationHandler = OperationActionHandler.getOperationHandler(action, this.operationHandlerRegistry);
-            if (operationHandler) {
-                return this.executeHandler(action, operationHandler);
-            }
+        if (!this.handles(action)) {
+            throw new GLSPServerError(`Unhandled operation kind: ${action.kind}`);
+        }
+        if (this.modelState.isReadonly) {
+            return [
+                ServerMessageAction.create(`Server is in readonly-mode! Could not execute operation: ${action.kind}`, {
+                    severity: 'WARNING'
+                })
+            ];
+        }
+        return this.executeOperation(action);
+    }
+
+    protected executeOperation(operation: Operation): MaybePromise<Action[]> {
+        const operationHandler = OperationActionHandler.getOperationHandler(operation, this.operationHandlerRegistry);
+        if (operationHandler) {
+            return this.executeHandler(operation, operationHandler);
         }
         return [];
     }
 
-    async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
-        // TODO: Create GModelRecordingCommand;
-        await handler.execute(operation);
-        this.modelState.index.indexRoot(this.modelState.root);
-        this.modelState.isDirty = true;
-        // TODO: this.modelState.execute(command)
+    protected async executeHandler(operation: Operation, handler: OperationHandler): Promise<Action[]> {
+        const command = await handler.execute(operation);
+        if (command) {
+            await this.executeCommand(command);
+        }
+        return this.modelSubmissionHandler.submitModel('operation');
+    }
+
+    protected async executeCommand(command: Command): Promise<void> {
+        return this.commandStack.execute(command);
+    }
+
+    protected submitModel(): MaybePromise<Action[]> {
         return this.modelSubmissionHandler.submitModel('operation');
     }
 
     handles(action: Action): boolean {
-        if (this.actionKinds.includes(action.kind)) {
-            return true;
-        }
-        return false;
+        return this.actionKinds.includes(action.kind);
     }
 
+    /**
+     *  @Deprecated Use {@link OperationHandlerRegistry#getOperationHandler(Operation) instead}.
+     */
+
     static getOperationHandler(operation: Operation, registry: OperationHandlerRegistry): OperationHandler | undefined {
-        return CreateOperation.is(operation) ? registry.get(`${operation.kind}_${operation.elementTypeId}`) : registry.get(operation.kind);
+        return registry.getOperationHandler(operation);
     }
 }

package/src/common/operations/operation-handler-registry.ts

@@ -13,8 +13,9 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { Args } from '@eclipse-glsp/protocol';
+import { Args, CreateOperation, MaybePromise, Operation } from '@eclipse-glsp/protocol';
 import { inject, injectable, optional } from 'inversify';
+import { Command } from '../command/command';
 import { ClientSessionInitializer } from '../session/client-session-initializer';
 import { Registry } from '../utils/registry';
 import { CreateOperationHandler } from './create-operation-handler';
@@ -23,13 +24,27 @@ import { OperationHandler, OperationHandlerConstructor, OperationHandlerFactory
 @injectable()
 export class OperationHandlerRegistry extends Registry<string, OperationHandler> {
     registerHandler(handler: OperationHandler): boolean {
-        if (handler instanceof CreateOperationHandler) {
+        if (CreateOperationHandler.is(handler)) {
             handler.elementTypeIds.forEach(typeId => this.register(`${handler.operationType}_${typeId}`, handler));
             return true;
         } else {
             return this.register(handler.operationType, handler);
         }
     }
+
+    getOperationHandler(operation: Operation): OperationHandler | undefined {
+        return CreateOperation.is(operation) ? this.get(`${operation.kind}_${operation.elementTypeId}`) : this.get(operation.kind);
+    }
+
+    /**
+     * Returns the matching command for the given operation.
+     *
+     * @param operation operation
+     * @return the matching command for the given operation
+     */
+    getExecutableCommand(operation: Operation): MaybePromise<Command | undefined> {
+        return this.getOperationHandler(operation)?.createCommand(operation);
+    }
 }
 
 @injectable()
@@ -44,7 +59,7 @@ export class OperationHandlerRegistryInitializer implements ClientSessionInitial
     @inject(OperationHandlerRegistry)
     protected registry: OperationHandlerRegistry;
 
-    initialize(args?: Args): void {
+    initialize(_args?: Args): void {
         const handlers = this.handlerConstructors.map(constructor => this.factory(constructor));
         handlers.forEach(handler => this.registry.registerHandler(handler));
     }

package/src/common/operations/operation-handler.ts

@@ -14,38 +14,63 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 import { MaybePromise, Operation } from '@eclipse-glsp/protocol';
-import { interfaces } from 'inversify';
-
-export const OperationHandler = Symbol('OperationHandler');
+import { inject, injectable, interfaces } from 'inversify';
+import { Command } from '../command/command';
+import { ModelState } from '../features/model/model-state';
 
 /**
  * An operation handler can execute {@link Operation}s of a certain type (subclass).
  * The operation handler processes the operation in the {@link OperationHandler.execute()} method. The result
- * of the execution is an update of the `ModelState` state.
- * This update is reversible (undo) and can be reapplied (redo). For basic diagram languages these updates are typically
- * applied directly on the `ModelState` using EMF `Command`s and the
- * `ModelState.execute()` method. For more complex diagram languages the
- * GModel state might be updated indirectly and the operation handler manipulates a custom model representation.
+ * of the execution is a {@link Command} that captures the corresponding source model changes.
+ * This command can be applied on the `CommandStack` and is reversible (undo) and can be reapplied (redo).
  *
  * The `OperationActionHandler` is responsible for retrieving all available (valid) operation handlers for an
  * operation that is dispatched via `ActionDispatcher`.
  */
-export interface OperationHandler {
+@injectable()
+export abstract class OperationHandler {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
     /**
      * Returns the operation type that can be handled by this operation handler.
      *
      * @returns the operation type that can be handled.
      */
-    readonly operationType: string;
+    abstract operationType: string;
 
     readonly label?: string;
 
     /**
-     * Executes the operation handler for the given {@link Operation}.
+     * Creates a command that performs the operation in the source model(s). If `undefined` is  returned, no update
+     * is performed on the model(s).
+     *
+     * @param operation The operation to process.
+     * @return The created command to be executed on the command stack or `undefined` nothing should be done.
+     */
+    abstract createCommand(operation: Operation): MaybePromise<Command | undefined>;
+
+    /**
+     * Executes the operation handler for the given {@link Operation} and returns the corresponding {@link Command}.
+     * If the given operation cannot be handled by this handler or the handler execution did not result in any changes
+     * `undefined` is returned.
+     *
+     * @param operation The operation that should be executed or empty if nothing should be done.
+     * @returns The command capturing the execution changes or `undefined`
+     */
+    execute(operation: Operation): MaybePromise<Command | undefined> {
+        return this.handles(operation) ? this.createCommand(operation) : undefined;
+    }
+
+    /**
+     * Validates whether the given {@link Operation} can be handled by this operation handler.
      *
-     * @param operation The operation that should be executed.
+     * @param operation The operation that should be validated.
+     * @returns `true` if the given operation can be handled, `false` otherwise.
      */
-    execute(operation: Operation): MaybePromise<void>;
+    handles(operation: Operation): boolean {
+        return this.modelState.root && operation.kind === this.operationType;
+    }
 }
 
 export const OperationHandlerConstructor = Symbol('OperationHandlerConstructor');

package/src/common/test/mock-util.ts

@@ -13,6 +13,7 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
+/* eslint-disable @typescript-eslint/no-empty-function */
 // Stub-implementation classes used for unit testing
 
 import { GEdge, GModelElement, GModelElementConstructor, GNode } from '@eclipse-glsp/graph';
@@ -24,15 +25,18 @@ import {
     EdgeTypeHint,
     InitializeClientSessionParameters,
     MaybeArray,
+    MaybePromise,
     Point,
     RequestEditValidationAction,
     ShapeTypeHint,
     ValidationStatus
 } from '@eclipse-glsp/protocol';
+import { expect } from 'chai';
 import { Container } from 'inversify';
 import { MessageConnection } from 'vscode-jsonrpc';
 import { ActionDispatcher } from '../actions/action-dispatcher';
 import { ActionHandler, ActionHandlerFactory } from '../actions/action-handler';
+import { Command } from '../command/command';
 import { DiagramConfiguration, ServerLayoutKind } from '../diagram/diagram-configuration';
 import { ContextEditValidator } from '../features/directediting/context-edit-validator';
 import { LabelEditValidator } from '../features/directediting/label-edit-validator';
@@ -51,6 +55,25 @@ export async function delay(ms: number): Promise<void> {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 
+/**
+ * Consumes a maybe async function and checks for error
+ * @param  method - The function to check
+ * @param  message - Optional message to match with error message
+ */
+export async function expectToThrowAsync(toEvaluate: () => MaybePromise<void>, message?: string): Promise<void> {
+    let err: Error | undefined = undefined;
+    try {
+        await toEvaluate();
+    } catch (error: any) {
+        err = error;
+    }
+    if (message) {
+        expect(err?.message).to.be.equal(message);
+    } else {
+        expect(err).to.be.an('Error');
+    }
+}
+
 export function createClientSession(
     id: string,
     diagramType: string,
@@ -103,9 +126,7 @@ export class StubCreateEdgeOperationHandler extends GModelCreateEdgeOperationHan
 }
 
 export class StubActionDispatcher implements ActionDispatcher {
-    dispatchAfterNextUpdate(...actions: MaybeArray<Action[]>): void {
-        // NO-OP
-    }
+    dispatchAfterNextUpdate(...actions: MaybeArray<Action[]>): void {}
 
     dispatch(action: Action): Promise<void> {
         return Promise.resolve();
@@ -158,51 +179,31 @@ export class StubLogger extends Logger {
     logLevel = LogLevel.none;
     caller = undefined;
 
-    info(message: string, ...params: any[]): void {
-        // no-op
-    }
+    info(message: string, ...params: any[]): void {}
 
-    warn(message: string, ...params: any[]): void {
-        // no-op
-    }
+    warn(message: string, ...params: any[]): void {}
 
-    error(message: string, ...params: any[]): void {
-        // no-op
-    }
+    error(message: string, ...params: any[]): void {}
 
-    debug(message: string, ...params: any[]): void {
-        // no-op
-    }
+    debug(message: string, ...params: any[]): void {}
 }
 
 export class StubClientSessionListener implements ClientSessionListener {
-    sessionCreated(clientSession: ClientSession): void {
-        // no-op
-    }
+    sessionCreated(clientSession: ClientSession): void {}
 
-    sessionDisposed(clientSession: ClientSession): void {
-        // no-op
-    }
+    sessionDisposed(clientSession: ClientSession): void {}
 }
 
 export class StubGLSPClientProxy implements JsonRpcGLSPClientProxy {
-    connect(connection: MessageConnection): void {
-        // no-op
-    }
+    connect(connection: MessageConnection): void {}
 
-    process(message: ActionMessage<Action>): void {
-        // no-op
-    }
+    process(message: ActionMessage<Action>): void {}
 }
 
 export class StubGLSPServerListener implements GLSPServerListener {
-    serverInitialized(server: GLSPServer): void {
-        // no-op
-    }
+    serverInitialized(server: GLSPServer): void {}
 
-    serverShutDown(server: GLSPServer): void {
-        // no-op
-    }
+    serverShutDown(server: GLSPServer): void {}
 }
 
 export class StubDiagramConfiguration implements DiagramConfiguration {
@@ -250,7 +251,12 @@ export class TestContextEditValidator implements ContextEditValidator {
 export const stubActionHandlerFactory: ActionHandlerFactory = constructor => new constructor();
 
 export class StubClientSessionInitializer implements ClientSessionInitializer {
-    initialize(args?: Args): void {
-        // no-op
-    }
+    initialize(args?: Args): void {}
+}
+
+export class StubCommand implements Command {
+    execute(): void {}
+    undo(): void {}
+    redo(): void {}
+    canUndo?(): boolean;
 }

package/lib/common/gmodel/apply-label-edit-operation-handler.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=apply-label-edit-operation-handler.spec.d.ts.map

package/lib/common/gmodel/apply-label-edit-operation-handler.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"apply-label-edit-operation-handler.spec.d.ts","sourceRoot":"","sources":["../../../src/common/gmodel/apply-label-edit-operation-handler.spec.ts"],"names":[],"mappings":""}

package/lib/common/gmodel/apply-label-edit-operation-handler.spec.js

@@ -1,38 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-/********************************************************************************
- * 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
- ********************************************************************************/
-const graph_1 = require("@eclipse-glsp/graph");
-const protocol_1 = require("@eclipse-glsp/protocol");
-const chai_1 = require("chai");
-const sinon = require("sinon");
-const gmodel_index_1 = require("../features/model/gmodel-index");
-const model_state_1 = require("../features/model/model-state");
-const apply_label_edit_operation_handler_1 = require("./apply-label-edit-operation-handler");
-const assert = require("assert");
-describe('Test ApplyLabelEditOperationHandler', () => {
-    const label = new graph_1.GLabel();
-    const modelState = new model_state_1.DefaultModelState();
-    Object.defineProperty(modelState, 'index', { value: new gmodel_index_1.GModelIndex() });
-    sinon.stub(modelState.index, 'findByClass').returns(label);
-    const applyLabelEditOperationHandler = new apply_label_edit_operation_handler_1.ApplyLabelEditOperationHandler();
-    Object.defineProperty(applyLabelEditOperationHandler, 'modelState', { value: modelState });
-    it('text is changed after ApplyLabelEditOperation', async () => {
-        assert.doesNotThrow(() => applyLabelEditOperationHandler.execute(protocol_1.ApplyLabelEditOperation.create({ labelId: 'myId', text: 'test' })));
-        (0, chai_1.expect)(label.text).to.be.equal('test');
-    });
-});
-//# sourceMappingURL=apply-label-edit-operation-handler.spec.js.map

package/lib/common/gmodel/apply-label-edit-operation-handler.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"apply-label-edit-operation-handler.spec.js","sourceRoot":"","sources":["../../../src/common/gmodel/apply-label-edit-operation-handler.spec.ts"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;kFAckF;AAClF,+CAA6C;AAC7C,qDAAiE;AACjE,+BAA8B;AAC9B,+BAA+B;AAC/B,iEAA6D;AAC7D,+DAAkE;AAClE,6FAAsF;AAEtF,iCAAkC;AAElC,QAAQ,CAAC,qCAAqC,EAAE,GAAG,EAAE;IACjD,MAAM,KAAK,GAAG,IAAI,cAAM,EAAE,CAAC;IAC3B,MAAM,UAAU,GAAG,IAAI,+BAAiB,EAAE,CAAC;IAC3C,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,IAAI,0BAAW,EAAE,EAAE,CAAC,CAAC;IACzE,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3D,MAAM,8BAA8B,GAAG,IAAI,mEAA8B,EAAE,CAAC;IAC5E,MAAM,CAAC,cAAc,CAAC,8BAA8B,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,CAAC;IAE3F,EAAE,CAAC,+CAA+C,EAAE,KAAK,IAAI,EAAE;QAC3D,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,CACrB,8BAA8B,CAAC,OAAO,CAAC,kCAAuB,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC,CAC5G,CAAC;QACF,IAAA,aAAM,EAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC,CAAC,CAAC;AACP,CAAC,CAAC,CAAC"}

package/lib/common/gmodel/computed-bounds-action-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-bounds-action-handler.d.ts","sourceRoot":"","sources":["../../../src/common/gmodel/computed-bounds-action-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;kFAckF;AAClF,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAEpF,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,4CAA4C,CAAC;AAGpF,qBACa,2BAA4B,YAAW,aAAa;IAE7D,SAAS,CAAC,iBAAiB,EAAE,sBAAsB,CAAC;IAGpD,SAAS,CAAC,UAAU,EAAE,UAAU,CAAC;IAEjC,WAAW,WAA+B;IAC1C,OAAO,CAAC,MAAM,EAAE,oBAAoB,GAAG,YAAY,CAAC,MAAM,EAAE,CAAC;IAU7D,SAAS,CAAC,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,oBAAoB,GAAG,IAAI;IAO3E,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC"}

package/lib/common/gmodel/computed-bounds-action-handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-bounds-action-handler.js","sourceRoot":"","sources":["../../../src/common/gmodel/computed-bounds-action-handler.ts"],"names":[],"mappings":";;;;;;;;;;;;AAgBA,qDAAoF;AACpF,yCAA+C;AAE/C,+DAA2D;AAC3D,yFAAoF;AACpF,sDAA+E;AAGxE,IAAM,2BAA2B,GAAjC,MAAM,2BAA2B;IAAjC;QAOH,gBAAW,GAAG,CAAC,+BAAoB,CAAC,IAAI,CAAC,CAAC;IAmB9C,CAAC;IAlBG,OAAO,CAAC,MAA4B;QAChC,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;QACnC,IAAI,MAAM,CAAC,QAAQ,KAAK,KAAK,CAAC,QAAQ,EAAE;YACpC,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;YAChC,OAAO,IAAI,CAAC,iBAAiB,CAAC,mBAAmB,EAAE,CAAC;SACvD;QAED,OAAO,EAAE,CAAC;IACd,CAAC;IAES,WAAW,CAAC,IAAgB,EAAE,MAA4B;;QAChE,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC;QACpC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,IAAA,yBAAW,EAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;QAC5D,CAAC,MAAA,MAAM,CAAC,UAAU,mCAAI,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,IAAA,4BAAc,EAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;QACjF,CAAC,MAAA,MAAM,CAAC,MAAM,mCAAI,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,IAAA,wBAAU,EAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IACrE,CAAC;CAGJ,CAAA;AAzBG;IAAC,IAAA,kBAAM,EAAC,iDAAsB,CAAC;8BACF,iDAAsB;sEAAC;AAEpD;IAAC,IAAA,kBAAM,EAAC,wBAAU,CAAC;;+DACc;AALxB,2BAA2B;IADvC,IAAA,sBAAU,GAAE;GACA,2BAA2B,CA0BvC;AA1BY,kEAA2B"}

package/lib/common/operations/cut-operation-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cut-operation-handler.d.ts","sourceRoot":"","sources":["../../../src/common/operations/cut-operation-handler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;kFAckF;AAClF,OAAO,EAAE,YAAY,EAA0B,YAAY,EAAE,MAAM,wBAAwB,CAAC;AAE5F,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD,qBACa,mBAAoB,YAAW,gBAAgB;IACxD,aAAa,SAAqB;IAGlC,SAAS,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAE7C,OAAO,CAAC,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC,IAAI,CAAC;IAOpD,SAAS,CAAC,eAAe,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,EAAE;CAGlE"}

package/lib/common/operations/cut-operation-handler.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cut-operation-handler.js","sourceRoot":"","sources":["../../../src/common/operations/cut-operation-handler.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA;;;;;;;;;;;;;;kFAckF;AAClF,qDAA4F;AAC5F,yCAA+C;AAC/C,oEAAgE;AAIzD,IAAM,mBAAmB,GAAzB,MAAM,mBAAmB;IAAzB;QACH,kBAAa,GAAG,uBAAY,CAAC,IAAI,CAAC;IAetC,CAAC;IAVG,OAAO,CAAC,SAAuB;QAC3B,MAAM,iBAAiB,GAAG,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC1D,IAAI,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE;YAC9B,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,iCAAsB,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAC,CAAC;SACpF;IACL,CAAC;IAES,eAAe,CAAC,YAA0B;QAChD,OAAO,YAAY,CAAC,aAAa,CAAC,kBAAkB,CAAC;IACzD,CAAC;CACJ,CAAA;AAbG;IAAC,IAAA,kBAAM,EAAC,oCAAgB,CAAC;;6DACoB;AAJpC,mBAAmB;IAD/B,IAAA,sBAAU,GAAE;GACA,mBAAmB,CAgB/B;AAhBY,kDAAmB"}

package/src/common/gmodel/apply-label-edit-operation-handler.spec.ts

@@ -1,40 +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 { GLabel } from '@eclipse-glsp/graph';
-import { ApplyLabelEditOperation } from '@eclipse-glsp/protocol';
-import { expect } from 'chai';
-import * as sinon from 'sinon';
-import { GModelIndex } from '../features/model/gmodel-index';
-import { DefaultModelState } from '../features/model/model-state';
-import { ApplyLabelEditOperationHandler } from './apply-label-edit-operation-handler';
-
-import assert = require('assert');
-
-describe('Test ApplyLabelEditOperationHandler', () => {
-    const label = new GLabel();
-    const modelState = new DefaultModelState();
-    Object.defineProperty(modelState, 'index', { value: new GModelIndex() });
-    sinon.stub(modelState.index, 'findByClass').returns(label);
-    const applyLabelEditOperationHandler = new ApplyLabelEditOperationHandler();
-    Object.defineProperty(applyLabelEditOperationHandler, 'modelState', { value: modelState });
-
-    it('text is changed after ApplyLabelEditOperation', async () => {
-        assert.doesNotThrow(() =>
-            applyLabelEditOperationHandler.execute(ApplyLabelEditOperation.create({ labelId: 'myId', text: 'test' }))
-        );
-        expect(label.text).to.be.equal('test');
-    });
-});