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

package/src/common/gmodel/delete-operation-handler.ts

@@ -0,0 +1,115 @@
+/********************************************************************************
+ * 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 { GEdge, GModelElement, GNode } from '@eclipse-glsp/graph';
+import { DeleteElementOperation, MaybePromise } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { GModelIndex } from '../features/model/gmodel-index';
+import { ModelState } from '../features/model/model-state';
+import { OperationHandler } from '../operations/operation-handler';
+import { Logger } from '../utils/logger';
+
+@injectable()
+export class GModelDeleteOperationHandler implements OperationHandler {
+    @inject(Logger)
+    protected logger: Logger;
+
+    protected allDependantsIds: Set<string>;
+
+    @inject(ModelState) protected readonly modelState: ModelState;
+
+    get operationType(): string {
+        return DeleteElementOperation.KIND;
+    }
+
+    execute(operation: DeleteElementOperation): MaybePromise<void> {
+        const elementIds = operation.elementIds;
+        if (!elementIds || elementIds.length === 0) {
+            this.logger.warn('Elements to delete are not specified');
+            return;
+        }
+        const index = this.modelState.index;
+        this.allDependantsIds = new Set<string>();
+        const success = elementIds.every(eId => this.delete(eId, index));
+        if (!success) {
+            this.logger.warn('Could not delete all elements as requested (see messages above to find out why)');
+        }
+    }
+
+    protected delete(elementId: string, index: GModelIndex): boolean {
+        if (this.allDependantsIds.has(elementId)) {
+            return true;
+        }
+
+        const element = index.find(elementId);
+        if (!element) {
+            this.logger.warn('Element not found: ' + elementId);
+            return false;
+        }
+
+        const nodeToDelete = this.findTopLevelElement(element);
+        if (!nodeToDelete.parent) {
+            this.logger.warn("The requested node doesn't have a parent; it can't be deleted");
+            return false;
+        }
+
+        const dependents = new Set<GModelElement>();
+        this.collectDependents(dependents, nodeToDelete);
+
+        dependents.forEach(dependant => {
+            const index = this.modelState.root.children.findIndex(element => element === dependant);
+            if (index > -1) {
+                this.modelState.root.children.splice(index, 1);
+            }
+            this.allDependantsIds.add(dependant.id);
+        });
+
+        return true;
+    }
+
+    protected collectDependents(dependents: Set<GModelElement>, nodeToDelete: GModelElement): void {
+        if (dependents.has(nodeToDelete)) {
+            return;
+        }
+
+        if (nodeToDelete.children.length > 0) {
+            nodeToDelete.children.forEach(child => this.collectDependents(dependents, child));
+        }
+
+        if (nodeToDelete instanceof GNode) {
+            const index = this.modelState.index;
+            index.getIncomingEdges(nodeToDelete).forEach(incoming => {
+                this.collectDependents(dependents, incoming);
+            });
+            index.getOutgoingEdges(nodeToDelete).forEach(outgoing => {
+                this.collectDependents(dependents, outgoing);
+            });
+        }
+
+        dependents.add(nodeToDelete);
+    }
+
+    protected findTopLevelElement(element: GModelElement): GModelElement {
+        if (element instanceof GNode || element instanceof GEdge) {
+            return element;
+        }
+
+        const parent = element.parent;
+        if (!parent) {
+            return element;
+        }
+        return this.findTopLevelElement(parent);
+    }
+}

package/src/common/gmodel/gmodel-create-edge-operation-handler.ts

@@ -0,0 +1,58 @@
+/********************************************************************************
+ * 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 { GEdge, GModelElement, GPort } from '@eclipse-glsp/graph';
+import { GNode } from '@eclipse-glsp/graph/lib/gnode';
+import { CreateEdgeOperation } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ModelState } from '../features/model/model-state';
+import { CreateOperationHandler } from '../operations/create-operation-handler';
+
+/**
+ * An abstract base implementation of {@link CreateEdgeOperation} handlers for diagram implementations
+ * where the graphical model is also directly used as source model.
+ * (i.e. all operation handlers directly modify the graphical model).
+ */
+@injectable()
+export abstract class GModelCreateEdgeOperationHandler extends CreateOperationHandler {
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    get operationType(): string {
+        return CreateEdgeOperation.KIND;
+    }
+
+    execute(operation: CreateEdgeOperation): void {
+        const index = this.modelState.index;
+
+        const source = index.find(operation.sourceElementId, element => element instanceof GNode || element instanceof GPort);
+        const target = index.find(operation.targetElementId, element => element instanceof GNode || element instanceof GPort);
+
+        if (!source || !target) {
+            throw new Error(
+                `Invalid source or target for source ID ${operation.sourceElementId} and target ID ${operation.targetElementId}`
+            );
+        }
+
+        const connection = this.createEdge(source, target);
+        if (connection) {
+            const currentModel = this.modelState.root;
+            currentModel.children.push(connection);
+        }
+    }
+
+    abstract createEdge(source: GModelElement, target: GModelElement): GEdge | undefined;
+}

