@camunda/linting 0.7.2 → 0.9.0

package/README.md

@@ -47,6 +47,10 @@ modeler.get('linting').setErrors(reports);
 
 // show error by selecting element and properties panel entry
 modeler.get('linting').showError(report);
+
+// activate and deactivate errors on canvas
+modeler.get('linting').activate();
+modeler.get('linting').deactivate();
 ```
 
 ## Development

package/assets/linting.css

@@ -1,33 +1,34 @@
 :root {
+  --color-grey-225-10-15: hsl(225, 10%, 15%);
+
   --color-red-360-100-45: hsl(360, 100%, 45%);
+
   --color-white: hsl(0, 0%, 100%);
 
-  --linting-annotation-background-color: var(--color-red-360-100-45);
-  --linting-annotation-fill-color: var(--color-white);
-}
+  --color-yellow-47-88-53: hsl(47, 88%, 53%);
 
-.djs-overlays:not(.selected) .bjs-linting-annotation {
-  opacity: 0.5;
-}
-
-.djs-overlays.selected .bjs-linting-annotation,
-.djs-overlays .bjs-linting-annotation:hover {
-  opacity: 1;
+  --linting-annotation-error-background-color: var(--color-red-360-100-45);
+  --linting-annotation-error-fill-color: var(--color-white);
+  
+  --linting-annotation-warning-background-color: var(--color-yellow-47-88-53);
+  --linting-annotation-warning-fill-color: var(--color-white);
+  --linting-annotation-warning-stroke-color: var(--color-grey-225-10-15);
 }
 
 .bjs-linting-annotation {
   display: flex;
   flex-direction: row;
   align-items: center;
-  padding: 1px;
+  padding: 2px;
   border-radius: 2px;
-  background-color: var(--linting-annotation-background-color);
   cursor: default;
   z-index: 100000;
 }
 
-.bjs-linting-annotation > svg {
-  fill: var(--linting-annotation-fill-color);
-  width: 18px;
-  height: 18px;
+.bjs-linting-annotation--error {
+  background-color: var(--linting-annotation-error-background-color);
+}
+
+.bjs-linting-annotation--warning {
+  background-color: var(--linting-annotation-warning-background-color);
 }

package/lib/Linter.js

@@ -10,7 +10,7 @@ import { isString } from 'min-dash';
 import modelerModdle from 'modeler-moddle/resources/modeler.json';
 import zeebeModdle from 'zeebe-bpmn-moddle/resources/zeebe.json';
 
-import { getErrorMessage, getExecutionPlatformLabel } from './utils/error-messages';
+import { getErrorMessage } from './utils/error-messages';
 import { getEntryIds } from './utils/properties-panel';
 
 const moddle = new BpmnModdle({
@@ -68,7 +68,8 @@ export class Linter {
             ...report,
             message: getErrorMessage(
               report,
-              getExecutionPlatformLabel(executionPlatform, toSemverMinor(executionPlatformVersion)),
+              executionPlatform,
+              executionPlatformVersion,
               this._modeler
             ),
             propertiesPanel: {

package/lib/modeler/LintingAnnotations.js

@@ -3,8 +3,15 @@ import { groupBy } from 'min-dash';
 import { domify } from 'min-dom';
 
 const errorSvg = `
-<svg viewBox="2 2 20 20">
-  <path d="M12,5 C15.8659932,5 19,8.13400675 19,12 C19,15.8659932 15.8659932,19 12,19 C8.13400675,19 5,15.8659932 5,12 C5,8.13400675 8.13400675,5 12,5 Z M9.33333333,8 L8,9.33333333 L10.667,12 L8,14.6666667 L9.33333333,16 L12,13.333 L14.6666667,16 L16,14.6666667 L13.333,12 L16,9.33333333 L14.6666667,8 L12,10.666 L9.33333333,8 Z"></path>
+<svg width="16" height="16" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M8 1C4.1 1 1 4.1 1 8s3.1 7 7 7 7-3.1 7-7-3.1-7-7-7Zm2.7 10.5L8 8.8l-2.7 2.7-.8-.8L7.2 8 4.5 5.3l.8-.8L8 7.2l2.7-2.7.8.8L8.8 8l2.7 2.7-.8.8Z" fill="var(--linting-annotation-error-fill-color, white)"/>
+</svg>
+`;
+
+const warningSvg = `
+<svg width="16" height="16" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path d="M12 3H4v10h8V3Z" fill="var(--linting-annotation-warning-stroke-color, black)"/>
+  <path d="M8 1C4.15 1 1 4.15 1 8s3.15 7 7 7 7-3.15 7-7-3.15-7-7-7Zm-.55 3h1.1v5.5h-1.1V4ZM8 12.5c-.4 0-.75-.35-.75-.75S7.6 11 8 11s.75.35.75.75-.35.75-.75.75Z" fill="var(--linting-annotation-warning-fill-color, white)"/>
 </svg>
 `;
 
@@ -40,9 +47,11 @@ export default class LintingAnnotations {
         return;
       }
 
+      const hasErrors = reports.find(({ category }) => category === 'error');
+
       const overlay = domify(`
