Clean up codebase with regards to deprecated API

Ensure that deprecated Action & SModel API is encapsulated and do not leak into non-deprecated API by
- Migrating the examples to the new Action/SModel API
- Migrating the test cases to the new Action/SModel API
- Remove any remaining usage of deprecated Action/SModel API in the non-deprecated code base

In addition, this change restructures all files that contain deprecated Action/SModel API and moves the
deprecated definitions in a separate section on the end of the file.

This enables easy removal of the deprecated API with the 1.0.0 release.
The deprecation section at the file end can be safely removed without breaking codebase.

Author: tortmayr

examples/circlegraph/src/standalone.ts

@@ -15,9 +15,9 @@
  ********************************************************************************/
 
 import {
-    TYPES, IActionDispatcher, ElementMove, MoveAction, LocalModelSource
+    TYPES, IActionDispatcher, ElementMove, LocalModelSource
 } from 'sprotty';
-import { Bounds, Point, SEdge, SelectAction, SGraph, SNode, getBasicType } from 'sprotty-protocol';
+import { Bounds, Point, SEdge, SelectAction, SGraph, SNode, getBasicType, MoveAction } from 'sprotty-protocol';
 import createContainer from './di.config';
 
 const NODE_SIZE = 60;

examples/classdiagram/src/menu.ts

@@ -16,11 +16,11 @@
 
 import { inject, injectable } from 'inversify';
 import {
-    Anchor, DeleteElementAction, EMPTY_ROOT, GetSelectionAction, IActionDispatcher,
+    Anchor, EMPTY_ROOT, GetSelectionAction, IActionDispatcher,
     IContextMenuItemProvider, IContextMenuService, LabeledAction, MenuItem,
     RequestExportSvgAction, SelectionResult, SModelRootImpl, TYPES, ViewerOptions
 } from 'sprotty';
-import { CenterAction, FitToScreenAction, Point, SetPopupModelAction } from 'sprotty-protocol';
+import { CenterAction, DeleteElementAction, FitToScreenAction, Point, SetPopupModelAction } from 'sprotty-protocol';
 
 @injectable()
 export class ClassContextMenuService implements IContextMenuService {

examples/svg/src/standalone.ts

@@ -15,10 +15,10 @@
  ********************************************************************************/
 
 import {
-    TYPES, ShapedPreRenderedElementSchema, ForeignObjectElementSchema, SShapeElementSchema, ViewportRootElementSchema,
-    Projectable, LocalModelSource
+    TYPES, ViewportRootElementSchema, Projectable, LocalModelSource
 } from 'sprotty';
 import createContainer from './di.config';
+import { ForeignObjectElement, SShapeElement, ShapedPreRenderedElement } from 'sprotty-protocol';
 
 function loadFile(path: string): Promise<string> {
     return new Promise<string>((resolve, reject) => {
@@ -50,21 +50,21 @@ export default async function runSVG() {
                 position: { x: 200, y: 200 },
                 code: svgLogo,
                 projectionCssClasses: ['logo-projection']
-            } as ShapedPreRenderedElementSchema & Projectable,
+            } as ShapedPreRenderedElement & Projectable,
             {
                 type: 'pre-rendered',
                 id: 'tiger',
                 position: { x: 400, y: 50 },
                 code: tiger,
                 projectionCssClasses: ['tiger-projection']
-            } as ShapedPreRenderedElementSchema & Projectable,
+            } as ShapedPreRenderedElement & Projectable,
             {
                 type: 'foreign-object',
                 id: 'direct-html',
                 position: { x: 50, y: 350 },
                 size: { height: 50, width: 190 },
                 code: '<p>This is a free-floating HTML paragraph!</p>'
-            } as ForeignObjectElementSchema,
+            } as ForeignObjectElement,
             {
                 id: 'foreign-object-in-shape',
                 type: 'node',
@@ -81,10 +81,10 @@ export default async function runSVG() {
                         type: 'child-foreign-object',
                         id: 'foreign-object-in-shape-contents',
                         code: '<div>This is <em>HTML</em> within <u>an SVG rectangle</u>!</div>'
-                    } as ForeignObjectElementSchema
+                    } as ForeignObjectElement
                 ],
                 projectionCssClasses: ['node-projection']