package/src/common/gmodel/gmodel-create-node-operation-handler.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * Copyright (c) 2022-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 { GNode } from '@eclipse-glsp/graph';
+import { CreateNodeOperation, Point, SelectAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ActionDispatcher } from '../actions/action-dispatcher';
+import { CreateNodeOperationHandler } from '../operations/create-operation-handler';
+
+/**
+ * An abstract base implementation of {@link CreateNodeOperationHandler} for diagram implementations
+ * where the graphical model is also directly used as source model.
+ * (i.e. all operation handlers directly modify the graphical model).
+ */
+@injectable()
+export abstract class GModelCreateNodeOperationHandler extends CreateNodeOperationHandler {
+    @inject(ActionDispatcher)
+    protected actionDispatcher: ActionDispatcher;
+
+    abstract override elementTypeIds: string[];
+
+    execute(operation: CreateNodeOperation): void {
+        const container = this.getContainer(operation) ?? this.modelState.root;
+        const relativeLocation = this.getRelativeLocation(operation);
+        const element = this.createNode(operation, relativeLocation);
+        if (element) {
+            container.children.push(element);
+            element.parent = container;
+            this.actionDispatcher.dispatchAfterNextUpdate(SelectAction.create({ selectedElementsIDs: [element.id] }));
+        }
+    }
+
+    abstract createNode(operation: CreateNodeOperation, relativeLocation?: Point): GNode | undefined;
+}

package/src/common/gmodel/gmodel-diagram-module.ts

@@ -0,0 +1,81 @@
+/********************************************************************************
+ * 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 { injectable } from 'inversify';
+import { ActionHandlerConstructor } from '../actions/action-handler';
+import { BindingTarget } from '../di/binding-target';
+import { DiagramModule } from '../di/diagram-module';
+import { InstanceMultiBinding } from '../di/multi-binding';
+import { RequestClipboardDataActionHandler } from '../features/clipboard/request-clipboard-data-action-handler';
+import { LayoutOperationHandler } from '../features/layout/layout-operation-handler';
+import { GModelFactory, GModelFactoryNullImpl } from '../features/model/gmodel-factory';
+import { DefaultModelState, ModelState } from '../features/model/model-state';
+import { SaveModelActionHandler } from '../features/model/save-model-action-handler';
+import { CutOperationHandler } from '../operations/cut-operation-handler';
+import { OperationHandlerConstructor } from '../operations/operation-handler';
+import { ApplyLabelEditOperationHandler } from './apply-label-edit-operation-handler';
+import { ChangeBoundsOperationHandler } from './change-bounds-operation-handler';
+import { ChangeRoutingPointsOperationHandler } from './change-routing-points-operation-handler';
+import { ComputedBoundsActionHandler } from './computed-bounds-action-handler';
+import { GModelDeleteOperationHandler } from './delete-operation-handler';
+import { PasteOperationHandler } from './paste-operation-handler';
+import { ReconnectEdgeOperationHandler } from './reconnect-edge-operation-handler';
+
+/**
+ * Extension of the {@link DiagramModule} to provide GModel integration.
+ *
+ * Contains all bindings of {@link DiagramModule}.
+ *
+ * Additionally binds:
+ * - {@link CommandStack} to {@link DefaultCommandStack}
+ * - {@link ModelState} to {@link ModelState}
+ * - {@link GModelFactory} to {@link GModelFactoryNullImpl}
+ * - {@link GModelIndex} to self
+ * - {@link ComputedBoundsActionHandler} to {@link ActionHandler}
+ * - {@link RequestClipboardDataActionHandler} to {@link ActionHandler}
+ * - {@link ApplyLabelEditOperationHandler} to {@link OperationHandler}
+ * - {@link ChangeBoundsOperationHandler} to {@link OperationHandler}
+ * - {@link CutOperationHandler} to {@link OperationHandler}
+ * - {@link PasteOperationHandler} to {@link OperationHandler}
+ */
+@injectable()
+export abstract class GModelDiagramModule extends DiagramModule {
+    protected override bindGModelFactory(): BindingTarget<GModelFactory> {
+        return GModelFactoryNullImpl;
+    }
+
+    protected bindModelState(): BindingTarget<ModelState> {
+        return DefaultModelState;
+    }
+
+    protected override configureActionHandlers(binding: InstanceMultiBinding<ActionHandlerConstructor>): void {
+        super.configureActionHandlers(binding);
+        binding.add(ComputedBoundsActionHandler);
+        binding.add(SaveModelActionHandler);
+        binding.add(RequestClipboardDataActionHandler);
+    }
+
+    protected override configureOperationHandlers(binding: InstanceMultiBinding<OperationHandlerConstructor>): void {
+        super.configureOperationHandlers(binding);
+        binding.add(ApplyLabelEditOperationHandler);
+        binding.add(ChangeBoundsOperationHandler);
+        binding.add(CutOperationHandler);
+        binding.add(GModelDeleteOperationHandler);
+        binding.add(PasteOperationHandler);
+        binding.add(ReconnectEdgeOperationHandler);
+        binding.add(LayoutOperationHandler);
+        binding.add(ChangeRoutingPointsOperationHandler);
+    }
+}