-        <div class="bjs-linting-annotation" title="Click to show">
-          ${ errorSvg }
+        <div class="bjs-linting-annotation ${ hasErrors ? 'bjs-linting-annotation--error' : 'bjs-linting-annotation--warning' }" title="Click to show">
+          ${ hasErrors ? errorSvg : warningSvg }
         </div>
       `);
 

package/lib/utils/error-messages.js

@@ -1,6 +1,7 @@
 import { ERROR_TYPES } from 'bpmnlint-plugin-camunda-compat/rules/utils/element';
 
 import { is } from 'bpmnlint-utils';
+
 import {
   every,
   isArray
@@ -9,29 +10,75 @@ import {
 import { getTypeString } from './types';
 
 const TIMER_PROPERTIES = [
+  'timeCycle',
   'timeDate',
-  'timeDuration',
-  'timeCycle'
+  'timeDuration'
 ];
 
-export function getErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
+const executionPlatformLabels = {
+  'Camunda Cloud': {
+    'default': 'Camunda',
+    '1.0': 'Camunda 8 (Zeebe 1.0)',
+    '1.1': 'Camunda 8 (Zeebe 1.1)',
+    '1.2': 'Camunda 8 (Zeebe 1.2)',
+    '1.3': 'Camunda 8 (Zeebe 1.3)'
+  }
+};
+
+export function getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) {
+  const executionPlatformLabel = executionPlatformLabels[ executionPlatform ]
+    && executionPlatformLabels[ executionPlatform ][ executionPlatformVersion ];
+
+  if (executionPlatformLabel) {
+    return executionPlatformLabel;
+  }
+
+  if (executionPlatformLabels[ executionPlatform ]
+    && executionPlatformLabels[ executionPlatform ][ 'default' ]) {
+    executionPlatform = executionPlatformLabels[ executionPlatform ][ 'default' ];
+  }
+
+  return `${ executionPlatform } ${ executionPlatformVersion }`;
+}
+
+function getIndefiniteArticle(type) {
+  if ([
+    'Ad',
+    'Error',
+    'Escalation',
+    'Event',
+    'Inclusive',
+    'Intermediate',
+    'Undefined'
+  ].includes(type.split(' ')[ 0 ])) {
+    return 'An';
+  }
+
+  return 'A';
+}
+
+export function getErrorMessage(report, executionPlatform, executionPlatformVersion, modeler = 'desktop') {
   const {
-    error,
+    data,
     message
   } = report;
 
-  if (!error) {
+  if (!data) {
     return message;
   }
 
-  const { type } = error;
+  const { type } = data;
+
+  if (type === ERROR_TYPES.ELEMENT_COLLAPSED_NOT_ALLOWED) {
+    return getElementCollapsedNotAllowedErrorMessage(report);
+  }
 
   if (type === ERROR_TYPES.ELEMENT_TYPE_NOT_ALLOWED) {
-    return getElementTypeNotAllowedErrorMessage(report, executionPlatformLabel);
+    return getElementTypeNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion);
   }
 
   if (type === ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED) {
-    return getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabel);
+    return getExtensionElementNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion);
   }
 
   if (type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED) {
@@ -43,80 +90,61 @@ export function getErrorMessage(report, executionPlatformLabel, modeler = 'deskt
   }
 
   if (type === ERROR_TYPES.PROPERTY_NOT_ALLOWED) {
-    return getPropertyNotAllowedErrorMessage(report, executionPlatformLabel, modeler);
+    return getPropertyNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion, modeler);
   }
 
   if (type === ERROR_TYPES.PROPERTY_REQUIRED) {
-    return getPropertyRequiredErrorMessage(report, executionPlatformLabel);
-  }
-
-  if (type === ERROR_TYPES.PROPERTY_TYPE_NOT_ALLOWED) {
-    return getPropertyTypeNotAllowedErrorMessage(report, executionPlatformLabel);
+    return getPropertyRequiredErrorMessage(report);
   }
 
   if (type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED) {
     return getPropertyValueDuplicatedErrorMessage(report);
   }
 
-  if (type === ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED) {
-    return getPropertyValueNotAllowedErrorMessage(report, executionPlatformLabel);
+  if (type === ERROR_TYPES.EXPRESSION_REQUIRED) {
+    return getExpressionRequiredErrorMessage(report);
   }
 
-  return message;
-}
-
-const executionPlatformLabels = {
-  'Camunda Cloud': {
-    'defaultPlatformName': 'Camunda',
-    '1.0': 'Camunda 8 (Zeebe 1.0)',
-    '1.1': 'Camunda 8 (Zeebe 1.1)',
-    '1.2': 'Camunda 8 (Zeebe 1.2)',
-    '1.3': 'Camunda 8 (Zeebe 1.3)'
+  if (type === ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED) {
+    return getExpressionValueNotAllowedErrorMessage(report);
   }
-};
 
-export function getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) {
-  const translatedLabel = executionPlatformLabels[ executionPlatform ] && executionPlatformLabels[ executionPlatform ][ executionPlatformVersion ];
+  return message;
+}
 
-  if (translatedLabel) {
-    return translatedLabel;
-  }
+function getElementCollapsedNotAllowedErrorMessage(report) {
+  const {
+    data,
+    message
+  } = report;
 
-  if (executionPlatformLabels[executionPlatform] && executionPlatformLabels[executionPlatform]['defaultPlatformName']) {
-    executionPlatform = executionPlatformLabels[executionPlatform]['defaultPlatformName'];
-  }
+  const { node } = data;
 
-  return `${ executionPlatform } ${ executionPlatformVersion }`;
-}
+  const typeString = getTypeString(node);
 
-function getIndefiniteArticle(type) {
-  if ([
-    'Error',
-    'Escalation',
-    'Event',
-    'Inclusive',
-    'Intermediate',
-    'Undefined'
-  ].includes(type.split(' ')[ 0 ])) {
-    return 'An';
+  if (is(node, 'bpmn:SubProcess')) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must be expanded`;
   }
 
