bpmnlint 11.14.0 → 11.15.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "11.14.0",
+  "version": "11.15.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -27,11 +27,12 @@
   },
   "license": "MIT",
   "scripts": {
-    "all": "run-s lint lint:types test-coverage",
+    "all": "run-s lint lint:types test-coverage test:perf",
     "lint": "eslint .",
     "lint:types": "tsc",
     "dev": "npm test -- --watch",
-    "test": "mocha --exclude \"test/integration/*/**\" \"test/**/*.*js\"",
+    "test": "mocha --exclude \"test/integration/*/**\" --exclude \"test/performance/**\" \"test/**/*.*js\"",
+    "test:perf": "mocha \"test/performance/**/*.*js\"",
     "test-coverage": "nyc --reporter=lcov --reporter=html npm test",
     "generate-docs-images": "npx @bpmn-io/bpmnlint-generate-docs-images ."
   },

package/rules/no-bpmndi.js

@@ -35,12 +35,12 @@ module.exports = function() {
     // (2) Filter BPMN elements without visual representation
     const visualBpmnElements = bpmnElements.filter(hasVisualRepresentation);
 
-    // (3) Construct array of BPMNDI references
-    const diBpmnReferences = getAllDiBpmnReferences(node);
+    // (3) Construct set of BPMNDI references
+    const referencedBpmnElementIds = getReferencedBpmnElementIds(node);
 
     // (4) Report elements without BPMNDI
     visualBpmnElements.forEach((element) => {
-      if (diBpmnReferences.indexOf(element.id) === -1) {
+      if (!referencedBpmnElementIds.has(element.id)) {
         reporter.report(element.id, 'Element is missing bpmndi');
       }
     });
@@ -105,16 +105,17 @@ function getAllBpmnElements(rootElements) {
 }
 
 /**
- * Get all BPMN elements within a bpmn:Definitions node
+ * Get the ids of all BPMN elements referenced by BPMNDI elements
+ * within a bpmn:Definitions node
  *
  * @param {ModdleElement} definitionsNode - A moddleElement representing the
  *   bpmn:Definitions element
  *
- * @return {string[]} ids of all BPMNDI element part of
- *   this bpmn:Definitions node
+ * @return {Set<string>} ids of all BPMN elements referenced by BPMNDI
+ *   elements part of this bpmn:Definitions node
  */
-function getAllDiBpmnReferences(definitionsNode) {
-  return flatten(
+function getReferencedBpmnElementIds(definitionsNode) {
+  return new Set(flatten(
     definitionsNode.get('diagrams').map((diagram) => {
 
       const diElements = diagram.plane.planeElement || [];
@@ -124,7 +125,7 @@ function getAllDiBpmnReferences(definitionsNode) {
         return element.bpmnElement?.id;
       });
     })
-  );
+  ));
 }
 
 /**

package/rules/no-overlapping-elements.js

@@ -6,6 +6,18 @@ const {
   annotateRule
 } = require('./helper');
 
+/**
+ * @typedef { import('../lib/types.js').ModdleElement } ModdleElement
+ *
+ * @typedef { {
+ *   element: ModdleElement,
+ *   left: number,
+ *   right: number,
+ *   top: number,
+ *   bottom: number
+ * } } Shape
+ */
+
 
 /**
  * Rule that checks if two elements overlap except:
@@ -99,36 +111,88 @@ function checkProcess(node, elementsToReport, elementsOutsideToReport, diObjects
 }
 
 /**
+ * Check elements for overlap.
+ *
+ * Sweeps the shapes of the elements from left to right, so that every shape
+ * is only compared with the shapes that start before it ends.
+ *
  * @param {Array} elements
  * @param {Set} elementsToReport
+ * @param {Map} diObjects
  */
 function checkElementsArray(elements, elementsToReport, diObjects) {
-  for (let i = 0; i < elements.length - 1; i++) {
-    const element = elements[i];
+  const shapes = getShapes(elements, diObjects).sort((a, b) => a.left - b.left);
 
-    for (let j = i + 1; j < elements.length; j++) {
-      const element2 = elements[j];
+  const overlapping = new Set();
 
-      // ignore if Boundary events overlap their host
-      // but still check if they overlap other elements
-      if (element.attachedToRef === element2 || element2.attachedToRef === element) {
-        continue;
-      }
+  for (let i = 0; i < shapes.length; i++) {
+    const shape = shapes[i];
 
-      const bounds1 = diObjects.get(element)?.bounds;
-      const bounds2 = diObjects.get(element2)?.bounds;
+    // shapes starting right of this one cannot overlap it
+    for (let j = i + 1; j < shapes.length && shapes[j].left <= shape.right; j++) {
+      const otherShape = shapes[j];
 
-      // ignore if an element doesn't have bounds
-      if (!bounds1 || !bounds2) {
+      if (!isCollision(shape, otherShape)) {
         continue;
       }
 
-      if (isCollision(bounds1, bounds2)) {
-        elementsToReport.add(element);
-        elementsToReport.add(element2);
+      // ignore if Boundary events overlap their host
+      // but still check if they overlap other elements
+      if (shape.element.attachedToRef === otherShape.element || otherShape.element.attachedToRef === shape.element) {
+        continue;
       }
+
+      overlapping.add(shape.element);
+      overlapping.add(otherShape.element);
     }
   }
+
+  // report in element order, independent of the order overlaps are detected
+  elements.forEach(element => {
+    if (overlapping.has(element)) {
+      elementsToReport.add(element);
+    }
+  });
+}
+
+/**
+ * Get the shapes of all elements with valid bounds, the only elements
+ * that can overlap.
+ *
+ * @param {Array} elements
+ * @param {Map} diObjects
+ *
+ * @return {Shape[]}
+ */
+function getShapes(elements, diObjects) {
+  const shapes = [];
+
+  elements.forEach(element => {
+    const bounds = diObjects.get(element)?.bounds;
+
+    if (!isValidShapeElement(bounds)) {
+      return;
+    }
+
+    const left = bounds.x;
+    const right = bounds.x + bounds.width;
+
+    // shapes with a NaN left or right edge never collide,
+    // and a NaN left edge would break the sweep
+    if (Number.isNaN(left) || Number.isNaN(right)) {
+      return;
+    }
+
+    shapes.push({
+      element,
+      left,
+      right,
+      top: bounds.y,
+      bottom: bounds.y + bounds.height
+    });
+  });
+
+  return shapes;
 }
 
 /**
@@ -148,14 +212,15 @@ function isOutsideParentBoundary(childBounds, parentBounds) {
 
 /**
  * Check if two rectangle shapes collides
+ *
+ * @param {Shape} firstShape
+ * @param {Shape} secondShape
+ *
+ * @return {boolean}
  */
-function isCollision(firstBounds, secondBounds) {
-  if (!isValidShapeElement(firstBounds) || !isValidShapeElement(secondBounds)) {
-    return false;
-  }
-
-  const collisionX = firstBounds.x + firstBounds.width >= secondBounds.x && secondBounds.x + secondBounds.width >= firstBounds.x;
-  const collisionY = firstBounds.y + firstBounds.height >= secondBounds.y && secondBounds.y + secondBounds.height >= firstBounds.y;
+function isCollision(firstShape, secondShape) {
+  const collisionX = firstShape.right >= secondShape.left && secondShape.right >= firstShape.left;
+  const collisionY = firstShape.bottom >= secondShape.top && secondShape.bottom >= firstShape.top;
 
   // collision on both axis
   return collisionX && collisionY;