bpmnlint-plugin-camunda-compat 2.17.0 → 2.19.0

package/rules/camunda-cloud/element-type/index.js

@@ -1,134 +1,134 @@
-const { isString } = require('min-dash');
-
-const { isAny } = require('bpmnlint-utils');
-
-const config = require('./config');
-
-const { greaterOrEqual } = require('../../utils/version');
-
-const { getEventDefinition } = require('../../utils/element');
-
-const { ERROR_TYPES } = require('../../utils/error-types');
-
-const { reportErrors } = require('../../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../../utils/rule');
-
-module.exports = skipInNonExecutableProcess(function({ version }) {
-  function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
-      return;
-    }
-
-    const element = config[ node.$type ];
-
-    if (!element || (isString(element) && !greaterOrEqual(version, element))) {
-
-      // (1) Element not allowed
-      const allowedVersion = element || null;
-
-      let message = `Element of type <${ node.$type }> not allowed`;
-
-      let data = {
-        type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-        node,
-        parentNode: null
-      };
-
-      if (allowedVersion) {
-        message = `Element of type <${ node.$type }> only allowed by Camunda ${ allowedVersion } or newer`;
-
-        data = {
-          ...data,
-          allowedVersion
-        };
-      }
-
-      const error = {
-        message,
-        path: null,
-        data
-      };
-
-      reportErrors(node, reporter, error);
-
-      return;
-    }
-
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (eventDefinition) {
-      if (!element[ eventDefinition.$type ] || !greaterOrEqual(version, element[ eventDefinition.$type ])) {
-
-        // (2) Element with event definition not allowed
-        const allowedVersion = element[ eventDefinition.$type ] || null;
-
-        let message = `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> not allowed`;
-
-        let data = {
-          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-          node,
-          parentNode: null,
-          eventDefinition
-        };
-
-        if (allowedVersion) {
-          message = `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> only allowed by Camunda ${ allowedVersion } or newer`;
-
-          data = {
-            ...data,
-            allowedVersion
-          };
-        }
-
-        const error = {
-          message,
-          path: null,
-          data
-        };
-
-        reportErrors(node, reporter, error);
-      }
-    } else {
-      if (!element[ '_' ] || !greaterOrEqual(version, element[ '_' ])) {
-
-        // (3) Element without event definition not allowed
-        const allowedVersion = element[ '_' ] || null;
-
-        let message = `Element of type <${ node.$type }> with no event definition not allowed`;
-
-        let data = {
-          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
-          node,
-          parentNode: null,
-          eventDefinition
-        };
-
-        if (allowedVersion) {
-          message = `Element of type <${ node.$type }> with no event definition only allowed by Camunda ${ allowedVersion } or newer`;
-
-          data = {
-            ...data,
-            allowedVersion
-          };
-        }
-
-        const error = {
-          message,
-          path: null,
-          data
-        };
-
-        reportErrors(node, reporter, error);
-      }
-    }
-  }
-
-  return {
-    check
-  };
+const { isString } = require('min-dash');
+
+const { isAny } = require('bpmnlint-utils');
+
+const config = require('./config');
+
+const { greaterOrEqual } = require('../../utils/version');
+
+const { getEventDefinition } = require('../../utils/element');
+
+const { ERROR_TYPES } = require('../../utils/error-types');
+
+const { reportErrors } = require('../../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function({ version }) {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:FlowElement', 'bpmn:FlowElementsContainer' ])) {
+      return;
+    }
+
+    const element = config[ node.$type ];
+
+    if (!element || (isString(element) && !greaterOrEqual(version, element))) {
+
+      // (1) Element not allowed
+      const allowedVersion = element || null;
+
+      let message = `Element of type <${ node.$type }> not allowed`;
+
+      let data = {
+        type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+        node,
+        parentNode: null
+      };
+
+      if (allowedVersion) {
+        message = `Element of type <${ node.$type }> only allowed by Camunda ${ allowedVersion } or newer`;
+
+        data = {
+          ...data,
+          allowedVersion
+        };
+      }
+
+      const error = {
+        message,
+        path: null,
+        data
+      };
+
+      reportErrors(node, reporter, error);
+
+      return;
+    }
+
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (eventDefinition) {
+      if (!element[ eventDefinition.$type ] || !greaterOrEqual(version, element[ eventDefinition.$type ])) {
+
+        // (2) Element with event definition not allowed
+        const allowedVersion = element[ eventDefinition.$type ] || null;
+
+        let message = `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> not allowed`;
+
+        let data = {
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          eventDefinition
+        };
+
+        if (allowedVersion) {
+          message = `Element of type <${ node.$type }> with event definition of type <${ eventDefinition.$type }> only allowed by Camunda ${ allowedVersion } or newer`;
+
+          data = {
+            ...data,
+            allowedVersion
+          };
+        }
+
+        const error = {
+          message,
+          path: null,
+          data
+        };
+
+        reportErrors(node, reporter, error);
+      }
+    } else {
+      if (!element[ '_' ] || !greaterOrEqual(version, element[ '_' ])) {
+
+        // (3) Element without event definition not allowed
+        const allowedVersion = element[ '_' ] || null;
+
+        let message = `Element of type <${ node.$type }> with no event definition not allowed`;
+
+        let data = {
+          type: ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          eventDefinition
+        };
+
+        if (allowedVersion) {
+          message = `Element of type <${ node.$type }> with no event definition only allowed by Camunda ${ allowedVersion } or newer`;
+
+          data = {
+            ...data,
+            allowedVersion
+          };
+        }
+
+        const error = {
+          message,
+          path: null,
+          data
+        };
+
+        reportErrors(node, reporter, error);
+      }
+    }
+  }
+
+  return {
+    check
+  };
 });

