@finos/legend-extension-dsl-diagram 1.0.29 → 1.0.30

package/src/graphManager/DSLDiagram_PureGraphManagerPlugin.ts

@@ -17,10 +17,13 @@
 import packageJson from '../../package.json';
 import {
   PureGraphManagerPlugin,
+  type ObserverContext,
+  type ElementObserver,
   type PackageableElement,
   type PureGrammarElementLabeler,
 } from '@finos/legend-graph';
 import { Diagram } from '../models/metamodels/pure/packageableElements/diagram/DSLDiagram_Diagram';
+import { observe_Diagram } from './action/changeDetection/DSLDiagram_ObserverHelper';
 
 const PURE_GRAMMAR_DIAGRAM_PARSER_NAME = 'Diagram';
 const PURE_GRAMMAR_DIAGRAM_ELEMENT_TYPE_LABEL = 'Diagram';
@@ -48,4 +51,18 @@ export class DSLDiagram_PureGraphManagerPlugin extends PureGraphManagerPlugin {
       },
     ];
   }
+
+  override getExtraElementObservers(): ElementObserver[] {
+    return [
+      (
+        element: PackageableElement,
+        context: ObserverContext,
+      ): PackageableElement | undefined => {
+        if (element instanceof Diagram) {
+          return observe_Diagram(element);
+        }
+        return undefined;
+      },
+    ];
+  }
 }

package/src/graphManager/action/changeDetection/DSLDiagram_ObserverHelper.ts

@@ -0,0 +1,153 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  observe_Abstract_PackageableElement,
+  observe_PackageableElementReference,
+  observe_PropertyReference,
+  skipObserved,
+} from '@finos/legend-graph';
+import { computed, makeObservable, observable, override } from 'mobx';
+import type { AssociationView } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_AssociationView';
+import type { ClassView } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_ClassView';
+import type { ClassViewReference } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_ClassViewReference';
+import type { Diagram } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_Diagram';
+import type { GeneralizationView } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_GeneralizationView';
+import type { PropertyView } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_PropertyView';
+import type { RelationshipEdgeView } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_RelationshipEdgeView';
+import type { RelationshipView } from '../../../models/metamodels/pure/packageableElements/diagram/DSLDiagram_RelationshipView';
+import type { PositionedRectangle } from '../../../models/metamodels/pure/packageableElements/diagram/geometry/DSLDiagram_PositionedRectangle';
+
+export const observe_PositionedRectangle = skipObserved(
+  (metamodel: PositionedRectangle): PositionedRectangle =>
+    makeObservable(metamodel, {
+      dummyObservable: observable,
+    }),
+);
+
+export const observe_ClassViewReference = skipObserved(
+  (metamodel: ClassViewReference): ClassViewReference => {
+    makeObservable(metamodel, {
+      value: observable,
+    });
+
+    observe_PackageableElementReference(metamodel.ownerReference);
+
+    return metamodel;
+  },
+);
+
+export const observe_ClassView = skipObserved(
+  (metamodel: ClassView): ClassView => {
+    observe_PositionedRectangle(metamodel);
+
+    makeObservable(metamodel, {
+      id: observable,
+      hideProperties: observable,
+      hideTaggedValues: observable,
+      hideStereotypes: observable,
+      hashCode: computed,
+    });
+
+    observe_PackageableElementReference(metamodel.class);
+
+    return metamodel;
+  },
+);
+
+export const observe_RelationShipEdgeView = skipObserved(
+  (metamodel: RelationshipEdgeView): RelationshipEdgeView => {
+    observe_ClassViewReference(metamodel.classView);
+
+    return metamodel;
+  },
+);
+
+export const observe_RelationshipView = skipObserved(
+  (metamodel: RelationshipView): RelationshipView => {
+    makeObservable(metamodel, {
+      // NOTE: to optimize performance for diagram, we have made classview's position and rectangle non-observable
+      // if we want to further optimize, perhaps we can also remove observability from path
+      path: observable,
+      pathForSerialization: computed,
+    });
+
+    observe_RelationShipEdgeView(metamodel.from);
+    observe_RelationShipEdgeView(metamodel.to);
+
+    return metamodel;
+  },
+);
+
+export const observe_GeneralizationView = skipObserved(
+  (metamodel: GeneralizationView): GeneralizationView => {
+    observe_RelationshipView(metamodel);
+
+    makeObservable(metamodel, {
+      hashCode: computed,
+    });
+
+    return metamodel;
+  },
+);
+
+export const observe_AssociationView = skipObserved(
+  (metamodel: AssociationView): AssociationView => {
+    observe_RelationshipView(metamodel);
+
+    makeObservable(metamodel, {
+      hashCode: computed,
+    });
+
+    observe_PropertyReference(metamodel.property);
+    observe_PackageableElementReference(metamodel.association);
+
+    return metamodel;
+  },
+);
+
+export const observe_PropertyView = skipObserved(
+  (metamodel: PropertyView): PropertyView => {
+    observe_RelationshipView(metamodel);
+
+    makeObservable(metamodel, {
+      hashCode: computed,
+    });
+
+    observe_PropertyReference(metamodel.property);
+
+    return metamodel;
+  },
+);
+
+export const observe_Diagram = skipObserved((metamodel: Diagram): Diagram => {
+  observe_Abstract_PackageableElement(metamodel);
+
+  makeObservable<Diagram, '_elementHashCode'>(metamodel, {
+    classViews: observable,
+    associationViews: observable,
+    generalizationViews: observable,
+    propertyViews: observable,
+    _elementHashCode: override,
+  });
+
+  metamodel.classViews.forEach(observe_ClassView);
+  metamodel.associationViews.forEach(observe_AssociationView);
+  metamodel.generalizationViews.forEach(observe_GeneralizationView);
+  metamodel.propertyViews.forEach(observe_PropertyView);
+
+  return metamodel;
+});

