@eclipse-glsp/client 0.9.0-next.6d10f92e → 0.9.0-next.75608185

package/src/features/copy-paste/copy-paste-context-menu.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,62 +13,61 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
-import {
-    Action,
-    IActionDispatcher,
-    IActionHandler,
-    IContextMenuItemProvider,
-    isSelected,
-    MenuItem,
-    Point,
-    SModelRoot,
-    TYPES
-} from "sprotty/lib";
-
-import { GLSPServerStatusAction, ServerMessageAction } from "../../model-source/glsp-server-status";
+import { Action, GLSPServerStatusAction, Point, ServerMessageAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { IActionDispatcher, IActionHandler, IContextMenuItemProvider, isSelected, MenuItem, SModelRoot, TYPES } from 'sprotty';
 
 export class InvokeCopyAction implements Action {
-    static readonly KIND = "invoke-copy";
-    constructor(public readonly kind = InvokeCopyAction.KIND) { }
+    static readonly KIND = 'invoke-copy';
+    constructor(public readonly kind = InvokeCopyAction.KIND) {}
 }
 
 export class InvokePasteAction implements Action {
-    static readonly KIND = "invoke-paste";
-    constructor(public readonly kind = InvokePasteAction.KIND) { }
+    static readonly KIND = 'invoke-paste';
+    constructor(public readonly kind = InvokePasteAction.KIND) {}
 }
 
 export class InvokeCutAction implements Action {
-    static readonly KIND = "invoke-cut";
-    constructor(public readonly kind = InvokeCutAction.KIND) { }
+    static readonly KIND = 'invoke-cut';
+    constructor(public readonly kind = InvokeCutAction.KIND) {}
 }
 
 @injectable()
 export class InvokeCopyPasteActionHandler implements IActionHandler {
     @inject(TYPES.IActionDispatcher) protected dispatcher: IActionDispatcher;
-    handle(action: Action) {
+    handle(action: Action): void {
         switch (action.kind) {
             case InvokeCopyAction.KIND:
-                document.execCommand('copy');
+                if (supportsCopy()) {
+                    document.execCommand('copy');
+                } else {
+                    this.notifyUserToUseShortcut('copy');
+                }
                 break;
             case InvokePasteAction.KIND:
-                // in a browser without additional permission we can't invoke the paste command
-                // the user needs to invoke it from the browser, so notify the user about it
-                this.notifyUserToUseShortcut();
+                if (supportsPaste()) {
+                    document.execCommand('paste');
+                } else {
+                    this.notifyUserToUseShortcut('paste');
+                }
                 break;
             case InvokeCutAction.KIND:
-                document.execCommand('cut');
+                if (supportsCut()) {
+                    document.execCommand('cut');
+                } else {
+                    this.notifyUserToUseShortcut('cut');
+                }
                 break;
         }
     }
 
-    protected notifyUserToUseShortcut() {
-        const message = 'Please use the browser\'s paste command or shortcut.';
+    protected notifyUserToUseShortcut(operation: string): void {
+        const message = `Please use the browser's ${operation} command or shortcut.`;
         const timeout = 10000;
         const severity = 'WARNING';
         this.dispatcher.dispatchAll([
-            <GLSPServerStatusAction>{ kind: GLSPServerStatusAction.KIND, severity, timeout, message },
-            <ServerMessageAction>{ kind: ServerMessageAction.KIND, severity, timeout, message }
+            { kind: GLSPServerStatusAction.KIND, severity, timeout, message } as GLSPServerStatusAction,
+            { kind: ServerMessageAction.KIND, severity, timeout, message } as ServerMessageAction
         ]);
     }
 }
@@ -86,22 +85,52 @@ export class CopyPasteContextMenuItemProvider implements IContextMenuItemProvide
 
     protected createPasteMenuItem(): MenuItem {
         return {
-            id: "paste", label: "Paste", group: "copy-paste",
-            actions: [new InvokePasteAction()], isEnabled: () => true
+            id: 'paste',
+            label: 'Paste',
+            group: 'copy-paste',
+            actions: [new InvokePasteAction()],
+            isEnabled: () => true
         };
     }
 
     protected createCutMenuItem(hasSelectedElements: boolean): MenuItem {
         return {
-            id: "cut", label: "Cut", group: "copy-paste",
-            actions: [new InvokeCutAction()], isEnabled: () => hasSelectedElements
+            id: 'cut',
+            label: 'Cut',
+            group: 'copy-paste',
+            actions: [new InvokeCutAction()],
+            isEnabled: () => hasSelectedElements
         };
     }
 
     protected createCopyMenuItem(hasSelectedElements: boolean): MenuItem {
         return {
-            id: "copy", label: "Copy", group: "copy-paste",
-            actions: [new InvokeCopyAction()], isEnabled: () => hasSelectedElements
+            id: 'copy',
+            label: 'Copy',
+            group: 'copy-paste',
+            actions: [new InvokeCopyAction()],
+            isEnabled: () => hasSelectedElements
         };
     }
 }
+
+export function supportsCopy(): boolean {
+    return isNative() || document.queryCommandSupported('copy');
+}
+
+export function supportsCut(): boolean {
+    return isNative() || document.queryCommandSupported('cut');
+}
+
+export function supportsPaste(): boolean {
+    const isChrome = userAgent().indexOf('Chrome') >= 0;
+    return isNative() || (!isChrome && document.queryCommandSupported('paste'));
+}
+
+export function isNative(): boolean {
+    return typeof (window as any).process !== 'undefined';
+}
+
+function userAgent(): string {
+    return typeof navigator !== 'undefined' ? navigator.userAgent : '';
+}

package/src/features/copy-paste/copy-paste-handler.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,14 +13,13 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
-import { TYPES, ViewerOptions } from "sprotty";
-import { v4 as uuid } from "uuid";
-
-import { GLSPActionDispatcher } from "../../base/action-dispatcher";
-import { EditorContextService } from "../../base/editor-context";
-import { GLSP_TYPES } from "../../base/types";
-import { ClipboardData, CutOperation, PasteOperation, RequestClipboardDataAction } from "./copy-paste-actions";
+import { ClipboardData, CutOperation, PasteOperation, RequestClipboardDataAction, SetClipboardDataAction } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
+import { TYPES, ViewerOptions } from 'sprotty';
+import { v4 as uuid } from 'uuid';
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
+import { EditorContextService } from '../../base/editor-context-service';
+import { GLSP_TYPES } from '../../base/types';
 
 export interface ICopyPasteHandler {
     handleCopy(event: ClipboardEvent): void;
@@ -55,12 +54,12 @@ export class LocalClipboardService implements IAsyncClipboardService {
     protected currentId?: string;
     protected data?: ClipboardData;
 
-    clear() {
+    clear(): void {
         this.currentId = undefined;
         this.data = undefined;
     }
 
-    put(data: ClipboardData, id: string) {
+    put(data: ClipboardData, id: string): void {
         this.currentId = id;
         this.data = data;
     }
@@ -91,26 +90,27 @@ function getClipboardIdFromDataTransfer(dataTransfer: DataTransfer): string | un
     return isClipboardId(jsonObject) ? jsonObject.clipboardId : undefined;
 }
 
-const CLIPBOARD_DATA_FORMAT = "application/json";
+const CLIPBOARD_DATA_FORMAT = 'text/plain';
 
 @injectable()
 export class ServerCopyPasteHandler implements ICopyPasteHandler {
-
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
     @inject(TYPES.ViewerOptions) protected viewerOptions: ViewerOptions;
     @inject(GLSP_TYPES.IAsyncClipboardService) protected clipboadService: IAsyncClipboardService;
     @inject(EditorContextService) protected editorContext: EditorContextService;
 
-    handleCopy(event: ClipboardEvent) {
+    handleCopy(event: ClipboardEvent): void {
         if (event.clipboardData && this.shouldCopy(event)) {
             const clipboardId = uuid();
             event.clipboardData.setData(CLIPBOARD_DATA_FORMAT, toClipboardId(clipboardId));
             this.actionDispatcher
-                .request(RequestClipboardDataAction.create(this.editorContext.get()))
+                .request<SetClipboardDataAction>(RequestClipboardDataAction.create(this.editorContext.get()))
                 .then(action => this.clipboadService.put(action.clipboardData, clipboardId));
             event.preventDefault();
         } else {
-            if (event.clipboardData) { event.clipboardData.clearData(); }
+            if (event.clipboardData) {
+                event.clipboardData.clearData();
+            }
             this.clipboadService.clear();
         }
     }
@@ -124,7 +124,7 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
     }
 
     handlePaste(event: ClipboardEvent): void {
-        if (event.clipboardData) {
+        if (event.clipboardData && this.shouldPaste(event)) {
             const clipboardId = getClipboardIdFromDataTransfer(event.clipboardData);
             const clipboardData = this.clipboadService.get(clipboardId);
             if (clipboardData) {
@@ -134,9 +134,19 @@ export class ServerCopyPasteHandler implements ICopyPasteHandler {
         }
     }
 
-    protected shouldCopy(_event: ClipboardEvent) {
-        return this.editorContext.get().selectedElementIds.length > 0 && document.activeElement instanceof SVGElement
-            && document.activeElement.parentElement && document.activeElement.parentElement.id === this.viewerOptions.baseDiv;
+    protected shouldCopy(_event: ClipboardEvent): boolean | null {
+        return this.editorContext.get().selectedElementIds.length > 0 && this.isDiagramActive();
     }
 
+    protected shouldPaste(_event: ClipboardEvent): boolean | null {
+        return this.isDiagramActive();
+    }
+
+    private isDiagramActive(): boolean | null {
+        return (
+            document.activeElement instanceof SVGElement &&
+            document.activeElement.parentElement &&
+            document.activeElement.parentElement.id === this.viewerOptions.baseDiv
+        );
+    }
 }

package/src/features/copy-paste/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,18 +13,17 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from "inversify";
-import { configureActionHandler } from "sprotty/lib";
-
-import { GLSP_TYPES } from "../../base/types";
+import { ContainerModule } from 'inversify';
+import { configureActionHandler } from 'sprotty';
+import { GLSP_TYPES } from '../../base/types';
 import {
     CopyPasteContextMenuItemProvider,
     InvokeCopyAction,
     InvokeCopyPasteActionHandler,
     InvokeCutAction,
     InvokePasteAction
-} from "./copy-paste-context-menu";
-import { LocalClipboardService, ServerCopyPasteHandler } from "./copy-paste-handler";
+} from './copy-paste-context-menu';
+import { LocalClipboardService, ServerCopyPasteHandler } from './copy-paste-handler';
 
 export const glspServerCopyPasteModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(GLSP_TYPES.ICopyPasteHandler).to(ServerCopyPasteHandler);

package/src/features/decoration/decoration-placer.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2020 EclipseSource and others.
+ * Copyright (c) 2020-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,33 +13,24 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from "inversify";
-import {
-    Decoration,
-    DecorationPlacer,
-    isSizeable,
-    ORIGIN_POINT,
-    Point,
-    SChildElement,
-    SModelElement,
-    SRoutableElement
-} from "sprotty";
+import { Point } from '@eclipse-glsp/protocol';
+import { injectable } from 'inversify';
+import { Decoration, DecorationPlacer, isSizeable, ORIGIN_POINT, SChildElement, SModelElement, SRoutableElement } from 'sprotty';
 
 @injectable()
 export class GlspDecorationPlacer extends DecorationPlacer {
-
     protected static readonly DECORATION_OFFSET: Point = { x: 12, y: 10 };
 
     protected getPosition(element: SModelElement & Decoration): Point {
         if (element instanceof SChildElement && element.parent instanceof SRoutableElement) {
             return super.getPosition(element);
         }
-        if (isSizeable(element))
+        if (isSizeable(element)) {
             return {
                 x: GlspDecorationPlacer.DECORATION_OFFSET.x * element.bounds.width,
                 y: GlspDecorationPlacer.DECORATION_OFFSET.y * element.bounds.height
             };
+        }
         return ORIGIN_POINT;
     }
-
 }

package/src/features/decoration/di.config.ts

@@ -13,16 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import "../../../css/decoration.css";
+import '../../../css/decoration.css';
 
-import { ContainerModule } from "inversify";
-import { configureModelElement, SIssueMarker, TYPES } from "sprotty";
+import { ContainerModule } from 'inversify';
+import { TYPES } from 'sprotty';
 
-import { GlspDecorationPlacer } from "./decoration-placer";
-import { GlspIssueMarkerView } from "./view";
+import { GlspDecorationPlacer } from './decoration-placer';
 
 const glspDecorationModule = new ContainerModule((bind, _unbind, isBound) => {
-    configureModelElement({ bind, isBound }, 'marker', SIssueMarker, GlspIssueMarkerView);
     bind(GlspDecorationPlacer).toSelf().inSingletonScope();
     bind(TYPES.IVNodePostprocessor).toService(GlspDecorationPlacer);
 });

package/src/features/edit-label/di.config.ts

@@ -13,12 +13,12 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from "inversify";
-import { ApplyLabelEditCommand, configureCommand, TYPES } from "sprotty";
+import { ContainerModule } from 'inversify';
+import { ApplyLabelEditCommand, configureCommand, TYPES } from 'sprotty';
 
-import { GLSP_TYPES } from "../../base/types";
-import { DirectLabelEditTool } from "./edit-label-tool";
-import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from "./edit-label-validator";
+import { GLSP_TYPES } from '../../base/types';
+import { DirectLabelEditTool } from './edit-label-tool';
+import { BalloonLabelValidationDecorator, ServerEditLabelValidator } from './edit-label-validator';
 
 const glspEditLabelModule = new ContainerModule((bind, _unbind, isBound, _rebind) => {
     bind(TYPES.IEditLabelValidator).to(ServerEditLabelValidator);

package/src/features/edit-label/edit-label-tool.ts

@@ -13,14 +13,14 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { injectable } from "inversify";
-import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from "sprotty";
+import { injectable } from 'inversify';
+import { EditLabelKeyListener, EditLabelMouseListener, KeyListener, MouseListener } from 'sprotty';
 
-import { BaseGLSPTool } from "../tools/base-glsp-tool";
+import { BaseGLSPTool } from '../tools/base-glsp-tool';
 
 @injectable()
 export class DirectLabelEditTool extends BaseGLSPTool {
-    static readonly ID = "glsp.direct-label-edit-tool";
+    static readonly ID = 'glsp.direct-label-edit-tool';
 
     protected editLabelMouseListener: MouseListener;
     protected editLabelKeyListener: KeyListener;

package/src/features/edit-label/edit-label-validator.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,7 +13,8 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { inject, injectable } from "inversify";
+import { isSetEditValidationResultAction, RequestEditValidationAction, ValidationStatus } from '@eclipse-glsp/protocol';
+import { inject, injectable } from 'inversify';
 import {
     Action,
     EditableLabel,
@@ -23,25 +24,20 @@ import {
     Severity,
     SModelElement,
     TYPES
-} from "sprotty";
+} from 'sprotty';
 
-import { GLSPActionDispatcher } from "../../base/action-dispatcher";
-import {
-    isSetEditValidationResultAction,
-    RequestEditValidationAction,
-    ValidationStatus
-} from "../../base/actions/edit-validation-actions";
+import { GLSPActionDispatcher } from '../../base/action-dispatcher';
 
 export namespace LabelEditValidation {
     export const CONTEXT_ID = 'label-edit';
 
     export function toEditLabelValidationResult(status: ValidationStatus): EditLabelValidationResult {
         const message = status.message;
-        let severity = <Severity>'ok';
+        let severity = 'ok' as Severity;
         if (ValidationStatus.isError(status)) {
-            severity = <Severity>'error';
+            severity = 'error' as Severity;
         } else if (ValidationStatus.isWarning(status)) {
-            severity = <Severity>'warning';
+            severity = 'warning' as Severity;
         }
         return { message, severity };
     }
@@ -55,7 +51,6 @@ export class ValidateLabelEditAction extends RequestEditValidationAction {
 
 @injectable()
 export class ServerEditLabelValidator implements IEditLabelValidator {
-
     @inject(TYPES.IActionDispatcher) protected actionDispatcher: GLSPActionDispatcher;
 
     validate(value: string, label: EditableLabel & SModelElement): Promise<EditLabelValidationResult> {
@@ -67,14 +62,12 @@ export class ServerEditLabelValidator implements IEditLabelValidator {
         if (isSetEditValidationResultAction(action)) {
             return LabelEditValidation.toEditLabelValidationResult(action.status);
         }
-        return { severity: <Severity>'ok' };
+        return { severity: 'ok' as Severity };
     }
-
 }
 
 @injectable()
 export class BalloonLabelValidationDecorator implements IEditLabelValidationDecorator {
-
     decorate(input: HTMLInputElement, result: EditLabelValidationResult): void {
         const containerElement = input.parentElement;
         if (!containerElement) {
@@ -86,9 +79,15 @@ export class BalloonLabelValidationDecorator implements IEditLabelValidationDeco
             containerElement.setAttribute('data-balloon-visible', 'true');
         }
         switch (result.severity) {
-            case 'ok': containerElement.classList.add('validation-ok'); break;
-            case 'warning': containerElement.classList.add('validation-warning'); break;
-            case 'error': containerElement.classList.add('validation-error'); break;
+            case 'ok':
+                containerElement.classList.add('validation-ok');
+                break;
+            case 'warning':
+                containerElement.classList.add('validation-warning');
+                break;
+            case 'error':
+                containerElement.classList.add('validation-error');
+                break;
         }
     }
 

package/src/features/hints/di.config.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,12 +13,11 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { ContainerModule } from "inversify";
-import { configureActionHandler, configureCommand } from "sprotty";
-
-import { GLSP_TYPES } from "../../base/types";
-import { SetTypeHintsAction } from "./request-type-hints-action";
-import { ApplyTypeHintsCommand, TypeHintProvider } from "./type-hints";
+import { SetTypeHintsAction } from '@eclipse-glsp/protocol';
+import { ContainerModule } from 'inversify';
+import { configureActionHandler, configureCommand } from 'sprotty';
+import { GLSP_TYPES } from '../../base/types';
+import { ApplyTypeHintsCommand, TypeHintProvider } from './type-hints';
 
 const modelHintsModule = new ContainerModule((bind, _unbind, isBound) => {
     bind(TypeHintProvider).toSelf().inSingletonScope();

package/src/features/hints/model.ts

@@ -1,5 +1,5 @@
 /********************************************************************************
- * Copyright (c) 2019 EclipseSource and others.
+ * Copyright (c) 2019-2021 EclipseSource and others.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0 which is available at
@@ -13,21 +13,22 @@
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
-import { SModelElement, SModelElementSchema, SModelExtension } from "sprotty";
+import { SModelElementSchema } from '@eclipse-glsp/protocol';
+import { SModelElement, SModelExtension } from 'sprotty';
 
-export const containerFeature = Symbol("containable");
+export const containerFeature = Symbol('containable');
 
 export interface Containable extends SModelExtension {
-    isContainableElement(input: SModelElement | SModelElementSchema | string): boolean
+    isContainableElement(input: SModelElement | SModelElementSchema | string): boolean;
 }
 
 export function isContainable(element: SModelElement): element is SModelElement & Containable {
     return element.hasFeature(containerFeature);
 }
 
-export const reparentFeature = Symbol("reparentFeature");
+export const reparentFeature = Symbol('reparentFeature');
 
-export interface Reparentable extends SModelExtension { }
+export interface Reparentable extends SModelExtension {}
 
 export function isReparentable(element: SModelElement): element is SModelElement & Reparentable {
     return element.hasFeature(reparentFeature);