package/rules/camunda-cloud/error-reference.js

@@ -1,72 +1,72 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
-
-const {
-  getEventDefinition,
-  hasProperties
-} = require('../utils/element');
-
-const { reportErrors } = require('../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../utils/rule');
-
-const { greaterOrEqual } = require('../utils/version');
-
-const noErrorRefAllowedVersion = '8.2';
-
-module.exports = skipInNonExecutableProcess(function({ version }) {
-  function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
-      return;
-    }
-
-    let errors = [];
-
-    if (!isNoErrorRefAllowed(node, version)) {
-      errors = hasProperties(eventDefinition, {
-        errorRef: {
-          required: true,
-          allowedVersion: '8.2'
-        }
-      }, node);
-
-      if (errors.length) {
-        reportErrors(node, reporter, errors);
-
-        return;
-      }
-    }
-
-    const errorRef = eventDefinition.get('errorRef');
-
-    if (!errorRef) {
-      return;
-    }
-
-    errors = hasProperties(errorRef, {
-      errorCode: {
-        required: true
-      }
-    }, node);
-
-    if (errors.length) {
-      reportErrors(node, reporter, errors);
-    }
-  }
-
-  return {
-    check
-  };
-});
-
-function isNoErrorRefAllowed(node, version) {
-  return is(node, 'bpmn:CatchEvent') && greaterOrEqual(version, noErrorRefAllowedVersion);
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+const { greaterOrEqual } = require('../utils/version');
+
+const noErrorRefAllowedVersion = '8.2';
+
+module.exports = skipInNonExecutableProcess(function({ version }) {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:ErrorEventDefinition')) {
+      return;
+    }
+
+    let errors = [];
+
+    if (!isNoErrorRefAllowed(node, version)) {
+      errors = hasProperties(eventDefinition, {
+        errorRef: {
+          required: true,
+          allowedVersion: '8.2'
+        }
+      }, node);
+
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
+    }
+
+    const errorRef = eventDefinition.get('errorRef');
+
+    if (!errorRef) {
+      return;
+    }
+
+    errors = hasProperties(errorRef, {
+      errorCode: {
+        required: true
+      }
+    }, node);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function isNoErrorRefAllowed(node, version) {
+  return is(node, 'bpmn:CatchEvent') && greaterOrEqual(version, noErrorRefAllowedVersion);
 }

package/rules/camunda-cloud/escalation-boundary-event-attached-to-ref.js

@@ -1,48 +1,48 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
-
-const {
-  getEventDefinition,
-  isAnyExactly
-} = require('../utils/element');
-
-const { ERROR_TYPES } = require('../utils/error-types');
-
-const { reportErrors } = require('../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../utils/rule');
-
-module.exports = skipInNonExecutableProcess(function() {
-  function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
-      return;
-    }
-
-    const attachedToRef = node.get('attachedToRef');
-
-    if (attachedToRef && !isAnyExactly(attachedToRef, [ 'bpmn:CallActivity', 'bpmn:SubProcess' ])) {
-      reportErrors(node, reporter, {
-        message: `Element of type <bpmn:BoundaryEvent> with event definition of type <bpmn:EscalationEventDefinition> is not allowed to be attached to element of type <${ attachedToRef.$type }>`,
-        path: null,
-        data: {
-          type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED,
-          node,
-          parentNode: null,
-          attachedToRef
-        }
-      });
-    }
-  }
-
-  return {
-    check
-  };
-});
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  isAnyExactly
+} = require('../utils/element');
+
+const { ERROR_TYPES } = require('../utils/error-types');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
+      return;
+    }
+
+    const attachedToRef = node.get('attachedToRef');
+
+    if (attachedToRef && !isAnyExactly(attachedToRef, [ 'bpmn:CallActivity', 'bpmn:SubProcess' ])) {
+      reportErrors(node, reporter, {
+        message: `Element of type <bpmn:BoundaryEvent> with event definition of type <bpmn:EscalationEventDefinition> is not allowed to be attached to element of type <${ attachedToRef.$type }>`,
+        path: null,
+        data: {
+          type: ERROR_TYPES.ATTACHED_TO_REF_ELEMENT_TYPE_NOT_ALLOWED,
+          node,
+          parentNode: null,
+          attachedToRef
+        }
+      });
+    }
+  }
+
+  return {
+    check
+  };
+});