package/src/helpers/DiagramHelper.ts

@@ -14,11 +14,13 @@
  * limitations under the License.
  */
 
+import { RelationshipView } from '../models/metamodels/pure/packageableElements/diagram/DSLDiagram_RelationshipView';
+import { Point } from '../models/metamodels/pure/packageableElements/diagram/geometry/DSLDiagram_Point';
+import { Vector } from '../models/metamodels/pure/packageableElements/diagram/geometry/DSLDiagram_Vector';
 import type { PureModel } from '@finos/legend-graph';
 import { deleteEntry } from '@finos/legend-shared';
 import type { ClassView } from '../models/metamodels/pure/packageableElements/diagram/DSLDiagram_ClassView';
 import type { Diagram } from '../models/metamodels/pure/packageableElements/diagram/DSLDiagram_Diagram';
-import { Point } from '../models/metamodels/pure/packageableElements/diagram/geometry/DSLDiagram_Point';
 
 /**
  * Get absolute position of element on the screen by recursively walking up element tree
@@ -78,3 +80,122 @@ export const cleanUpDeadReferencesInDiagram = (
     deleteEntry(diagram.generalizationViews, g),
   );
 };
+
+export const _relationshipView_setPath = (
+  relationshipView: RelationshipView,
+  val: Point[],
+): void => {
+  relationshipView.path = val;
+};
+
+/**
+ * Simplify the path.
+ *
+ * Flatten the path if the angle is wide enough between 3 consecutive points
+ * Also remove unnecessary inside points
+ */
+export const _relationshipView_simplifyPath = (
+  relationshipView: RelationshipView,
+): void => {
+  const fullPath = relationshipView.buildFullPath();
+  // NOTE: this method here will `swallow` up points inside of the boxes
+  const newPath = RelationshipView.pruneUnnecessaryInsidePoints(
+    fullPath,
+    relationshipView.from.classView.value,
+    relationshipView.to.classView.value,
+  );
+
+  // recompute the offset point from center inside of `from` and `to` classviews.
+  // for each, we first check if `manageInsidePointsDynamically` removes any points from the full path
+  // if it does we will update the offset
+  if (newPath[0] !== fullPath[0]) {
+    const center = relationshipView.from.classView.value.center();
+    relationshipView.from.offsetX = (newPath[0] as Point).x - center.x;
+    relationshipView.from.offsetY = (newPath[0] as Point).y - center.y;
+  }
+
+  if (newPath[newPath.length - 1] !== fullPath[fullPath.length - 1]) {
+    const center = relationshipView.to.classView.value.center();
+    relationshipView.to.offsetX =
+      (newPath[newPath.length - 1] as Point).x - center.x;
+    relationshipView.to.offsetY =
+      (newPath[newPath.length - 1] as Point).y - center.y;
+  }
+
+  // find the point which can be flattened due to its wide angle
+  const result = [];
+  for (let i = 0; i < newPath.length - 2; i++) {
+    const v1 = Vector.fromPoints(
+      newPath[i + 1] as Point,
+      newPath[i] as Point,
+    ).unit();
+    const v2 = Vector.fromPoints(
+      newPath[i + 1] as Point,
+      newPath[i + 2] as Point,
+    ).unit();
+    const dot = v1.dotProduct(v2);
+    const angle = (Math.acos(dot) * 180) / Math.PI;
+    if (Math.abs(angle - 180) > 5) {
+      result.push(newPath[i + 1] as Point);
+    }
+  }
+
+  // NOTE: this new path does not contain the 2 end points
+  _relationshipView_setPath(relationshipView, result);
+};
+
+/**
+ * Based on the location, find the point on the path that matches or create new point
+ * (within a threshold of proximity) from the coordinate and put this in the path array
+ * so it doesn't look too weird
+ */
+export const _findOrBuildPoint = (
+  relationshipView: RelationshipView,
+  x: number,
+  y: number,
+  zoom: number,
+  allowChange: boolean,
+): Point | undefined => {
+  for (const pt of relationshipView.path) {
+    if (
+      Math.sqrt((x - pt.x) * (x - pt.x) + (y - pt.y) * (y - pt.y)) <
+      10 / zoom
+    ) {
+      return pt;
+    }
+  }
+
+  const fullPath = relationshipView.buildFullPath(allowChange);
+  const newPath = [];
+  let point;
+
+  for (let i = 0; i < fullPath.length - 1; i++) {
+    const a = fullPath[i] as Point;
+    const b = fullPath[i + 1] as Point;
+    const u = new Vector(a.x, a.y).normal(new Vector(b.x, b.y)).unit();
+    const v = Vector.fromPoints(a, new Point(x, y));
+
+    // if the selection point is not too far from the segment
+    // of the path, create a new point and make it part of the path
+    if (Math.abs(u.dotProduct(v)) < 5 / zoom) {
+      const lx = (a.x < b.x ? a.x : b.x) - 5 / zoom;
+      const hx = (a.x < b.x ? b.x : a.x) + 5 / zoom;
+      const ly = (a.y < b.y ? a.y : b.y) - 5 / zoom;
+      const hy = (a.y < b.y ? b.y : a.y) + 5 / zoom;
+
+      if (lx <= x && x <= hx && ly <= y && y <= hy) {
+        point = new Point(x, y);
+        newPath.push(point);
+      }
+    }
+
+    if (i < fullPath.length - 2) {
+      newPath.push(fullPath[i + 1] as Point);
+    }
+  }
+  if (point && allowChange) {
+    // NOTE: this new path does not contain the 2 end points
+    _relationshipView_setPath(relationshipView, newPath);
+  }
+  return point;
+};

