bpmnlint 11.10.0 → 11.12.0

package/lib/support/compile-config.js

@@ -77,17 +77,20 @@ const config = {
   rules: rules
 };
 
+const moddleExtensions = {};
+
 const bundle = {
   resolver: resolver,
-  config: config
+  config: config,
+  moddleExtensions: moddleExtensions
 };
 
-export { resolver, config };
+export { resolver, config, moddleExtensions };
 
 export default bundle;
 `;
 
-  const importCode = Object.entries(rules).map(([ key, value ], idx) => {
+  const ruleImportCode = Object.entries(rules).map(([ key, value ], idx) => {
 
     if (!value) {
       return null;
@@ -97,10 +100,19 @@ export default bundle;
       pkg, ruleName
     } = linter.parseRuleName(key);
 
-    return createImportStatement(pkg, ruleName, idx, resolver);
+    return createRuleImportStatement(pkg, ruleName, idx, resolver);
+  }).filter(e => e).join('\n');
+
+  const moddleExtensionsImportCode = Object.entries(config.moddleExtensions || {}).map(([ key, importPath ], idx) => {
+
+    if (typeof importPath !== 'string') {
+      throw new Error(`illegal value for moddle-extension ${key}: expected <string>`);
+    }
+
+    return createModdleExtensionStatement(key, importPath, idx);
   }).filter(e => e).join('\n');
 
-  return `${preambleCode}${importCode}`;
+  return `${preambleCode}${ruleImportCode}\n${moddleExtensionsImportCode}`;
 }
 
 module.exports = compileConfig;
@@ -113,7 +125,7 @@ function requirePkg(resolver, pkg) {
   }
 }
 
-function createImportStatement(pkg, ruleName, idx, resolver) {
+function createRuleImportStatement(pkg, ruleName, idx, resolver) {
   const originalPkg = pkg;
 
   pkg = resolver.normalizePkg(pkg);
@@ -150,6 +162,23 @@ import rule_${ idx } from '${ pkg }/rules/${ ruleName }';
 cache['${ originalPkg }/${ ruleName }'] = rule_${ idx };`;
 }
 
+
+/**
+ * @param {string} key
+ * @param {string} importPath
+ * @param {number} idx
+ *
+ * @return {string}
+ */
+function createModdleExtensionStatement(key, importPath, idx) {
+
+  // (2) resolve rule via $PKG/rules/$NAME
+  return `
+import moddle_extension_${ idx } from '${ importPath }';
+
+moddleExtensions['${key}'] = moddle_extension_${ idx };`;
+}
+
 function computeRuleImport(resolver, pkg, originalPkg, rule) {
 
   // local reference, resolved relative to pkg location

package/lib/testers/helper.js

@@ -3,16 +3,37 @@ const { BpmnModdle } = require('bpmn-moddle');
 
 const { readFileSync } = require('node:fs');
 
+/**
+ * @typedef { any } ModdleElement
+ *
+ * @typedef { {
+ *   root: ModdleElement,
+ *   moddle: BpmnModdle,
+ *   warnings: any[]
+ * } } CreatedModdle
+ */
 
 /**
  * Create moddle instance.
  *
- * @param {String} xml the XML string
+ * @param {string} xml the XML string
+ * @param {string} [elementType]
+ * @param {Object} [moddleExtensions]
  *
- * @return {Promise<Object>}
+ * @return {Promise<CreatedModdle>}
  */
-async function createModdle(xml, elementType = 'bpmn:Definitions') {
-  const moddle = new BpmnModdle();
+async function createModdle(xml, elementType = 'bpmn:Definitions', moddleExtensions) {
+
+  if (typeof elementType !== 'string') {
+    moddleExtensions = elementType;
+    elementType = undefined;
+  }
+
+  if (typeof elementType === 'undefined') {
+    elementType = 'bpmn:Definitions';
+  }
+
+  const moddle = new BpmnModdle(moddleExtensions);
 
   const {
     rootElement: root,
@@ -22,6 +43,8 @@ async function createModdle(xml, elementType = 'bpmn:Definitions') {
   return {
     root,
     moddle,
+
+    // @ts-ignore-next-line "legacy"
     context: {
       warnings
     },
@@ -35,14 +58,16 @@ module.exports.createModdle = createModdle;
 /**
  * Return moddle instance, read from the given file.
  *
- * @param {String} filePath
+ * @param {string|URL} filePath
+ * @param {string} [elementType]
+ * @param {Object} [moddleExtensions]
  *
- * @return {Promise<Object>}
+ * @return {Promise<CreatedModdle>}
  */
-function readModdle(filePath) {
+function readModdle(filePath, elementType, moddleExtensions) {
   const contents = readFileSync(filePath, 'utf8');
 
-  return createModdle(contents);
+  return createModdle(contents, elementType, moddleExtensions);
 }
 
 module.exports.readModdle = readModdle;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bpmnlint",
   "description": "Validate your BPMN diagrams based on configurable lint rules",
-  "version": "11.10.0",
+  "version": "11.12.0",
   "main": "lib/index.js",
   "keywords": [
     "bpmnlint",
@@ -31,7 +31,7 @@
     "lint": "eslint .",
     "lint:types": "tsc",
     "dev": "npm test -- --watch",
-    "test": "mocha --exclude 'test/integration/*/**' 'test/**/*.*js'",
+    "test": "mocha --exclude \"test/integration/*/**\" \"test/**/*.*js\"",
     "test-coverage": "nyc --reporter=lcov --reporter=html npm test",
     "generate-docs-images": "npx @bpmn-io/bpmnlint-generate-docs-images ."
   },
@@ -51,7 +51,7 @@
     "tiny-glob": "^0.2.9"
   },
   "devDependencies": {
-    "@bpmn-io/bpmnlint-generate-docs-images": "^1.1.0",
+    "@bpmn-io/bpmnlint-generate-docs-images": "^1.2.0",
     "@types/mocha": "^10.0.10",
     "chai": "^6.2.2",
     "eslint": "^9.39.2",

package/rules/ad-hoc-sub-process.js

@@ -11,7 +11,6 @@ const {
  * A rule that ensures that an Ad Hoc Sub Process is valid according to the BPMN spec:
  *
  * - No start or end events
- * - Every intermediate event has an outgoing sequence flow
  *
  * @type { import('../lib/types.js').RuleFactory }
  */