package/src/common/gmodel/index.ts

@@ -0,0 +1,26 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+export * from './apply-label-edit-operation-handler';
+export * from './change-bounds-operation-handler';
+export * from './change-routing-points-operation-handler';
+export * from './computed-bounds-action-handler';
+export * from './delete-operation-handler';
+export * from './gmodel-create-edge-operation-handler';
+export * from './gmodel-create-node-operation-handler';
+export * from './gmodel-diagram-module';
+export * from './paste-operation-handler';
+export * from './reconnect-edge-operation-handler';

package/src/common/gmodel/paste-operation-handler.ts

@@ -0,0 +1,119 @@
+/********************************************************************************
+ * 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 { GBoundsAware, GEdge, GModelElement, isGBoundsAware } from '@eclipse-glsp/graph';
+import { MaybePromise, PasteOperation, Point, SModelElementSchema } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import * as uuid from 'uuid';
+import { GModelSerializer } from '../features/model/gmodel-serializer';
+import { ModelState } from '../features/model/model-state';
+import { OperationHandler } from '../operations/operation-handler';
+
+@injectable()
+export class PasteOperationHandler implements OperationHandler {
+    operationType = PasteOperation.KIND;
+
+    protected readonly DEFAULT_OFFSET = 20;
+
+    @inject(ModelState)
+    protected modelState: ModelState;
+
+    @inject(GModelSerializer)
+    protected modelSerializer: GModelSerializer;
+
+    execute(operation: PasteOperation): MaybePromise<void> {
+        const schemas: SModelElementSchema[] = JSON.parse(operation.clipboardData['application/json']);
+        const elements = schemas.map(schema => this.modelSerializer.createElement(schema, this.modelState.root));
+        shift(elements, this.computeOffset(elements, operation.editorContext.lastMousePosition));
+        const idMap = this.reassignIds(elements);
+        this.filterElements(elements, idMap);
+        this.rewireEdges(elements, idMap);
+
+        this.modelState.root.children.push(...elements);
+    }
+
+    protected computeOffset(elements: GModelElement[], lastMousePosition?: Point): Point {
+        const offset = { x: this.DEFAULT_OFFSET, y: this.DEFAULT_OFFSET };
+        if (lastMousePosition) {
+            const referenceElement = this.getReferenceElementForPasteOffset(elements);
+            if (referenceElement) {
+                const position = referenceElement.position ?? Point.ORIGIN;
+                offset.x = lastMousePosition.x - position.x;
+                offset.y = lastMousePosition.y - position.y;
+            }
+        }
+        return offset;
+    }
+
+    protected getReferenceElementForPasteOffset(elements: GModelElement[]): GBoundsAware | undefined {
+        let minY = Number.MAX_VALUE;
+        for (const element of elements) {
+            if (isGBoundsAware(element)) {
+                const position = element.position ?? Point.ORIGIN;
+                if (minY > position.y) {
+                    minY = position.y;
+                    return element;
+                }
+            }
+        }
+        return undefined;
+    }
+
+    protected reassignIds(elements: GModelElement[]): Map<string, string> {
+        const idMap = new Map<string, string>();
+        elements.forEach(element => {
+            const newId = uuid.v4();
+            idMap.set(element.id, newId);
+            element.id = newId;
+            const childMap = this.reassignIds(element.children);
+            childMap.forEach((value, key) => {
+                idMap.set(key, value);
+            });
+        });
+        return idMap;
+    }
+
+    protected filterElements(elements: GModelElement[], idMap: Map<string, string>): void {
+        elements.filter(e => !this.shouldExcludeElement(e, idMap));
+    }
+
+    protected shouldExcludeElement(element: GModelElement, idMap: Map<string, string>): boolean {
+        return false;
+    }
+
+    protected rewireEdges(elements: GModelElement[], idMap: Map<string, string>): void {
+        const edges = elements.filter(element => element instanceof GEdge) as GEdge[];
+        edges.forEach(edge => {
+            const sourceId = idMap.get(edge.sourceId);
+            if (sourceId) {
+                edge.sourceId = sourceId;
+            }
+            const targetId = idMap.get(edge.targetId);
+            if (targetId) {
+                edge.targetId = targetId;
+            }
+        });
+    }
+}
+
+export function shift(elements: GModelElement[], offset: Point): void {
+    elements
+        .filter(element => isGBoundsAware(element))
+        .map(element => element as unknown as GBoundsAware)
+        .forEach(gBoundsAware => {
+            const position = gBoundsAware.position ?? Point.ORIGIN;
+            gBoundsAware.position = { x: position.x + offset.x, y: position.y + offset.y };
+        });
+}

package/src/common/gmodel/reconnect-edge-operation-handler.ts

@@ -0,0 +1,55 @@
+/********************************************************************************
+ * 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 { GEdge, GNode, GPort } from '@eclipse-glsp/graph';
+import { MaybePromise, ReconnectEdgeOperation } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { ModelState } from '../features/model/model-state';
+import { OperationHandler } from '../operations/operation-handler';
+import { GLSPServerError } from '../utils/glsp-server-error';
+
+@injectable()
+export class ReconnectEdgeOperationHandler implements OperationHandler {
+    operationType = ReconnectEdgeOperation.KIND;
+
+    @inject(ModelState)
+    protected readonly modelState: ModelState;
+
+    execute(operation: ReconnectEdgeOperation): MaybePromise<void> {
+        if (!operation.edgeElementId || !operation.sourceElementId || !operation.targetElementId) {
+            throw new GLSPServerError('Incomplete reconnect connection action');
+        }
+
+        const index = this.modelState.index;
+
+        const edge = index.findByClass(operation.edgeElementId, GEdge);
+        const source = index.findByClass(operation.sourceElementId, GNode || GPort);
+        const target = index.findByClass(operation.targetElementId, GNode || GPort);
+
+        if (!edge) {
+            throw new Error(`Invalid edge: edge ID ${operation.edgeElementId}`);
+        }
+        if (!source) {
+            throw new Error(`Invalid source: source ID ${operation.sourceElementId}`);
+        }
+        if (!target) {
+            throw new Error(`Invalid target: target ID ${operation.targetElementId}`);
+        }
+
+        edge.sourceId = source.id;
+        edge.targetId = target.id;
+        edge.routingPoints = [];
+    }
+}

package/src/common/index.ts

@@ -0,0 +1,88 @@
+/********************************************************************************
+ * 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
+ ********************************************************************************/
+
+export * from '@eclipse-glsp/graph';
+export * from '@eclipse-glsp/protocol';
+export * from './actions/action-dispatcher';
+export * from './actions/action-handler';
+export * from './actions/action-handler-registry';
+export * from './actions/client-action-handler';
+export * from './actions/global-action-provider';
+export * from './command/command';
+export * from './command/command-stack';
+export * from './di/binding-target';
+export * from './di/client-session-module';
+export * from './di/diagram-module';
+export * from './di/glsp-module';
+export * from './di/multi-binding';
+export * from './di/server-module';
+export * from './di/service-identifiers';
+export * from './diagram/diagram-configuration';
+export * from './diagram/request-type-hints-action-handler';
+export * from './features/clipboard/request-clipboard-data-action-handler';
+export * from './features/contextactions/command-palette-action-provider';
+export * from './features/contextactions/context-actions-provider';
+export * from './features/contextactions/context-actions-provider-registry';
+export * from './features/contextactions/context-menu-item-provider';
+export * from './features/contextactions/request-context-actions-handler';
+export * from './features/contextactions/tool-palette-item-provider';
+export * from './features/directediting/context-edit-validator';
+export * from './features/directediting/context-edit-validator-registry';
+export * from './features/directediting/label-edit-validator';
+export * from './features/directediting/request-edit-validation-handler';
+export * from './features/layout/layout-engine';
+export * from './features/layout/layout-operation-handler';
+export * from './features/model/gmodel-factory';
+export * from './features/model/gmodel-index';
+export * from './features/model/gmodel-serializer';
+export * from './features/model/model-state';
+export * from './features/model/model-submission-handler';
+export * from './features/model/request-model-action-handler';
+export * from './features/model/save-model-action-handler';
+export * from './features/model/source-model-storage';
+export * from './features/navigation/json-opener-options';
+export * from './features/navigation/navigation-target-provider';
+export * from './features/navigation/navigation-target-provider-registry';
+export * from './features/navigation/navigation-target-resolution';
+export * from './features/navigation/navigation-target-resolver';
+export * from './features/navigation/request-navigation-targets-action-handler';
+export * from './features/navigation/resolve-navigation-targets-action-handler';
+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/index';
+export * from './launch/glsp-server-launcher';
+export * from './operations/compound-operation-handler';
+export * from './operations/create-operation-handler';
+export * from './operations/cut-operation-handler';
+export * from './operations/operation-action-handler';
+export * from './operations/operation-handler';
+export * from './operations/operation-handler-registry';
+export * from './protocol/glsp-client-proxy';
+export * from './protocol/glsp-server';
+export * from './protocol/glsp-server-listener';
+export * from './session/client-session';
+export * from './session/client-session-factory';
+export * from './session/client-session-initializer';
+export * from './session/client-session-listener';
+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/logger';
+export * from './utils/promise-queue';
+export * from './utils/registry';

