@eclipse-glsp/graph 0.9.0-next.397cddd.4

package/src/gcompartment.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { Args, DefaultTypes, JsonPrimitive } from '@eclipse-glsp/protocol';
+import { GLayoutContainer, GLayoutContainerBuilder } from './glayout-container';
+import { GLayoutable, GLayoutableBuilder } from './glayoutable';
+import { GShapeElement, GShapeElementBuilder } from './gshape-element';
+
+export class GCompartment extends GShapeElement implements GLayoutContainer, GLayoutable {
+    static builder(): GCompartmentBuilder {
+        return new GCompartmentBuilder(GCompartment).type(DefaultTypes.COMPARTMENT);
+    }
+
+    type = DefaultTypes.COMPARTMENT;
+    layout?: string;
+    layoutOptions?: Args;
+    [GLayoutContainer] = true;
+    [GLayoutable] = true;
+}
+
+export class GCompartmentBuilder<G extends GCompartment = GCompartment> extends GShapeElementBuilder<G> {
+    layout(layout?: string): this {
+        return GLayoutContainerBuilder.layout(this, layout);
+    }
+
+    addLayoutOption(key: string, value: JsonPrimitive): this {
+        return GLayoutableBuilder.addLayoutOption(this, key, value);
+    }
+
+    addLayoutOptions(layoutOptions: Args): this;
+    addLayoutOptions(layoutOptions: Map<string, JsonPrimitive>): this;
+    addLayoutOptions(layoutOptions: Args | Map<string, JsonPrimitive>): this {
+        return GLayoutableBuilder.addLayoutOptions(this, layoutOptions);
+    }
+}

package/src/gedge-layoutable.ts

@@ -0,0 +1,45 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { GModelElement, GModelElementBuilder } from './gmodel-element';
+
+export type EdgeSide = 'left' | 'right' | 'top' | 'bottom' | 'on';
+
+export class EdgePlacement extends Object {
+    rotate: boolean;
+    side: EdgeSide;
+    position: number;
+    offset: number;
+}
+
+export const GEdgeLayoutable = Symbol('GEdgeLayoutable');
+
+export interface GEdgeLayoutable {
+    edgePlacement?: EdgePlacement;
+    [GEdgeLayoutable]: boolean;
+}
+
+export function isGEdgeLayoutable<G extends GModelElement>(element: G): element is G & GEdgeLayoutable {
+    return ((element as any)[GEdgeLayoutable] = true);
+}
+
+export type GEdgeLayoutableBuilder<G extends GModelElement = GModelElement> = GModelElementBuilder<G & GEdgeLayoutable>;
+
+export namespace GEdgeLayoutableBuilder {
+    export function edgePlacement<B extends GEdgeLayoutableBuilder>(builder: B, placement?: EdgePlacement): B {
+        builder['proxy'].edgePlacement = placement;
+        return builder;
+    }
+}

package/src/gedge.ts