package/src/index.ts

@@ -25,7 +25,6 @@ export { DiagramRenderer, DIAGRAM_INTERACTION_MODE } from './DiagramRenderer';
 export { Diagram } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_Diagram';
 export { ClassView } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_ClassView';
 export { RelationshipView } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_RelationshipView';
-export { _relationView_manageInsidePointsDynamically } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_GraphModifierHelper';
 export { PropertyHolderView } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_PropertyHolderView';
 export { PropertyView } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_PropertyView';
 export { AssociationView } from './models/metamodels/pure/packageableElements/diagram/DSLDiagram_AssociationView';

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_AssociationView.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { computed, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { PropertyHolderView } from './DSLDiagram_PropertyHolderView';
 import type { ClassView } from './DSLDiagram_ClassView';
@@ -37,11 +36,6 @@ export class AssociationView extends PropertyHolderView implements Hashable {
     to: ClassView,
   ) {
     super(owner, property, from, to);
-
-    makeObservable(this, {
-      hashCode: computed,
-    });
-
     this.association = association;
   }
 

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_ClassView.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { computed, observable, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { PositionedRectangle } from './geometry/DSLDiagram_PositionedRectangle';
 import { Rectangle } from './geometry/DSLDiagram_Rectangle';
@@ -37,15 +36,6 @@ export class ClassView extends PositionedRectangle implements Hashable {
     _class: PackageableElementReference<Class>,
   ) {
     super(new Point(0, 0), new Rectangle(0, 0));
-
-    makeObservable(this, {
-      id: observable,
-      hideProperties: observable,
-      hideTaggedValues: observable,
-      hideStereotypes: observable,
-      hashCode: computed,
-    });
-
     this.owner = owner;
     this.id = id;
     this.class = _class;

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_ClassViewReference.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable } from 'mobx';
 import type { Diagram } from './DSLDiagram_Diagram';
 import type { ClassView } from './DSLDiagram_ClassView';
 import {
@@ -33,11 +32,6 @@ export abstract class ClassViewReference extends ReferenceWithOwner {
     value: ClassView,
   ) {
     super(ownerReference);
-
-    makeObservable(this, {
-      value: observable,
-    });
-
     this.ownerReference = ownerReference;
     this.value = value;
   }

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_Diagram.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable, override } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import type { ClassView } from './DSLDiagram_ClassView';
 import type { PropertyView } from './DSLDiagram_PropertyView';
@@ -32,18 +31,6 @@ export class Diagram extends PackageableElement implements Hashable {
   generalizationViews: GeneralizationView[] = [];
   propertyViews: PropertyView[] = [];
 
-  constructor(name: string) {
-    super(name);
-
-    makeObservable<Diagram, '_elementHashCode'>(this, {
-      classViews: observable,
-      associationViews: observable,
-      generalizationViews: observable,
-      propertyViews: observable,
-      _elementHashCode: override,
-    });
-  }
-
   protected override get _elementHashCode(): string {
     return hashArray([
       DIAGRAM_HASH_STRUCTURE.DIAGRAM,

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_GeneralizationView.ts

@@ -14,22 +14,11 @@
  * limitations under the License.
  */
 
-import { computed, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { RelationshipView } from './DSLDiagram_RelationshipView';
-import type { Diagram } from './DSLDiagram_Diagram';
-import type { ClassView } from './DSLDiagram_ClassView';
 import { DIAGRAM_HASH_STRUCTURE } from '../../../../DSLDiagram_ModelUtils';
 
 export class GeneralizationView extends RelationshipView implements Hashable {
-  constructor(owner: Diagram, from: ClassView, to: ClassView) {
-    super(owner, from, to);
-
-    makeObservable(this, {
-      hashCode: computed,
-    });
-  }
-
   override get hashCode(): string {
     return hashArray([
       DIAGRAM_HASH_STRUCTURE.GENERALIZATION_VIEW,

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_PropertyView.ts

@@ -14,28 +14,11 @@
  * limitations under the License.
  */
 
-import { computed, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { PropertyHolderView } from './DSLDiagram_PropertyHolderView';
-import type { Diagram } from './DSLDiagram_Diagram';
-import type { ClassView } from './DSLDiagram_ClassView';
-import type { PropertyReference } from '@finos/legend-graph';
 import { DIAGRAM_HASH_STRUCTURE } from '../../../../DSLDiagram_ModelUtils';
 
 export class PropertyView extends PropertyHolderView implements Hashable {
-  constructor(
-    owner: Diagram,
-    property: PropertyReference,
-    from: ClassView,
-    to: ClassView,
-  ) {
-    super(owner, property, from, to);
-
-    makeObservable(this, {
-      hashCode: computed,
-    });
-  }
-
   override get hashCode(): string {
     return hashArray([DIAGRAM_HASH_STRUCTURE.PROPERTY_VIEW, super.hashCode]);
   }

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_RelationshipEdgeView.ts

@@ -14,20 +14,19 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable } from 'mobx';
 import type { ClassViewReference } from './DSLDiagram_ClassViewReference';
 
-export class RelationShipEdgeView {
+export class RelationshipEdgeView {
   classView: ClassViewReference;
+  /**
+   * Offsets from the center of the class view.
+   *
+   * These offsets can be used to compute the end points of relationship views.
+   */
   offsetX?: number | undefined;
   offsetY?: number | undefined;
 
   constructor(classView: ClassViewReference) {
-    makeObservable(this, {
-      offsetX: observable,
-      offsetY: observable,
-    });
-
     this.classView = classView;
   }
 }

package/src/models/metamodels/pure/packageableElements/diagram/DSLDiagram_RelationshipView.ts

@@ -14,30 +14,31 @@
  * limitations under the License.
  */
 
-import { observable, computed, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
-import { RelationShipEdgeView as RelationshipEdgeView } from './DSLDiagram_RelationshipEdgeView';
+import { RelationshipEdgeView } from './DSLDiagram_RelationshipEdgeView';
 import { Point } from './geometry/DSLDiagram_Point';
 import type { ClassView } from './DSLDiagram_ClassView';
 import type { Diagram } from './DSLDiagram_Diagram';
 import { ClassViewExplicitReference } from './DSLDiagram_ClassViewReference';
 import { DIAGRAM_HASH_STRUCTURE } from '../../../../DSLDiagram_ModelUtils';
-import { _relationView_manageInsidePointsDynamically } from './DSLDiagram_GraphModifierHelper';
 
 export class RelationshipView implements Hashable {
   owner: Diagram;
   from: RelationshipEdgeView;
   to: RelationshipEdgeView;
-  // NOTE: to optimize performance for diagram, we have made classview's position and rectangle non-observable
-  // if we want to further optimize, perhaps we can also remove observability from path
+  /**
+   * NOTE: Unlike in the protocol model, we don't store the end points in the path but only store the
+   * offsets of that point from the center of the end/start classviews. The main purpose here is to
+   * make less error. We don't need to bother maintaining these points in the path. They are
+   * auto-managed. Even if an erroneous path is set (e.g. an empty list of points), this logic
+   * that we have will rectify that and create a sensible path.
+   *
+   * In exchange, this logic is a little complicated, we have tried to document as much about it as we could
+   * but the logic is not straight forward. Perhaps, we could simplify this in the future.
+   */
   path: Point[] = [];
 
   constructor(owner: Diagram, from: ClassView, to: ClassView) {
-    makeObservable(this, {
-      path: observable,
-      fullPath: computed,
-    });
-
     this.owner = owner;
     this.from = new RelationshipEdgeView(
       ClassViewExplicitReference.create(from),
@@ -45,29 +46,6 @@ export class RelationshipView implements Hashable {
     this.to = new RelationshipEdgeView(ClassViewExplicitReference.create(to));
   }
 
-  /**
-   * Compute the full path for an edge, but notice here that the end points are recomputed every time, as such
-   * `path` only stores point that matters to the edge but are not end points
-   */
-  buildFullPath(allowChange = true): Point[] {
-    return [
-      this.computeEdgeEndpoint(this.from, allowChange),
-      ...this.path,
-      this.computeEdgeEndpoint(this.to, allowChange),
-    ];
-  }
-
-  /**
-   * This method will compute the full path from the offset within class view for persistence purpose
-   */
-  get fullPath(): Point[] {
-    return _relationView_manageInsidePointsDynamically(
-      this.buildFullPath(),
-      this.from.classView.value,
-      this.to.classView.value,
-    );
-  }
-
   /**
    * Calculate the end points of the edge using offset, otherwise, use the center
    */
@@ -89,12 +67,77 @@ export class RelationshipView implements Hashable {
     return new Point(center.x, center.y);
   }
 
+  /**
+   * Compute the full path for the relationship view (including the ends even if these
+   * ends lie inside of the classviews)
+   *
+   * Notice here that the end points are recomputed every time, as such
+   * `path` only stores point that matters to the edge but are not end points
+   */
+  buildFullPath(allowChange = true): Point[] {
+    return [
+      this.computeEdgeEndpoint(this.from, allowChange),
+      ...this.path,
+      this.computeEdgeEndpoint(this.to, allowChange),
+    ];
+  }
+
+  /**
+   * For a path, only keep **at most** 1 point at each end that lies inside the class view.
+   * If there is no inside points, none of kept, so the path only contains outside points.
+   */
+  static pruneUnnecessaryInsidePoints = (
+    path: Point[],
+    from: ClassView,
+    to: ClassView,
+  ): Point[] => {
+    if (!path.length) {
+      return [];
+    }
+
+    let start = 0;
+    let startPoint = path[start] as Point;
+
+    while (
+      start < path.length - 1 &&
+      from.contains(startPoint.x, startPoint.y)
+    ) {
+      start++;
+      startPoint = path[start] as Point;
+    }
+
+    // NOTE: due to the usage path, we could make sure `end > start`, but maybe this
+    // is an improvement to be done
+
+    let end = path.length - 1;
+    let endPoint = path[end] as Point;
+
+    while (end > 0 && to.contains(endPoint.x, endPoint.y)) {
+      end--;
+      endPoint = path[end] as Point;
+    }
+
+    // NOTE: slice upper bound is exclusive, hence the +2 instead of +1
+    return path.slice(start - 1, end + 2);
+  };
+
+  /**
+   * This method will compute the full path from the offset within class view for serialization and persistence purpose
+   */
+  get pathForSerialization(): Point[] {
+    return RelationshipView.pruneUnnecessaryInsidePoints(
+      this.buildFullPath(),
+      this.from.classView.value,
+      this.to.classView.value,
+    );
+  }
+
   get hashCode(): string {
     return hashArray([
       DIAGRAM_HASH_STRUCTURE.RELATIONSHIP_VIEW,
       this.from.classView.value.id,
       this.to.classView.value.id,
-      hashArray(this.fullPath),
+      hashArray(this.pathForSerialization),
     ]);
   }
 }

package/src/models/metamodels/pure/packageableElements/diagram/geometry/DSLDiagram_PositionedRectangle.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import { observable, makeObservable } from 'mobx';
 import { hashArray, type Hashable } from '@finos/legend-shared';
 import { Point } from './DSLDiagram_Point';
 import { Rectangle } from './DSLDiagram_Rectangle';
@@ -26,10 +25,6 @@ export class PositionedRectangle implements Hashable {
   dummyObservable = {};
 
   constructor(position: Point, rectangle: Rectangle) {
-    makeObservable(this, {
-      dummyObservable: observable,
-    });
-
     this.position = position;
     this.rectangle = rectangle;
   }