bpmnlint 11.14.1 → 12.0.0

package/lib/types.d.ts

@@ -1,81 +1,20 @@
-export type ModdleElement = any;
-
-export interface Reporter {
-
-  report(id: string, message: string): void;
-
-  report(id: string, message: string, path: string[]): void;
-
-  report(id: string, message: string, context: {
-    path?: string[],
-    [key: string]: any
-  }) : void;
-}
-
-export interface Resolver {
-
-  resolveRule(pkg: string, ruleName: string): Promise<RuleFactory> | RuleFactory,
-
-  resolveConfig(pkg: string, configName: string): Promise<Config> | Config;
-}
-
-export type EnterFn = (element: ModdleElement, reporter: Reporter) => boolean | void;
-
-export type LeaveFn = (element: ModdleElement, reporter: Reporter) => void;
-
-export type CheckDefinition = EnterFn | {
-  enter: EnterFn
-} | {
-  leave: LeaveFn
-} | {
-  enter: EnterFn,
-  leave: LeaveFn
-};
-
-export type RuleDefinition = {
-  meta?: {
-    documentation?: {
-      url?: string
-    }
-  },
-  check: CheckDefinition
-};
-
-export type RuleFactory = (ruleOptions?: any) => RuleDefinition;
-
-export type ReportingCategoryMap = {
-  0: 'off',
-  1: 'warn',
-  2: 'error',
-  3: 'info'
-};
-
-export type ReportingCategoryIndex = keyof ReportingCategoryMap;
-export type ReportingCategory = ReportingCategoryMap[ReportingCategoryIndex];
-
-export type RuleErrorCategory = 'rule-error';
-
-export type RuleConfig =
-  ReportingCategoryIndex |
-  ReportingCategory |
-  [ ReportingCategoryIndex, config?: any ] |
-  [ ReportingCategory, config?: any ];
-
-export type RuleConfigs = Record<string, RuleConfig>;
-
-export type Config = {
-  extends?: string | string[],
-  rules?: RuleConfigs
-};
-
-export type TransformRuleFn = (
-  rule: RuleDefinition,
-  options: { pkg: string, ruleName: string }
-) => RuleDefinition;
-
-export type Report = {
-  id?: string,
-  path?: string[],
-  message: string,
-  [key: string]: any
-};
+export type {
+  ModdleElement,
+  Product,
+  Reporter,
+  Resolver,
+  EnterFn,
+  LeaveFn,
+  CheckDefinition,
+  RuleDefinition,
+  RuleFactory,
+  ReportingCategoryMap,
+  ReportingCategoryIndex,
+  ReportingCategory,
+  RuleErrorCategory,
+  RuleConfig,
+  RuleConfigs,
+  Config,
+  TransformRuleFn,
+  Report
+} from '@bpmn-io/lint-core/lib/types';

package/package.json

@@ -1,8 +1,47 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "11.14.1",
+  "version": "12.0.0",
   "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./lib/index": "./lib/index.js",
+    "./lib/index.js": "./lib/index.js",
+    "./lib/linter": "./lib/linter.js",
+    "./lib/linter.js": "./lib/linter.js",
+    "./lib/resolver/helper": "./lib/resolver/helper.js",
+    "./lib/resolver/helper.js": "./lib/resolver/helper.js",
+    "./lib/resolver/node-resolver": "./lib/resolver/node-resolver.js",
+    "./lib/resolver/node-resolver.js": "./lib/resolver/node-resolver.js",
+    "./lib/resolver/static-resolver": "./lib/resolver/static-resolver.js",
+    "./lib/resolver/static-resolver.js": "./lib/resolver/static-resolver.js",
+    "./lib/support/compile-config": "./lib/support/compile-config.js",
+    "./lib/support/compile-config.js": "./lib/support/compile-config.js",
+    "./lib/test-rule": "./lib/test-rule.js",
+    "./lib/test-rule.js": "./lib/test-rule.js",
+    "./lib/testers/helper": "./lib/testers/helper.js",
+    "./lib/testers/helper.js": "./lib/testers/helper.js",
+    "./lib/traverse": "./lib/traverse.js",
+    "./lib/traverse.js": "./lib/traverse.js",
+    "./bin/bpmnlint": "./bin/bpmnlint.js",
+    "./bin/bpmnlint.js": "./bin/bpmnlint.js",
+    "./lib/testers/rule-tester": {
+      "types": "./lib/testers/rule-tester.d.ts",
+      "default": "./lib/testers/rule-tester.js"
+    },
+    "./lib/testers/rule-tester.js": {
+      "types": "./lib/testers/rule-tester.d.ts",
+      "default": "./lib/testers/rule-tester.js"
+    },
+    "./lib/types": {
+      "types": "./lib/types.d.ts"
+    },
+    "./rules/*.js": "./rules/*.js",
+    "./rules/*": "./rules/*.js",
+    "./config/*.js": "./config/*.js",
+    "./config/*": "./config/*.js",
+    "./package.json": "./package.json"
+  },
   "keywords": [
     "bpmnlint",
     "bpmn",
@@ -23,15 +62,16 @@
     }
   ],
   "engines": {
-    "node": ">= 20"
+    "node": ">= 24"
   },
   "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 ."
   },
@@ -39,16 +79,10 @@
     "bpmnlint": "./bin/bpmnlint.js"
   },
   "dependencies": {
-    "@bpmn-io/moddle-utils": "^0.3.0",
-    "ansi-colors": "^4.1.3",
+    "@bpmn-io/lint-core": "^0.1.0",
     "bpmn-moddle": "^10.1.0",
     "bpmnlint-utils": "^1.1.1",
-    "cli-table": "^0.3.11",
-    "color-support": "^1.1.3",
-    "min-dash": "^5.1.0",
-    "mri": "^1.2.0",
-    "pluralize": "^8.0.0",
-    "tiny-glob": "^0.2.9"
+    "min-dash": "^5.1.0"
   },
   "devDependencies": {
     "@bpmn-io/bpmnlint-generate-docs-images": "^1.2.0",

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;