@@ -0,0 +1,100 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { DefaultTypes, flatPush, MaybeArray, Point } from '@eclipse-glsp/protocol';
+import { GModelElement, GModelElementBuilder } from './gmodel-element';
+
+export class GEdge extends GModelElement {
+    static builder(): GEdgeBuilder {
+        return new GEdgeBuilder(GEdge).type(DefaultTypes.EDGE);
+    }
+
+    type = DefaultTypes.EDGE;
+    routingPoints: Point[] = [];
+    sourceId: string;
+    targetId: string;
+    routerKind?: string;
+    private _source: GModelElement;
+    private _target: GModelElement;
+
+    get source(): GModelElement {
+        return this._source;
+    }
+
+    set source(value: GModelElement) {
+        this._source = value;
+        this.sourceId = value.id;
+    }
+
+    get target(): GModelElement {
+        return this._target;
+    }
+
+    set target(value: GModelElement) {
+        this._target = value;
+        this.targetId = value.id;
+    }
+}
+
+export namespace GEdge {
+    export function is(object: unknown): object is GEdge {
+        return GEdge.is(object);
+    }
+}
+
+export class GEdgeBuilder<G extends GEdge = GEdge> extends GModelElementBuilder<G> {
+    source(source: GModelElement): this {
+        this.proxy.source = source;
+        return this;
+    }
+
+    sourceId(sourceId: string): this {
+        this.proxy.sourceId = sourceId;
+        return this;
+    }
+
+    target(target: GModelElement): this {
+        this.proxy.target = target;
+        return this;
+    }
+
+    targetId(targetId: string): this {
+        this.proxy.targetId = targetId;
+        return this;
+    }
+
+    routerKind(routerKind: string): this {
+        this.proxy.routerKind = routerKind;
+        return this;
+    }
+
+    addRoutingPoint(x: number, y: number): this;
+    addRoutingPoint(point: Point): this;
+    addRoutingPoint(xOrPoint: Point | number, y?: number): this {
+        if (typeof xOrPoint === 'object') {
+            this.proxy.routingPoints.push(xOrPoint);
+        } else if (y) {
+            this.proxy.routingPoints.push({ x: xOrPoint, y });
+        }
+        return this;
+    }
+
+    addRoutingPoints(routingPoints: Point[]): this;
+    addRoutingPoints(...routingPoints: Point[]): this;
+    addRoutingPoints(...routingPoints: MaybeArray<Point>[]): this {
+        flatPush(this.proxy.routingPoints, routingPoints);
+        return this;
+    }
+}

package/src/ggraph.ts

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * Copyright (c) 2022 StMicroelectronics.
+ *
+ * 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
+ ********************************************************************************/
+/**
+ * TS implementation of the GLSP graph definition
+ * (https://github.com/eclipse-glsp/glsp-server/tree/master/plugins/org.eclipse.glsp.graph/src-gen/org/eclipse/glsp/graph)
+ * Parts of the implementation is derived from Sprotty's SModel API
+ * (https://github.com/eclipse/sprotty/blob/master/packages/sprotty/src/base/model/smodel.ts)
+ */
+import { DefaultTypes as types, Dimension, ORIGIN_POINT, Point } from '@eclipse-glsp/protocol';
+import { GBoundsAware, GBoundsAwareBuilder } from './gbound-aware';
+import { GModelRoot, GModelRootBuilder } from './gmodel-element';
+
+export class GGraph extends GModelRoot implements GBoundsAware {
+    static builder(): GGraphBuilder {
+        return new GGraphBuilder(GGraph);
+    }
+
+    type = types.GRAPH;
+    position: Point = ORIGIN_POINT;
+    size?: Dimension;
+    [GBoundsAware] = true;
+}
+
+export class GGraphBuilder<G extends GGraph = GGraph> extends GModelRootBuilder<G> {
+    position(x: number, y: number): this;
+    position(position: Point): this;
+    position(positionOrX: Point | number, y?: number): this {
+        return GBoundsAwareBuilder.position(this, positionOrX, y);
+    }
+
+    size(width: number, height: number): this;
+    size(size: Dimension): this;
+    size(sizeOrWidth: Dimension | number, height?: number): this {
+        return GBoundsAwareBuilder.size(this, sizeOrWidth, height);
+    }
+}

package/src/gissue-marker.ts

@@ -0,0 +1,49 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { DefaultTypes, flatPush, MaybeArray } from '@eclipse-glsp/protocol';
+import { GShapeElement, GShapeElementBuilder } from './gshape-element';
+
+export type GIssueSeverity = 'error' | 'warning' | 'info';
+
+export class GIssue {
+    message: string;
+    severity: GIssueSeverity;
+}
+
+export class GIssueMarker extends GShapeElement {
+    type = DefaultTypes.ISSUE_MARKER;
+    issues: GIssue[] = [];
+}
+
+export class GIssueMarkerBuilder<G extends GIssueMarker = GIssueMarker> extends GShapeElementBuilder<G> {
+    addIssue(issue: GIssue): this;
+    addIssue(message: string, severity: GIssueSeverity): this;
+    addIssue(issueOrMessage: GIssue | string, severity?: GIssueSeverity): this {
+        if (typeof issueOrMessage === 'object') {
+            this.proxy.issues.push(issueOrMessage);
+        } else if (severity) {
+            this.proxy.issues.push({ message: issueOrMessage, severity });
+        }
+        return this;
+    }
+
+    addIssues(issues: GIssue[]): this;
+    addIssues(...issues: GIssue[]): this;
+    addIssues(...issues: MaybeArray<GIssue>[]): this {
+        flatPush(this.proxy.issues, issues);
+        return this;
+    }
+}