-  return 'A';
+  return message;
 }
 
-function getElementTypeNotAllowedErrorMessage(report, executionPlatformLabel) {
-  const { error } = report;
+function getElementTypeNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion) {
+  const { data } = report;
 
-  const { node } = error;
+  const {
+    allowedVersion,
+    node
+  } = data;
 
   const typeString = getTypeString(node);
 
-  return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
+  return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <${ typeString }>`, executionPlatform, executionPlatformVersion, allowedVersion);
 }
 
 function getPropertyValueDuplicatedErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -125,7 +153,7 @@ function getPropertyValueDuplicatedErrorMessage(report) {
     parentNode,
     duplicatedPropertyValue,
     properties
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -136,26 +164,27 @@ function getPropertyValueDuplicatedErrorMessage(report) {
   return message;
 }
 
-function getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabel) {
+function getExtensionElementNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion) {
   const {
-    error,
+    data,
     message
   } = report;
 
   const {
+    allowedVersion,
     node,
     parentNode,
     extensionElement
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
   if (is(node, 'bpmn:BusinessRuleTask') && is(extensionElement, 'zeebe:CalledDecision')) {
-    return `A <Business Rule Task> with <Implementation: DMN decision> is not supported by ${ executionPlatformLabel }`;
+    return getSupportedMessage('A <Business Rule Task> with <Implementation: DMN decision>', executionPlatform, executionPlatformVersion, allowedVersion);
   }
 
   if (is(extensionElement, 'zeebe:Properties')) {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Extension properties> is not supported by ${ executionPlatformLabel }`;
+    return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <${ typeString }> with <Extension properties>`, executionPlatform, executionPlatformVersion, allowedVersion);
   }
 
   return message;
@@ -163,7 +192,7 @@ function getExtensionElementNotAllowedErrorMessage(report, executionPlatformLabe
 
 function getExtensionElementRequiredErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -171,7 +200,7 @@ function getExtensionElementRequiredErrorMessage(report) {
     node,
     parentNode,
     requiredExtensionElement
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -200,7 +229,7 @@ function getExtensionElementRequiredErrorMessage(report) {
 
 function getPropertyDependendRequiredErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -209,7 +238,7 @@ function getPropertyDependendRequiredErrorMessage(report) {
     parentNode,
     property,
     dependendRequiredProperty
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -224,39 +253,40 @@ function getPropertyDependendRequiredErrorMessage(report) {
   return message;
 }
 
-function getPropertyNotAllowedErrorMessage(report, executionPlatformLabel, modeler = 'desktop') {
+function getPropertyNotAllowedErrorMessage(report, executionPlatform, executionPlatformVersion, modeler = 'desktop') {
   const {
-    error,
+    data,
     message
   } = report;
 
   const {
+    allowedVersion,
     node,
     parentNode,
     property
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
   if (property === 'modelerTemplate') {
     if (modeler === 'desktop') {
-      return `${ getIndefiniteArticle(typeString) } <Template ${ typeString }> is not supported by ${ executionPlatformLabel }`;
+      return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <Template ${ typeString }>`, executionPlatform, executionPlatformVersion, allowedVersion);
     } else if (modeler === 'web') {
-      return `${ getIndefiniteArticle(typeString) } <Connector ${ typeString }> is not supported by ${ executionPlatformLabel }`;
+      return getSupportedMessage(`${ getIndefiniteArticle(typeString) } <Connector ${ typeString }>`, executionPlatform, executionPlatformVersion, allowedVersion);
     }
   }
 
   if (is(node, 'bpmn:InclusiveGateway') && property === 'incoming') {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with more than one incoming <Sequence Flow> is not supported by ${ executionPlatformLabel }`;
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> with more than one incoming <Sequence Flow> is not supported by ${ getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) }`;
   }
 
   return message;
 }
 
 