package/rules/camunda-cloud/escalation-reference.js

@@ -1,67 +1,67 @@
-const {
-  is,
-  isAny
-} = require('bpmnlint-utils');
-
-const {
-  getEventDefinition,
-  hasProperties
-} = require('../utils/element');
-
-const { reportErrors } = require('../utils/reporter');
-
-const { skipInNonExecutableProcess } = require('../utils/rule');
-
-module.exports = skipInNonExecutableProcess(function() {
-  function check(node, reporter) {
-    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
-      return;
-    }
-
-    const eventDefinition = getEventDefinition(node);
-
-    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
-      return;
-    }
-
-    let errors = [];
-
-    if (!isNoEscalationRefAllowed(node)) {
-      errors = hasProperties(eventDefinition, {
-        escalationRef: {
-          required: true
-        }
-      }, node);
-
-      if (errors.length) {
-        reportErrors(node, reporter, errors);
-
-        return;
-      }
-    }
-
-    const escalationRef = eventDefinition.get('escalationRef');
-
-    if (!escalationRef) {
-      return;
-    }
-
-    errors = hasProperties(escalationRef, {
-      escalationCode: {
-        required: true
-      }
-    }, node);
-
-    if (errors.length) {
-      reportErrors(node, reporter, errors);
-    }
-  }
-
-  return {
-    check
-  };
-});
-
-function isNoEscalationRefAllowed(node) {
-  return isAny(node, [ 'bpmn:CatchEvent', 'bpmn:BoundaryEvent' ]);
+const {
+  is,
+  isAny
+} = require('bpmnlint-utils');
+
+const {
+  getEventDefinition,
+  hasProperties
+} = require('../utils/element');
+
+const { reportErrors } = require('../utils/reporter');
+
+const { skipInNonExecutableProcess } = require('../utils/rule');
+
+module.exports = skipInNonExecutableProcess(function() {
+  function check(node, reporter) {
+    if (!isAny(node, [ 'bpmn:CatchEvent', 'bpmn:ThrowEvent' ])) {
+      return;
+    }
+
+    const eventDefinition = getEventDefinition(node);
+
+    if (!eventDefinition || !is(eventDefinition, 'bpmn:EscalationEventDefinition')) {
+      return;
+    }
+
+    let errors = [];
+
+    if (!isNoEscalationRefAllowed(node)) {
+      errors = hasProperties(eventDefinition, {
+        escalationRef: {
+          required: true
+        }
+      }, node);
+
+      if (errors.length) {
+        reportErrors(node, reporter, errors);
+
+        return;
+      }
+    }
+
+    const escalationRef = eventDefinition.get('escalationRef');
+
+    if (!escalationRef) {
+      return;
+    }
+
+    errors = hasProperties(escalationRef, {
+      escalationCode: {
+        required: true
+      }
+    }, node);
+
+    if (errors.length) {
+      reportErrors(node, reporter, errors);
+    }
+  }
+
+  return {
+    check
+  };
+});
+
+function isNoEscalationRefAllowed(node) {
+  return isAny(node, [ 'bpmn:CatchEvent', 'bpmn:BoundaryEvent' ]);
 }