package/src/glabel.ts

@@ -0,0 +1,50 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { DefaultTypes, ORIGIN_POINT, Point } from '@eclipse-glsp/protocol';
+import { GAlignable, GAlignableBuilder } from './galignable';
+import { EdgePlacement, GEdgeLayoutable, GEdgeLayoutableBuilder } from './gedge-layoutable';
+import { GModelElementConstructor } from './gmodel-element';
+import { GShapeElement, GShapeElementBuilder } from './gshape-element';
+
+export class GLabel extends GShapeElement implements GAlignable, GEdgeLayoutable {
+    static builder<G extends GLabel = GLabel>(constructor?: GModelElementConstructor<G>): GLabelBuilder {
+        return new GLabelBuilder(constructor ?? GLabel).type(DefaultTypes.LABEL);
+    }
+
+    type = DefaultTypes.LABEL;
+    text: string;
+    alignment: Point = ORIGIN_POINT;
+    edgePlacement?: EdgePlacement;
+    [GAlignable] = true;
+    [GEdgeLayoutable] = true;
+}
+
+export class GLabelBuilder<G extends GLabel = GLabel> extends GShapeElementBuilder<G> {
+    alignment(x: number, y: number): this;
+    alignment(alignment: Point): this;
+    alignment(xOrAlign: number | Point, y?: number): this {
+        return GAlignableBuilder.alignment(this, xOrAlign, y);
+    }
+
+    text(text: string): this {
+        this.proxy.text = text;
+        return this;
+    }
+
+    edgePlacement(placement: EdgePlacement): this {
+        return GEdgeLayoutableBuilder.edgePlacement(this, placement);
+    }
+}

package/src/glayout-container.ts

@@ -0,0 +1,36 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { GModelElement, GModelElementBuilder } from './gmodel-element';
+
+export const GLayoutContainer = Symbol('GLayoutContainer');
+
+export interface GLayoutContainer {
+    layout?: string;
+    [GLayoutContainer]: boolean;
+}
+
+export function isGLayoutContainer<G extends GModelElement>(element: G): element is G & GLayoutContainer {
+    return ((element as any)[GLayoutContainer] = true);
+}
+
+export type GLayoutContainerBuilder = GModelElementBuilder<GModelElement & GLayoutContainer>;
+
+export namespace GLayoutContainerBuilder {
+    export function layout<B extends GLayoutContainerBuilder>(builder: B, newLayout?: string): B {
+        builder['proxy'].layout = newLayout;
+        return builder;
+    }
+}

package/src/glayoutable.ts