-            } as SShapeElementSchema & Projectable
+            } as SShapeElement & Projectable
         ]
     };
 

packages/sprotty/src/base/actions/action-dispatcher.spec.ts

@@ -18,11 +18,10 @@ import 'reflect-metadata';
 import 'mocha';
 import { expect } from "chai";
 import { Container, injectable, interfaces } from "inversify";
-import { Action, RejectAction, RequestModelAction, SetModelAction } from 'sprotty-protocol/lib/actions';
+import { Action, RedoAction, RejectAction, RequestModelAction, SetModelAction, UndoAction } from 'sprotty-protocol/lib/actions';
 import { Bounds } from 'sprotty-protocol/lib/utils/geometry';
 import { TYPES } from "../types";
 import { InitializeCanvasBoundsAction } from '../features/initialize-canvas';
-import { RedoAction, UndoAction } from "../../features/undo-redo/undo-redo";
 import { Command, CommandExecutionContext, CommandReturn, ICommand } from '../commands/command';
 import { ICommandStack } from "../commands/command-stack";
 import { ActionDispatcher } from "./action-dispatcher";

packages/sprotty/src/base/actions/action.ts

@@ -18,6 +18,23 @@ import { generateRequestId as generateRequestId2, Action as ProtocolAction} from
 import { JsonAny } from 'sprotty-protocol/lib/utils/json';
 import { hasOwnProperty } from 'sprotty-protocol/lib/utils/object';
 
+/**
+ * A list of actions with a label.
+ * Labeled actions are used to denote a group of actions in a user-interface context, e.g.,
+ * to define an entry in the command palette or in the context menu.
+ */
+export class LabeledAction {
+    constructor(readonly label: string, readonly actions: ProtocolAction[], readonly icon?: string) { }
+}
+
+export function isLabeledAction(element: unknown): element is LabeledAction {
+    return element !== undefined
+        && (<LabeledAction>element).label !== undefined
+        && (<LabeledAction>element).actions !== undefined;
+}
+
+// Compatibility deprecation layer (will be removed with the graduation 1.0.0 release)
+
 /**
  * An action describes a change to the model declaratively.
  * It is a plain data structure, and as such transferable between server and client. An action must never contain actual
@@ -93,17 +110,3 @@ export class RejectAction implements ResponseAction {
                 public readonly detail?: JsonAny) {}
 }
 
-/**
- * A list of actions with a label.
- * Labeled actions are used to denote a group of actions in a user-interface context, e.g.,
- * to define an entry in the command palette or in the context menu.
- */
-export class LabeledAction {
-    constructor(readonly label: string, readonly actions: ProtocolAction[], readonly icon?: string) { }
-}
-
-export function isLabeledAction(element: unknown): element is LabeledAction {
-    return element !== undefined
-        && (<LabeledAction>element).label !== undefined
-        && (<LabeledAction>element).actions !== undefined;
-}

packages/sprotty/src/base/commands/command-registration.spec.ts

@@ -20,17 +20,18 @@ import { expect } from "chai";
 import { Container, injectable, inject } from "inversify";
 import { TYPES } from "../types";
 import { configureCommand, CommandActionHandlerInitializer } from "./command-registration";
-import { SetModelCommand, SetModelAction } from "../features/set-model";
+import { SetModelCommand } from "../features/set-model";
 import { ActionHandlerRegistry } from "../actions/action-handler";
 import { EMPTY_ROOT } from "../model/smodel-factory";
 import { Command, CommandResult } from "./command";
+import { SetModelAction } from "sprotty-protocol";
 
 const MySymbol = Symbol('MySymbol');
 
 class MyAction {
     kind = MyCommand.KIND;
 
-    constructor(readonly value: string) {}
+    constructor(readonly value: string) { }
 }
 
 @injectable()