package/src/common/launch/glsp-server-launcher.ts

@@ -0,0 +1,70 @@
+/********************************************************************************
+ * 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 { MaybePromise } from '@eclipse-glsp/protocol';
+import { Container, ContainerModule, inject, injectable, optional } from 'inversify';
+import { ServerModule } from '../di/server-module';
+import { InjectionContainer } from '../di/service-identifiers';
+import { Logger } from '../utils/logger';
+
+export const START_UP_COMPLETE_MSG = '[GLSP-Server]:Startup completed';
+
+@injectable()
+export abstract class GLSPServerLauncher<T = undefined> {
+    @inject(Logger) protected logger: Logger;
+
+    protected _modules: ContainerModule[] = [];
+    protected running: boolean;
+
+    @inject(InjectionContainer) @optional() protected parentContainer?: Container;
+
+    configure(serverModule: ServerModule, ...additionalModules: ContainerModule[]): void {
+        this._modules.push(serverModule, ...additionalModules);
+    }
+
+    createContainer(): Container {
+        const container = this.parentContainer ? this.parentContainer.createChild() : new Container();
+        container.load(...this._modules);
+        return container;
+    }
+
+    start(startParams?: T): MaybePromise<void> {
+        if (!this.running) {
+            this.running = true;
+            return this.run(startParams);
+        }
+        this.logger.warn('Could not start launcher. Launcher is already running!');
+    }
+
+    protected abstract run(startParams?: T): MaybePromise<void>;
+
+    shutdown(): MaybePromise<void> {
+        if (this.running) {
+            const result = this.stop();
+            this.running = false;
+            return result;
+        }
+        this.logger.warn('Could not stop launcher. Launcher is not running!');
+    }
+
+    protected abstract stop(): MaybePromise<void>;
+
+    get modules(): ContainerModule[] {
+        if (!this._modules) {
+            throw new Error('The GLSPServerLauncher has not been configured yet');
+        }
+        return this._modules;
+    }
+}