@@ -0,0 +1,57 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 { Args, JsonPrimitive } from '@eclipse-glsp/protocol';
+import { GModelElement, GModelElementBuilder } from './gmodel-element';
+
+export const GLayoutable = Symbol('GLayoutable');
+
+export interface GLayoutable {
+    layoutOptions?: Args;
+    [GLayoutable]: boolean;
+}
+
+export function isGLayoutable<G extends GModelElement>(element: G): element is G & GLayoutable {
+    return ((element as any)[GLayoutable] = true);
+}
+
+export type GLayoutableBuilder = GModelElementBuilder<GModelElement & GLayoutable>;
+
+export namespace GLayoutableBuilder {
+    export function addLayoutOption<B extends GLayoutableBuilder>(builder: B, key: string, value: JsonPrimitive): B {
+        const proxy = builder['proxy'];
+        if (!proxy.layoutOptions) {
+            proxy.layoutOptions = {};
+        }
+        proxy.layoutOptions[key] = value;
+        return builder;
+    }
+
+    export function addLayoutOptions<B extends GLayoutableBuilder>(builder: B, layoutOptions: Args | Map<string, JsonPrimitive>): B {
+        const toAssign: Args = {};
+        const proxy = builder['proxy'];
+        if (layoutOptions instanceof Map) {
+            [...layoutOptions.keys()].forEach(key => (toAssign[key] = layoutOptions.get(key)!));
+        } else {
+            Object.keys(layoutOptions).forEach(key => (toAssign[key] = layoutOptions[key]));
+        }
+        if (proxy.layoutOptions) {
+            Object.assign(proxy.layoutOptions, toAssign);
+        } else {
+            proxy.layoutOptions = toAssign;
+        }
+        return builder;
+    }
+}

package/src/gmodel-element.spec.ts

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * Copyright (c) 2022 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
+ ********************************************************************************/
+describe('foo', () => {
+    // Test stub
+});

package/src/gmodel-element.ts