@@ -49,13 +50,13 @@ class MyCommand extends Command {
 }
 
 describe('CommandRegistration', () => {
-    it ('creates new instances', () => {
+    it('creates new instances', () => {
         const container = new Container();
         container.bind(TYPES.IActionHandlerInitializer).to(CommandActionHandlerInitializer).inSingletonScope();
         container.bind(ActionHandlerRegistry).toSelf().inSingletonScope();
         configureCommand(container, SetModelCommand);
         const actionHandlerRegistry = container.get<ActionHandlerRegistry>(ActionHandlerRegistry);
-        const action = new SetModelAction(EMPTY_ROOT);
+        const action = SetModelAction.create(EMPTY_ROOT);
         const handlers = actionHandlerRegistry.get(action.kind);
         expect(handlers.length).to.be.equal(1);
         const handler = handlers.pop()!;
@@ -64,13 +65,13 @@ describe('CommandRegistration', () => {
         const command1 = handler.handle(action);
         expect(command1).to.be.an.instanceOf(SetModelCommand);
         expect(command0).to.not.be.equal(command1);
-        const command2 = handler.handle(new SetModelAction({ type: 'other',  id: '0' }));
+        const command2 = handler.handle(SetModelAction.create({ type: 'other', id: '0' }));
         expect(command2).to.be.an.instanceOf(SetModelCommand);
         expect(command2).to.not.be.equal(command1);
         expect(command2).to.not.be.equal(command0);
     });
 
-    it ('injects members', () => {
+    it('injects members', () => {
         const container = new Container();
         container.bind(TYPES.IActionHandlerInitializer).to(CommandActionHandlerInitializer).inSingletonScope();
         container.bind(ActionHandlerRegistry).toSelf().inSingletonScope();

packages/sprotty/src/base/features/initialize-canvas.spec.ts

@@ -17,10 +17,10 @@
 import "reflect-metadata";
 import "mocha";
 import { expect } from "chai";
-import { Bounds, EMPTY_BOUNDS } from '../../utils/geometry';
-import { SModelRoot } from "../model/smodel";
 import { CommandExecutionContext } from '../commands/command';
 import { InitializeCanvasBoundsAction, InitializeCanvasBoundsCommand } from './initialize-canvas';
+import { SModelRootImpl } from "../model/smodel";
+import { Bounds } from "sprotty-protocol";
 
 describe('InitializeCanvasBoundsCommand', () => {
 
@@ -31,7 +31,7 @@ describe('InitializeCanvasBoundsCommand', () => {
         height: 10
     };
 
-    const root = new SModelRoot();
+    const root = new SModelRootImpl();
     const command = new InitializeCanvasBoundsCommand(InitializeCanvasBoundsAction.create(bounds));
 
     const context: CommandExecutionContext = {
@@ -45,7 +45,7 @@ describe('InitializeCanvasBoundsCommand', () => {
 
     it('execute() works as expected', () => {
         // sanity check for initial bounds values
-        expect(EMPTY_BOUNDS).deep.equals(root.canvasBounds);
+        expect(Bounds.EMPTY).deep.equals(root.canvasBounds);
         command.execute(context);
         expect(bounds).deep.equals(root.canvasBounds);
     });

packages/sprotty/src/base/features/set-model.spec.ts

@@ -19,16 +19,17 @@ import 'mocha';
 import { expect } from "chai";
 import { Container } from 'inversify';
 import { TYPES } from '../types';
-import { SModelElement, SModelElementSchema, SModelRootSchema } from "../model/smodel";
+import { SModelElementImpl } from "../model/smodel";
 import { EMPTY_ROOT } from '../model/smodel-factory';
 import { SGraphFactory } from "../../graph/sgraph-factory";
 import { CommandExecutionContext } from "../commands/command";
 import { ConsoleLogger } from "../../utils/logging";
 import { AnimationFrameSyncer } from "../animations/animation-frame-syncer";
-import { SetModelAction, SetModelCommand } from "./set-model";
+import {  SetModelCommand } from "./set-model";
 import defaultModule from "../di.config";
+import { SModelElement, SModelRoot, SetModelAction } from 'sprotty-protocol';
 
-function compare(expected: SModelElementSchema, actual: SModelElement) {
+function compare(expected: SModelElement, actual: SModelElementImpl) {
     for (const p in expected) {
         if (expected.hasOwnProperty(p)) {
             const expectedProp = (expected as any)[p];
@@ -70,14 +71,14 @@ describe('SetModelCommand', () => {
         children: []
     });
 
-    const model2: SModelRootSchema = {
+    const model2: SModelRoot = {
         id: 'model2',
         type: 'graph',
         children: []
     };
 
     // create the action
-    const mySetModelAction = new SetModelAction(model2 /* the new model */);
+    const mySetModelAction =  SetModelAction.create(model2 /* the new model */);
 
     // create the command
     const cmd = new SetModelCommand(mySetModelAction);

packages/sprotty/src/base/features/set-model.ts

@@ -26,6 +26,38 @@ import { SModelRootImpl } from "../model/smodel";
 import { TYPES } from "../types";
 import { InitializeCanvasBoundsCommand } from './initialize-canvas';
 
+@injectable()
+export class SetModelCommand extends ResetCommand {
+    static readonly KIND = ProtocolSetModelAction.KIND;
+
+    oldRoot: SModelRootImpl;
+    newRoot: SModelRootImpl;
+
+    constructor(@inject(TYPES.Action) protected readonly action: ProtocolSetModelAction) {
+        super();
+    }
+
+    execute(context: CommandExecutionContext): SModelRootImpl {
+        this.oldRoot = context.modelFactory.createRoot(context.root);
+        this.newRoot = context.modelFactory.createRoot(this.action.newRoot);
+        return this.newRoot;
+    }
+
+    undo(context: CommandExecutionContext): SModelRootImpl {
+        return this.oldRoot;
+    }
+
+    redo(context: CommandExecutionContext): SModelRootImpl {
+        return this.newRoot;
+    }
+
+    get blockUntil(): (action: Action) => boolean {
+        return action => action.kind === InitializeCanvasBoundsCommand.KIND;
+    }
+}
+
+// Compatibility deprecation layer (will be removed with the graduation 1.0.0 release)
+
 /**
  * Sent from the client to the model source (e.g. a DiagramServer) in order to request a model. Usually this
  * is the first message that is sent to the source, so it is also used to initiate the communication.
@@ -58,33 +90,3 @@ export class SetModelAction implements ResponseAction, ProtocolSetModelAction {
     constructor(public readonly newRoot: SModelRootSchema,
         public readonly responseId = '') { }
 }
-
-@injectable()
-export class SetModelCommand extends ResetCommand {
-    static readonly KIND = ProtocolSetModelAction.KIND;
-
-    oldRoot: SModelRootImpl;
-    newRoot: SModelRootImpl;
-
-    constructor(@inject(TYPES.Action) protected readonly action: ProtocolSetModelAction) {
-        super();
-    }
-
-    execute(context: CommandExecutionContext): SModelRootImpl {
-        this.oldRoot = context.modelFactory.createRoot(context.root);
-        this.newRoot = context.modelFactory.createRoot(this.action.newRoot);
-        return this.newRoot;
-    }
-
-    undo(context: CommandExecutionContext): SModelRootImpl {
-        return this.oldRoot;
-    }
-
-    redo(context: CommandExecutionContext): SModelRootImpl {
-        return this.newRoot;
-    }
-
-    get blockUntil(): (action: Action) => boolean {
-        return action => action.kind === InitializeCanvasBoundsCommand.KIND;
-    }
-}

packages/sprotty/src/base/model/smodel-factory.spec.ts

@@ -19,17 +19,18 @@ import 'mocha';
 import { expect } from "chai";
 import { Container } from 'inversify';
 import { TYPES } from '../types';
-import { SModelElementSchema, ModelIndexImpl, SChildElement } from './smodel';
+import { ModelIndexImpl, SChildElementImpl } from './smodel';
 import { SModelFactory } from "./smodel-factory";
 import { registerModelElement } from './smodel-utils';
 import { selectFeature, Selectable } from '../../features/select/model';
 import { boundsFeature } from '../../features/bounds/model';
 import defaultModule from "../di.config";
+import { SModelElement } from 'sprotty-protocol';
 
 describe('model factory', () => {
 
-    class FooElement extends SChildElement implements Selectable {
-        static readonly DEFAULT_FEATURES = [selectFeature]
+    class FooElement extends SChildElementImpl implements Selectable {
+        static readonly DEFAULT_FEATURES = [selectFeature];
         selected: boolean;
     }
 
@@ -67,7 +68,7 @@ describe('model factory', () => {
                             id: 'element3'
                         }
                     ]
-                } as SModelElementSchema
+                } as SModelElement
             ]
         });
         const element1 = root.children[0];