bpmnlint 8.3.2 → 9.1.0

package/config/all.js

@@ -13,6 +13,7 @@ const allRules = [
   'no-implicit-end',
   'no-implicit-start',
   'no-inclusive-gateway',
+  'no-overlapping-elements',
   'single-blank-start-event',
   'single-event-definition',
   'start-event-required',

package/config/recommended.js

@@ -14,6 +14,7 @@ module.exports = {
     'no-implicit-end': 'error',
     'no-implicit-start': 'error',
     'no-inclusive-gateway': 'error',
+    'no-overlapping-elements': 'warn',
     'single-blank-start-event': 'error',
     'single-event-definition': 'error',
     'start-event-required': 'error',

package/lib/linter.js

@@ -7,6 +7,8 @@ const categoryMap = {
   3: 'info'
 };
 
+const ruleErrorCategory = 'rule-error';
+
 
 function Linter(options = {}) {
 
@@ -69,8 +71,8 @@ Linter.prototype.applyRule = function applyRule(moddleRoot, ruleDefinition) {
 
     return [
       {
-        message: 'Rule error: ' + e.message,
-        category: 'error'
+        message: e.message,
+        category: ruleErrorCategory
       }
     ];
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "8.3.2",
+  "version": "9.1.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -51,8 +51,8 @@
   },
   "devDependencies": {
     "@bpmn-io/bpmnlint-generate-docs-images": "^0.4.0",
-    "chai": "^4.3.4",
-    "eslint": "^8.42.0",
+    "chai": "^4.3.7",
+    "eslint": "^8.44.0",
     "eslint-plugin-bpmn-io": "^1.0.0",
     "esm": "^3.2.25",
     "execa": "^5.1.1",

package/rules/no-overlapping-elements.js

@@ -0,0 +1,174 @@
+const {
+  is
+} = require('bpmnlint-utils');
+
+
+/**
+ * Rule that checks if two elements overlap except:
+ * - Boundary events overlap their host
+ * - Child elements overlap / are on top of their parent (e.g., elements within a subProcess)
+ */
+module.exports = function() {
+
+  function check(node, reporter) {
+    if (!is(node, 'bpmn:Definitions')) {
+      return;
+    }
+
+    const rootElements = node.rootElements || [];
+    const elementsToReport = new Set();
+    const elementsOutsideToReport = new Set();
+    const diObjects = getAllDiObjects(node);
+    const processElementsParentDiMap = new Map(); // map with sub/process as key and its parent boundary di object
+
+    rootElements
+      .filter(element => is(element, 'bpmn:Collaboration'))
+      .forEach(collaboration => {
+        const participants = collaboration.participants || [];
+        checkElementsArray(participants, elementsToReport, diObjects);
+
+        participants.forEach(participant => {
+          processElementsParentDiMap.set(participant.processRef, diObjects.get(participant));
+        });
+      });
+
+    rootElements
+      .filter(element => is(element, 'bpmn:Process'))
+      .forEach(process => {
+        const parentDi = processElementsParentDiMap.get(process) || {};
+        checkProcess(process, elementsToReport, elementsOutsideToReport, diObjects, parentDi);
+      });
+
+    // report elements
+    elementsToReport.forEach(element => reporter.report(element.id, 'Element overlaps with other element'));
+    elementsOutsideToReport.forEach(element => reporter.report(element.id, 'Element is outside of parent boundary'));
+  }
+
+  return {
+    check: check
+  };
+};
+
+// helpers /////////////////
+
+/**
+ * Recursively check subprocesses in a process
+ * @param {Object} node Process or SubProcess
+ * @param {Set} elementsToReport
+ * @param {Set} elementsOutsideToReport
+ * @param {Map} diObjects
+ */
+function checkProcess(node, elementsToReport, elementsOutsideToReport, diObjects, parentDi) {
+
+  // check child elements for overlap
+  const flowElements = node.flowElements || [];
+  checkElementsArray(flowElements, elementsToReport, diObjects);
+
+  // check child elements outside parent boundary
+  // TODO: Skipped DataSoreReferences for now
+  flowElements.filter(element => !is(element, 'bpmn:DataStoreReference')).forEach(element => {
+    if (isOutsideParentBoundary(diObjects.get(element).bounds, parentDi.bounds)) {
+      elementsOutsideToReport.add(element);
+    }
+  });
+
+  // check subprocesses
+  const subProcesses = flowElements.filter(element => is(element, 'bpmn:SubProcess'));
+  subProcesses.forEach(subProcess => {
+    const subProcessDi = diObjects.get(subProcess) || {};
+    const subProcessParentBoundary = subProcessDi.isExpanded ? subProcessDi : {};
+    checkProcess(subProcess, elementsToReport, elementsOutsideToReport, diObjects, subProcessParentBoundary);
+  });
+}
+
+/**
+ * @param {Array} elements
+ * @param {Set} elementsToReport
+ */
+function checkElementsArray(elements, elementsToReport, diObjects) {
+  for (let i = 0; i < elements.length - 1; i++) {
+    const element = elements[i];
+    for (let j = i + 1; j < elements.length; j++) {
+      const element2 = elements[j];
+
+      if (!diObjects.has(element) || !diObjects.has(element2)) {
+        continue;
+      }
+
+      // ignore if Boundary events overlap their host
+      // but still check if they overlap other elements
+      if (element.attachedToRef === element2 || element2.attachedToRef === element) {
+        continue;
+      }
+
+      if (isCollision(diObjects.get(element).bounds, diObjects.get(element2).bounds)) {
+        elementsToReport.add(element);
+        elementsToReport.add(element2);
+      }
+    }
+  }
+}
+
+/**
+ * Check if child element is outside of parent boundary
+ */
+function isOutsideParentBoundary(childBounds, parentBounds) {
+  if (!isValidShapeElement(childBounds) || !isValidShapeElement(parentBounds)) {
+    return false;
+  }
+
+  const isTopLeftCornerInside = childBounds.x >= parentBounds.x && childBounds.y >= parentBounds.y;
+  const isBottomRightCornerInside = childBounds.x + childBounds.width <= parentBounds.x + parentBounds.width && childBounds.y + childBounds.height <= parentBounds.y + parentBounds.height;
+  const isInside = isTopLeftCornerInside && isBottomRightCornerInside;
+
+  return !isInside;
+}
+
+/**
+ * Check if two rectangle shapes collides
+ */
+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;
+
+  // collision on both axis
+  return collisionX && collisionY;
+}
+
+/**
+ * Checks if shape bounds has all necessary values for collision check
+ */
+function isValidShapeElement(bounds) {
+  return !!bounds && is(bounds, 'dc:Bounds') &&
+    typeof (bounds.x) === 'number' &&
+    typeof (bounds.y) === 'number' &&
+    typeof (bounds.width) === 'number' &&
+    typeof (bounds.height) === 'number';
+}
+
+/**
+ * Get all di object as one map object
+ * @param {Object} node bpmn:Definitions
+ * @returns {Map<Object, Object>} map of di objects with element as key
+ */
+function getAllDiObjects(node) {
+  const diObjects = new Map();
+  const diagrams = node.diagrams || [];
+
+  diagrams
+    .filter(diagram => !!diagram.plane)
+    .forEach(diagram => {
+      const planeElements = diagram.plane.planeElement || [];
+      planeElements
+        .filter(planeElement => !!planeElement.bpmnElement)
+        .forEach(planeElement => {
+          diObjects.set(planeElement.bpmnElement, planeElement);
+        });
+    });
+
+  return diObjects;
+}