@@ -0,0 +1,216 @@
+/********************************************************************************
+ * Copyright (c) 2022 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 {
+    Args,
+    Bounds,
+    Dimension,
+    flatPush,
+    isSModelElementSchema,
+    isSModelRootSchema,
+    JsonPrimitive,
+    MaybeArray,
+    Point,
+    SModelElementSchema,
+    SModelRootSchema
+} from '@eclipse-glsp/protocol';
+import * as uuid from 'uuid';
+export type GModelElementConstructor<G extends GModelElement = GModelElement> = new () => G;
+
+/**
+ * Represents a `GModeElement` serialized as plain JSON object.
+ */
+export type GModelElementSchema = SModelElementSchema;
+
+export function isGModelElementSchema(schema: any): schema is GModelElementSchema {
+    return isSModelElementSchema(schema);
+}
+
+/**
+ * Base type for all elements of the graphical model.
+ * Each model element must have a unique ID and a type that is used to look up its view.
+ */
+export abstract class GModelElement implements GModelElementSchema {
+    /**
+     * The `type` of a `GModelElement` has two main purposes. It is used by the GLSP client
+     * during the rendering phase to lookup the View that is responsible for rendering this element.
+     * In addition, it serves as the discriminator for serialization & deserialization of `GModeElements` and their corresponding
+     * `GModelElementSchema`. e.g. If the glsp server receives a `GModelElementSchema` (plain JSON object) the type is used to
+     * lookup and construct the corresponding `GModelElement` class.
+     */
+    type: string;
+    /**
+     * Each model element must have a unique ID. Duplicate ids in the graphical element will result in an error during the
+     * rendering phase.
+     */
+    id: string;
+    /**
+     * A set of css classes that should be applied to the DOM element that corresponds to this element.
+     */
+    cssClasses: string[] = [];
+    /** A `GModelElement can have an arbitrary amount of children. This parent-child relation ship is also reflected in
+     * the corresponding DOM element i.e. DOM elements that reflect children of this element are also children
+     * of the DOM element that reflects this element.
+     */
+    children: GModelElement[] = [];
+    /**
+     * Each `GModelElement` (apart from  the root element) must have an assigned parent. Orphan elements are not allowed.
+     */
+    parent: GModelElement;
+    /**
+     * Additional custom arguments. Can be used to transmit additional information between client & server without
+     * having to extend the model.
+     */
+    args?: Args;
+
+    get root(): GModelRoot {
+        let current: GModelElement = this;
+        while (!(current instanceof GModelRoot)) {
+            current = current.parent;
+        }
+        return current;
+    }
+}
+
+/**
+ * A fluent builder API that simplifies the construction of complex {@link GModelElement}s.
+ * The builder API is derived from the Java GLSP server implementation where it is used to hide the complexity
+ * of creating EMF objects. However, the API is also useful in a Typescript/Node context to declare the creation of a new
+ * {@link GModelElement} in a more concise way.
+ */
+export abstract class GModelElementBuilder<G extends GModelElement> {
+    protected proxy: G;
+    protected elementConstructor: GModelElementConstructor<G>;
+
+    constructor(elementConstructor: GModelElementConstructor<G>) {
+        this.elementConstructor = elementConstructor;
+        this.proxy = new elementConstructor();
+        this.proxy.cssClasses = [];
+        this.proxy.children = [];
+        this.proxy.id = uuid.v4();
+    }
+
+    reset(): this {
+        this.proxy = new this.elementConstructor();
+        return this;
+    }
+
+    build(): G {
+        const element = new this.elementConstructor();
+        Object.assign(element, this.proxy);
+        element.children.forEach(child => (child.parent = element));
+        if (element.id === undefined) {
+            throw new Error('The `id` property of a GModelElement must not be undefined!');
+        }
+        if (element.type === undefined) {
+            throw new Error('The `type` property of a GModelElement must not be undefined!');
+        }
+        return element;
+    }
+
+    id(id: string): this {
+        this.proxy.id = id;
+        return this;
+    }
+
+    type(type: string): this {
+        this.proxy.type = type;
+        return this;
+    }
+
+    addCssClass(cssClass: string): this {
+        this.proxy.cssClasses.push(cssClass);
+        return this;
+    }
+
+    addCssClasses(cssClasses: string[]): this;
+    addCssClasses(...cssClasses: string[]): this;
+    addCssClasses(...cssClasses: MaybeArray<string>[]): this {
+        flatPush(this.proxy.cssClasses, cssClasses);
+        return this;
+    }
+
+    add(child: GModelElement): this {
+        this.proxy.children.push(child);
+        return this;
+    }
+
+    addChildren(children: GModelElement[]): this;
+    addChildren(...children: GModelElement[]): this;
+    addChildren(...children: MaybeArray<GModelElement>[]): this {
+        flatPush(this.proxy.children, children);
+        return this;
+    }
+
+    addArg(key: string, value: JsonPrimitive): this {
+        if (!this.proxy.args) {
+            this.proxy.args = {};
+        }
+        this.proxy.args[key] = value;
+        return this;
+    }
+
+    addArgs(args: Args): this;
+    addArgs(args: Map<string, JsonPrimitive>): this;
+    addArgs(args: Args | Map<string, JsonPrimitive>): this {
+        const toAssign: Args = {};
+        if (args instanceof Map) {
+            [...args.keys()].forEach(key => (toAssign[key] = args.get(key)!));
+        } else {
+            Object.keys(args).forEach(key => (toAssign[key] = args[key]));
+        }
+        if (this.proxy.args) {
+            Object.assign(this.proxy.args, toAssign);
+        } else {
+            this.proxy.args = toAssign;
+        }
+        return this;
+    }
+}
+
+export type GModelRootSchema = SModelRootSchema;
+
+export function isGModelRootSchema(schema: any): schema is GModelRootSchema {
+    return isSModelRootSchema(schema);
+}
+
+export class GModelRoot extends GModelElement implements SModelRootSchema {
+    static builder(): GModelRootBuilder {
+        return new GModelRootBuilder(GModelRoot);
+    }
+
+    canvasBounds?: Bounds;
+    revision = 0;
+}
+
+export class GModelRootBuilder<G extends GModelRoot = GModelRoot> extends GModelElementBuilder<G> {
+    revision(revision: number): this {
+        this.proxy.revision = revision;
+        return this;
+    }
+
+    canvasBounds(position: Point, size: Dimension): this;
+    canvasBounds(bounds: Bounds): this;
+    canvasBounds(positionOrBounds: Point | Bounds, size?: Dimension): this {
+        let bounds: Bounds;
+        if (size) {
+            bounds = { ...positionOrBounds, ...size };
+        } else {
+            bounds = positionOrBounds as Bounds;
+        }
+        this.proxy.canvasBounds = bounds;
+        return this;
+    }
+}