-function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
+function getPropertyRequiredErrorMessage(report) {
   const {
-    error,
+    data,
     message
   } = report;
 
@@ -264,7 +294,7 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     node,
     parentNode,
     requiredProperty
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
@@ -288,10 +318,6 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Error Reference> must have a defined <Error code>`;
   }
 
-  if (is(node, 'bpmn:Event') && requiredProperty === 'eventDefinitions') {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
-  }
-
   if (is(node, 'zeebe:LoopCharacteristics') && requiredProperty === 'inputCollection') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> with <Multi-instance marker> must have a defined <Input collection>`;
   }
@@ -339,72 +365,57 @@ function getPropertyRequiredErrorMessage(report, executionPlatformLabel) {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer duration>`;
   }
 
-  if (is(node, 'bpmn:FormalExpression')
-    && requiredProperty === 'body'
-    && TIMER_PROPERTIES.includes(secondLast(report.path))
-  ) {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer value>`;
-  }
-
   return message;
 }
 
-function getPropertyTypeNotAllowedErrorMessage(report, executionPlatformLabel) {
+function getExpressionRequiredErrorMessage(report) {
   const {
-    error,
-    message
+    data
   } = report;
 
   const {
     node,
     parentNode,
     property
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
-  if (is(node, 'bpmn:Event') && property === 'eventDefinitions') {
-    return `${ getIndefiniteArticle(typeString) } <${ typeString }> is not supported by ${ executionPlatformLabel }`;
+  if (is(node, 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(property)) {
+    return `${ getIndefiniteArticle(typeString) } <${ typeString }> must have a defined <Timer value>`;
   }
-
-  return message;
 }
 
-function getPropertyValueNotAllowedErrorMessage(report, executionPlatformLabel) {
+function getExpressionValueNotAllowedErrorMessage(report) {
   const {
-    error
+    data
   } = report;
 
   const {
     node,
     parentNode,
     property
-  } = error;
+  } = data;
 
   const typeString = getTypeString(parentNode || node);
 
-  if (is(node, 'bpmn:FormalExpression')
-    && property === 'body'
-    && secondLast(report.path) === 'timeCycle'
-  ) {
+  if (is(node, 'bpmn:FormalExpression') && property === 'timeCycle') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time cycle> should be an expression, an ISO 8601 repeating interval, or a cron expression (cron requires Camunda Platform 8.1 or newer)`;
   }
 
-  if (is(node, 'bpmn:FormalExpression')
-    && property === 'body'
-    && secondLast(report.path) === 'timeDate'
-  ) {
+  if (is(node, 'bpmn:FormalExpression') && property === 'timeDate') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time date> should be an expression, or an ISO 8601 date`;
   }
 
-  if (is(node, 'bpmn:FormalExpression')
-    && property === 'body'
-    && secondLast(report.path) === 'timeDuration'
-  ) {
+  if (is(node, 'bpmn:FormalExpression') && property === 'timeDuration') {
     return `${ getIndefiniteArticle(typeString) } <${ typeString }> <Time duration> should be an expression, or an ISO 8601 interval`;
   }
 }
 
-function secondLast(array) {
-  return array[array.length - 2];
-}
+function getSupportedMessage(prefix, executionPlatform, executionPlatformVersion, allowedVersion) {
+  if (allowedVersion) {
+    return `${ prefix } is only supported by ${ getExecutionPlatformLabel(executionPlatform, allowedVersion) } or newer`;
+  }
+
+  return `${ prefix } is not supported by ${ getExecutionPlatformLabel(executionPlatform, executionPlatformVersion) }`;
+}

package/lib/utils/properties-panel.js

@@ -46,80 +46,85 @@ export function getErrors(reports, element) {
 
 export function getEntryIds(report) {
   const {
-    error = {},
-    id
+    data = {},
+    id,
+    path
   } = report;
 
-  if (isExtensionElementRequiredError(error, 'zeebe:CalledDecision', 'bpmn:BusinessRuleTask')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:CalledDecision', 'bpmn:BusinessRuleTask')) {
     return [ 'businessRuleImplementation' ];
   }
 
-  if (isPropertyRequiredError(error, 'errorRef')) {
+  if (isPropertyError(data, 'errorRef')) {
     return [ 'errorRef' ];
   }
 
-  if (isPropertyRequiredError(error, 'messageRef')) {
+  if (isPropertyError(data, 'messageRef')) {
     return [ 'messageRef' ];
   }
 
-  if (isPropertyRequiredError(error, 'decisionId', 'zeebe:CalledDecision')) {
+  if (isPropertyError(data, 'decisionId', 'zeebe:CalledDecision')) {
     return [ 'decisionId' ];
   }
 
-  if (isPropertyRequiredError(error, 'resultVariable', 'zeebe:CalledDecision')) {
+  if (isPropertyError(data, 'resultVariable', 'zeebe:CalledDecision')) {
     return [ 'resultVariable' ];
   }
 
-  if (isPropertyRequiredError(error, 'errorCode', 'bpmn:Error')) {
+  if (isPropertyError(data, 'errorCode', 'bpmn:Error')) {
     return [ 'errorCode' ];
   }
 
-  if (isPropertyRequiredError(error, 'name', 'bpmn:Message')) {
+  if (isPropertyError(data, 'name', 'bpmn:Message')) {
     return [ 'messageName' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:LoopCharacteristics', 'bpmn:MultiInstanceLoopCharacteristics')
-    || isPropertyRequiredError(error, 'inputCollection', 'zeebe:LoopCharacteristics')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:LoopCharacteristics', 'bpmn:MultiInstanceLoopCharacteristics')
+    || isPropertyError(data, 'inputCollection', 'zeebe:LoopCharacteristics')) {
     return [ 'multiInstance-inputCollection' ];
   }
 
-  if (isPropertyDependendRequiredError(error, 'outputCollection', 'zeebe:LoopCharacteristics')) {
+  if (isPropertyDependendRequiredError(data, 'outputCollection', 'zeebe:LoopCharacteristics')) {
     return [ 'multiInstance-outputCollection' ];
   }
 
-  if (isPropertyDependendRequiredError(error, 'outputElement', 'zeebe:LoopCharacteristics')) {
+  if (isPropertyDependendRequiredError(data, 'outputElement', 'zeebe:LoopCharacteristics')) {
     return [ 'multiInstance-outputElement' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:CalledElement', 'bpmn:CallActivity')
-    || isPropertyRequiredError(error, 'processId', 'zeebe:CalledElement')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:CalledElement', 'bpmn:CallActivity')
+    || isPropertyError(data, 'processId', 'zeebe:CalledElement')) {
     return [ 'targetProcessId' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:TaskDefinition')
-    || isPropertyRequiredError(error, 'type', 'zeebe:TaskDefinition')) {
+  if (isExtensionElementRequiredError(data, 'zeebe:TaskDefinition')
+    || isPropertyError(data, 'type', 'zeebe:TaskDefinition')) {
     return [ 'taskDefinitionType' ];
   }
 
-  if (isExtensionElementRequiredError(error, 'zeebe:Subscription')
-    || isPropertyRequiredError(error, 'correlationKey', 'zeebe:Subscription')) {
+  if (isPropertyError(data, 'retries', 'zeebe:TaskDefinition')) {
+    return [ 'taskDefinitionRetries' ];
+  }
+
+  if (isExtensionElementRequiredError(data, 'zeebe:Subscription')
+    || isPropertyError(data, 'correlationKey', 'zeebe:Subscription')) {
     return [ 'messageSubscriptionCorrelationKey' ];
   }
 
-  if (isPropertyRequiredError(error, 'formKey', 'zeebe:FormDefinition')) {
+  if (isPropertyError(data, 'formKey', 'zeebe:FormDefinition')) {
     return [ 'customFormKey' ];
   }
 
-  if (isPropertyRequiredError(error, 'body', 'zeebe:UserTaskForm')) {
+  if (isPropertyError(data, 'body', 'zeebe:UserTaskForm')) {
     return [ 'formConfiguration' ];
   }
 
-  if (isPropertyValueDuplicatedError(error, 'values', 'key', 'zeebe:TaskHeaders')) {
+  if (isPropertyValueDuplicatedError(data, 'values', 'key', 'zeebe:TaskHeaders')) {
     const {
       node,
       properties,
       propertiesName
-    } = error;
+    } = data;
 
     return properties.map(property => {
       const index = node.get(propertiesName).indexOf(property);
@@ -128,40 +133,76 @@ export function getEntryIds(report) {
     });
   }
 
-  if (isExtensionElementNotAllowedError(error, 'zeebe:Properties')) {
-    const { extensionElement } = error;
+  if (isExtensionElementNotAllowedError(data, 'zeebe:Properties')) {
+    const { extensionElement } = data;
 
     return extensionElement.get('zeebe:properties').map((zeebeProperty, index) => {
       return `${ id }-extensionProperty-${ index }-name`;
     });
   }
 
-  if (isPropertyRequiredError(error, 'conditionExpression', 'bpmn:SequenceFlow')) {
+  if (isPropertyError(data, 'conditionExpression', 'bpmn:SequenceFlow')) {
     return [ 'conditionExpression' ];
   }
 
-  if (isPropertyRequiredError(error, 'timeDuration', 'bpmn:TimerEventDefinition')) {
+  if (isPropertyError(data, 'timeDuration', 'bpmn:TimerEventDefinition')) {
     return [ 'timerEventDefinitionDurationValue' ];
   }
 
+  if (isPropertyError(data, 'completionCondition', 'bpmn:MultiInstanceLoopCharacteristics')) {
+    return [ 'multiInstance-completionCondition' ];
+  }
+
   if (TIMER_PROPERTIES.some(property =>
-    isOneOfPropertiesRequiredError(error, property , 'bpmn:TimerEventDefinition'))
+    isOneOfPropertiesRequiredError(data, property, 'bpmn:TimerEventDefinition'))
   ) {
     return [ 'timerEventDefinitionType' ];
   }
 
-  if (isPropertyRequiredError(error, 'body', 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(secondLast(report.path))) {
-    return hasOnlyDurationTimer(error.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  if (isExpressionRequiredError(data, 'timeCycle', 'bpmn:FormalExpression')
+    || isExpressionRequiredError(data, 'timeDate', 'bpmn:FormalExpression')
+    || isExpressionRequiredError(data, 'timeDuration', 'bpmn:FormalExpression')) {
+    return hasOnlyDurationTimer(data.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
   }
 
-  if (isPropertyValueNotAllowedError(error, 'body', 'bpmn:FormalExpression') && TIMER_PROPERTIES.includes(secondLast(report.path))) {
-    return hasOnlyDurationTimer(error.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  if (isExpressionValueNotAllowedError(data, 'timeCycle', 'bpmn:FormalExpression')
+    || isExpressionValueNotAllowedError(data, 'timeDate', 'bpmn:FormalExpression')
+    || isExpressionValueNotAllowedError(data, 'timeDuration', 'bpmn:FormalExpression')) {
+    return hasOnlyDurationTimer(data.parentNode) ? [ 'timerEventDefinitionDurationValue' ] : [ 'timerEventDefinitionValue' ];
+  }
+
+  const LIST_PROPERTIES = [
+    [ 'zeebe:Input', 'input' ],
+    [ 'zeebe:Output', 'output' ],
+    [ 'zeebe:Property', 'extensionProperty' ],
+    [ 'zeebe:Header', 'header' ]
+  ];
+
+  for (const [ type, prefix ] of LIST_PROPERTIES) {
+    if (hasType(data, type)
+        && getPropertyName(data)) {
+
+      const index = path[path.length - 2];
+
+      return [ `${ id }-${prefix}-${index}-${ getPropertyName(data) }` ];
+    }
+  }
+
+  if (hasType(data, 'zeebe:LoopCharacteristics')) {
+    return [ `multiInstance-${getPropertyName(data)}` ];
   }
 
   return [];
 }
 
 export function getErrorMessage(id, report) {
+  const { data } = report;
+
+  // do not override FEEL message
+  if (data.type === ERROR_TYPES.FEEL_EXPRESSION_INVALID) {
+    return;
+  }
+
   if (id === 'businessRuleImplementation') {
     return 'Implementation must be defined.';
   }
@@ -235,16 +276,16 @@ export function getErrorMessage(id, report) {
   }
 
   if (id === 'timerEventDefinitionDurationValue') {
-    return report.error.type === ERROR_TYPES.PROPERTY_REQUIRED ?
+    return data.type === ERROR_TYPES.EXPRESSION_REQUIRED ?
       'Duration must be defined.' : 'Must be an expression, or an ISO 8601 interval.';
   }
 
   if (id === 'timerEventDefinitionValue') {
-    if (report.error.type === ERROR_TYPES.PROPERTY_REQUIRED) {
+    if (data.type === ERROR_TYPES.EXPRESSION_REQUIRED) {
       return 'Value must be defined.';
     }
 
-    const property = secondLast(report.path);
+    const { property } = data;
 
     if (property === 'timeCycle') {
       return 'Must be an expression, an ISO 8601 repeating interval, or a cron expression (cron requires Camunda Platform 8.1 or newer).';
@@ -260,56 +301,68 @@ export function getErrorMessage(id, report) {
   }
 }
 
-function isExtensionElementNotAllowedError(error, extensionElement, type) {
-  return error.type === ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED
-    && is(error.extensionElement, extensionElement)
-    && (!type || is(error.node, type));
+function isExtensionElementNotAllowedError(data, extensionElement, type) {
+  return data.type === ERROR_TYPES.EXTENSION_ELEMENT_NOT_ALLOWED
+    && is(data.extensionElement, extensionElement)
+    && (!type || is(data.node, type));
 }
 
-function isExtensionElementRequiredError(error, requiredExtensionElement, type) {
-  return error.type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED
-    && (isArray(error.requiredExtensionElement) && error.requiredExtensionElement.includes(requiredExtensionElement)
-      || error.requiredExtensionElement === requiredExtensionElement)
-    && (!type || is(error.node, type));
+function isExtensionElementRequiredError(data, requiredExtensionElement, type) {
+  return data.type === ERROR_TYPES.EXTENSION_ELEMENT_REQUIRED
+    && (isArray(data.requiredExtensionElement) && data.requiredExtensionElement.includes(requiredExtensionElement)
+      || data.requiredExtensionElement === requiredExtensionElement)
+    && (!type || is(data.node, type));
 }
 
-function isPropertyDependendRequiredError(error, dependendRequiredProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED
-    && error.dependendRequiredProperty === dependendRequiredProperty
-    && (!type || is(error.node, type));
+function isPropertyDependendRequiredError(data, dependendRequiredProperty, type) {
+  return data.type === ERROR_TYPES.PROPERTY_DEPENDEND_REQUIRED
+    && data.dependendRequiredProperty === dependendRequiredProperty
+    && (!type || is(data.node, type));
 }
 
-function isPropertyRequiredError(error, requiredProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_REQUIRED
-    && (error.requiredProperty === requiredProperty)
-    && (!type || is(error.node, type));
+
+function isPropertyError(data, property, type) {
+  return getPropertyName(data) === property
+    && (!type || is(data.node, type));
 }
 
-function isOneOfPropertiesRequiredError(error, requiredProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_REQUIRED
-    && (isArray(error.requiredProperty) && error.requiredProperty.includes(requiredProperty))
-    && (!type || is(error.node, type));
+function hasType(data, type) {
+  return data.node && is(data.node, type);
 }
 
-function isPropertyValueDuplicatedError(error, propertiesName, duplicatedProperty, type) {
-  return error.type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED
-    && error.propertiesName === propertiesName
-    && error.duplicatedProperty === duplicatedProperty
-    && (!type || is(error.node, type));
+function getPropertyName(data) {
+  const propertyKey = data.type === ERROR_TYPES.PROPERTY_REQUIRED ? 'requiredProperty' : 'property';
+
+  return data[ propertyKey ];
 }
 
-function isPropertyValueNotAllowedError(error, propertyName, type) {
-  return error.type === ERROR_TYPES.PROPERTY_VALUE_NOT_ALLOWED
-    && error.property === propertyName
-    && (!type || is(error.node, type));
+function isOneOfPropertiesRequiredError(data, requiredProperty, type) {
+  return data.type === ERROR_TYPES.PROPERTY_REQUIRED
+    && (isArray(data.requiredProperty) && data.requiredProperty.includes(requiredProperty))
+    && (!type || is(data.node, type));
 }
 
-function getBusinessObject(element) {
-  return element.businessObject || element;
+function isPropertyValueDuplicatedError(data, propertiesName, duplicatedProperty, type) {
+  return data.type === ERROR_TYPES.PROPERTY_VALUE_DUPLICATED
+    && data.propertiesName === propertiesName
+    && data.duplicatedProperty === duplicatedProperty
+    && (!type || is(data.node, type));
 }
 
-function secondLast(array) {
-  return array[array.length - 2];
+function isExpressionRequiredError(data, propertyName, type) {
+  return data.type === ERROR_TYPES.EXPRESSION_REQUIRED
+    && data.property === propertyName
+    && (!type || is(data.node, type));
+}
+
+function isExpressionValueNotAllowedError(data, propertyName, type) {
+  return data.type === ERROR_TYPES.EXPRESSION_VALUE_NOT_ALLOWED
+    && data.property === propertyName
+    && (!type || is(data.node, type));
+}
+
+function getBusinessObject(element) {
+  return element.businessObject || element;
 }
 
 function hasOnlyDurationTimer(node) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/linting",
-  "version": "0.7.2",
+  "version": "0.9.0",
   "description": "Linting for Camunda Platform",
   "main": "index.js",
   "scripts": {
@@ -27,16 +27,16 @@
   "dependencies": {
     "bpmn-moddle": "^7.1.3",
     "bpmnlint": "^8.0.0",
-    "bpmnlint-plugin-camunda-compat": "^0.13.1",
+    "bpmnlint-plugin-camunda-compat": "^0.14.1",
     "bpmnlint-utils": "^1.0.2",
     "min-dash": "^4.0.0",
     "min-dom": "^4.0.1",
     "zeebe-bpmn-moddle": "^0.15.0"
   },
   "devDependencies": {
-    "@bpmn-io/properties-panel": "^0.20.2",
+    "@bpmn-io/properties-panel": "^0.23.0",
     "bpmn-js": "^9.4.0",
-    "bpmn-js-properties-panel": "^1.6.1",
+    "bpmn-js-properties-panel": "^1.10.0",
     "chai": "^4.3.6",
     "cross-env": "^7.0.3",
     "eslint": "^8.23.1",
@@ -57,7 +57,7 @@
     "webpack": "^5.74.0"
   },
   "peerDependencies": {
-    "bpmn-js-properties-panel": "^1.3.0"
+    "bpmn-js-properties-panel": ">= 1.10.0"
   },
   "peerDependenciesMeta": {
     "bpmn-js-properties-panel": {