bpmnlint 11.15.0 → 12.0.0

package/lib/resolver/static-resolver.js

@@ -1,48 +1 @@
-/**
- * @typedef { import('../types.js').RuleFactory } RuleFactory
- * @typedef { import('../types.js').Config } Config
- */
-
-
-/**
- * A resolver that resolves rules and packages from a static cache.
- *
- * @param { any } cache
- */
-function StaticResolver(cache) {
-  this.cache = cache;
-}
-
-module.exports = StaticResolver;
-
-/**
- * @param { string } pkg
- * @param { string } ruleName
- *
- * @return { RuleFactory }
- */
-StaticResolver.prototype.resolveRule = function(pkg, ruleName) {
-  return /** @type { RuleFactory } */ (this.resolve('rule', pkg, ruleName));
-};
-
-/**
- * @param { string } pkg
- * @param { string } configName
- *
- * @return { Config }
- */
-StaticResolver.prototype.resolveConfig = function(pkg, configName) {
-  return /** @type { Config } */ (this.resolve('config', pkg, configName));
-};
-
-StaticResolver.prototype.resolve = function(type, pkg, name) {
-  const id = `${pkg}/${name}`;
-
-  const resolved = this.cache[`${type}:${id}`];
-
-  if (!resolved) {
-    throw new Error(`unknown ${type} <${id}>`);
-  }
-
-  return resolved;
-};
+module.exports = require('@bpmn-io/lint-core/lib/resolver/static-resolver');

package/lib/support/compile-config.js

@@ -1,201 +1,6 @@
-const path = require('path');
+const { createCompileConfig } = require('@bpmn-io/lint-core/lib/support/compile-config');
 
-const { isString } = require('min-dash');
-
-const Linter = require('../linter');
-
-const NodeResolver = require('../resolver/node-resolver');
-
-/**
- * Compile the bpmnlint configuration to a JavaScript file that exports
- * a { config, resolver } bundle, resolving all enabled rules.
- *
- * @param  {Object} config the parsed bpmnlint configuration
- * @param  {NodeResolver} [resolver]
- * @return {Promise<String>} the configuration compiled to a JS file
- */
-async function compileConfig(config, resolver) {
-
-  resolver = resolver || new NodeResolver();
-
-  const linter = new Linter({
-    resolver
-  });
-
-  const resolvedRules = await linter.resolveConfiguredRules(config);
-
-  // only process and serialize enabled rules
-  const rules = Object.keys(resolvedRules).reduce(function(rules, key) {
-    const value = resolvedRules[key];
-
-    const { category } = linter.parseRuleValue(value);
-
-    if (category === 'off') {
-      rules[key] = 0;
-    } else {
-      rules[key] = value;
-    }
-
-    return rules;
-  }, {});
-
-  const serializedRules = JSON.stringify(rules, null, '  ');
-
-  const preambleCode = `
-const cache = {};
-
-/**
- * A resolver that caches rules and configuration as part of the bundle,
- * making them accessible in the browser.
- *
- * @param {Object} cache
- */
-function Resolver() {}
-
-Resolver.prototype.resolveRule = function(pkg, ruleName) {
-
-  const rule = cache[pkg + '/' + ruleName];
-
-  if (!rule) {
-    throw new Error('cannot resolve rule <' + pkg + '/' + ruleName + '>: not bundled');
-  }
-
-  return rule;
-};
-
-Resolver.prototype.resolveConfig = function(pkg, configName) {
-  throw new Error(
-    'cannot resolve config <' + configName + '> in <' + pkg +'>: not bundled'
-  );
-};
-
-const resolver = new Resolver();
-
-const rules = ${serializedRules};
-
-const config = {
-  rules: rules
-};
-
-const moddleExtensions = {};
-
-const bundle = {
-  resolver: resolver,
-  config: config,
-  moddleExtensions: moddleExtensions
-};
-
-export { resolver, config, moddleExtensions };
-
-export default bundle;
-`;
-
-  const ruleImportCode = Object.entries(rules).map(([ key, value ], idx) => {
-
-    if (!value) {
-      return null;
-    }
-
-    const {
-      pkg, ruleName
-    } = linter.parseRuleName(key);
-
-    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}${ruleImportCode}\n${moddleExtensionsImportCode}`;
-}
-
-module.exports = compileConfig;
-
-function requirePkg(resolver, pkg) {
-  try {
-    return resolver.require(pkg);
-  } catch (err) {
-    return null;
-  }
-}
-
-function createRuleImportStatement(pkg, ruleName, idx, resolver) {
-  const originalPkg = pkg;
-
-  pkg = resolver.normalizePkg(pkg);
-
-  const pkgExport = requirePkg(resolver, pkg);
-
-  // (1) try resolving rule via $PKG.rules[$NAME]
-  if (pkgExport && pkgExport.rules) {
-    const rules = pkgExport.rules;
-
-    if (ruleName in rules) {
-      const rule = rules[ruleName];
-
-      if (!isString(rule)) {
-        throw new Error(
-          `failed to bundle rule <${ruleName}> from <${ pkg }>: illegal rule export (expected path reference)`
-        );
-      }
-
-      const rulePath = computeRuleImport(resolver, pkg, originalPkg, rule);
-
-      return `
-import rule_${ idx } from '${rulePath}';
-
-cache['${ originalPkg }/${ ruleName }'] = rule_${ idx };`;
-
-    }
-  }
-
-  // (2) resolve rule via $PKG/rules/$NAME
-  return `
-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
-  if (rule.startsWith('.')) {
-    const pkgJsonPath = resolver.require.resolve(`${ pkg }/package.json`);
-
-    const pkgMainPath = resolver.require.resolve(pkg);
-
-    const relativePkgMainPath = path.relative(
-      path.dirname(pkgJsonPath),
-      path.dirname(pkgMainPath)
-    );
-
-    return path.posix.normalize(`${ originalPkg }/${ relativePkgMainPath }/${ rule }`);
-  } else {
-
-    // absolute reference
-    return path.posix.normalize(rule);
-  }
-}
+module.exports = createCompileConfig({
+  Linter: require('../linter'),
+  NodeResolver: require('../resolver/node-resolver')
+});

package/lib/test-rule.js

@@ -1,107 +1 @@
-const traverse = require('./traverse');
-
-const {
-  isArray,
-  isObject,
-  isFunction
-} = require('min-dash');
-
-
-/**
- * @typedef { import('./types.js').EnterFn } EnterFn
- * @typedef { import('./types.js').ModdleElement } ModdleElement
- * @typedef { import('./types.js').RuleDefinition } RuleDefinition
- * @typedef { import('./types.js').Report } Report
- */
-
-
-class Reporter {
-
-  /**
-   * @param { {
-   *   moddleRoot: ModdleElement,
-   *   rule: RuleDefinition
-   * } } options
-   */
-  constructor({ moddleRoot, rule }) {
-    this.rule = rule;
-    this.moddleRoot = moddleRoot;
-
-    /**
-     * @type { Report[] }
-     */
-    this.messages = [];
-
-    this.report = this.report.bind(this);
-  }
-
-  /**
-   * @param { string } id
-   * @param { string } message
-   * @param { string[] | { path?: string[], [key: string]: any } } [path]
-   *
-   * @example
-   *
-   * ```javascript
-   * reporter.report('foo', 'Foo error', [ 'foo', 'bar', 'baz' ]);
-   *
-   * reporter.report('foo', 'Foo error', {
-   *   path: [ 'foo', 'bar', 'baz' ],
-   *   foo: 'foo'
-   * });
-   * ```
-   */
-  report(id, message, path) {
-    let report = {
-      id,
-      message
-    };
-
-    if (path && isArray(path)) {
-      report = {
-        ...report,
-        path
-      };
-    }
-
-    if (path && isObject(path)) {
-      report = {
-        ...report,
-        ...path
-      };
-    }
-
-    this.messages.push(report);
-  }
-}
-
-/**
- * @param { {
- *   moddleRoot: ModdleElement,
- *   rule: RuleDefinition,
- *   config: any
- * } } options
- *
- * @return { Report[] } lint reports
- */
-module.exports = function testRule({ moddleRoot, rule }) {
-  const reporter = new Reporter({ rule, moddleRoot });
-
-  const check = rule.check || {};
-
-  const leave = 'leave' in check ? check.leave : undefined;
-  const enter = 'enter' in check ? check.enter : (
-    isFunction(check) ? check : undefined
-  );
-
-  if (!enter && !leave) {
-    throw new Error('no check implemented');
-  }
-
-  traverse(moddleRoot, {
-    enter: enter ? (node) => enter(node, reporter) : undefined,
-    leave: leave ? (node) => leave(node, reporter) : undefined
-  });
-
-  return reporter.messages;
-};
+module.exports = require('@bpmn-io/lint-core/lib/test-rule');

package/lib/testers/helper.js

@@ -1,73 +1,17 @@
 // @ts-expect-error 'missing <bpmn-moddle> types'
 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} [elementType]
- * @param {Object} [moddleExtensions]
- *
- * @return {Promise<CreatedModdle>}
- */
-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,
-    warnings = []
-  } = await moddle.fromXML(xml, elementType, { lax: true });
-
-  return {
-    root,
-    moddle,
-
-    // @ts-ignore-next-line "legacy"
-    context: {
-      warnings
-    },
-    warnings
-  };
-}
-
-module.exports.createModdle = createModdle;
-
-
-/**
- * Return moddle instance, read from the given file.
- *
- * @param {string|URL} filePath
- * @param {string} [elementType]
- * @param {Object} [moddleExtensions]
- *
- * @return {Promise<CreatedModdle>}
- */
-function readModdle(filePath, elementType, moddleExtensions) {
-  const contents = readFileSync(filePath, 'utf8');
-
-  return createModdle(contents, elementType, moddleExtensions);
-}
-
-module.exports.readModdle = readModdle;
+const { createModdleHelper } = require('@bpmn-io/lint-core/lib/testers/helper');
+
+const {
+  createModdle,
+  readModdle
+} = createModdleHelper({
+  Moddle: BpmnModdle,
+  rootType: 'bpmn:Definitions'
+});
+
+module.exports = {
+  createModdle,
+  readModdle
+};

package/lib/testers/rule-tester.d.ts

@@ -1,31 +1,13 @@
-export type TestFn = (...any) => any;
+import type { RuleTests } from '@bpmn-io/lint-core/lib/testers/rule-tester';
 
-export type ModdleElement = any;
-
-export type ValidRuleTest = {
-  config?: any,
-  it?: TestFn,
-  moddleElement: ModdleElement,
-  name?: string
-};
-
-export type InvalidReport = {
-  id: string,
-  message: string
-};
-
-export type InvalidRuleTest = {
-  config?: any,
-  it?: TestFn,
-  moddleElement: ModdleElement,
-  name?: string,
-  report: InvalidReport | InvalidReport[]
-};
-
-export type RuleTests = {
-  valid?: ValidRuleTest[],
-  invalid?: InvalidRuleTest[]
-};
+export type {
+  TestFn,
+  ModdleElement,
+  ValidRuleTest,
+  InvalidReport,
+  InvalidRuleTest,
+  RuleTests
+} from '@bpmn-io/lint-core/lib/testers/rule-tester';
 
 /**
  * Verify a rule.
@@ -34,4 +16,4 @@ export type RuleTests = {
  * @param rule the rule implementation
  * @param tests the tests to verify
  */
-export function verify(ruleName: string, rule: any, tests: RuleTests): void;
+export function verify(ruleName: string, rule: any, tests: RuleTests): void;

package/lib/testers/rule-tester.js

@@ -1,147 +1,17 @@
-/* global it, describe, beforeEach */
+const { createRuleTester } = require('@bpmn-io/lint-core/lib/testers/rule-tester');
 
-const assert = require('assert');
-
-const Linter = require('../linter');
-
-function createResolver(rule) {
-
-  return {
-    resolveRule: () => Promise.resolve(rule),
-
-    resolveConfig: () => {
-      throw new Error('not implemented');
-    }
-  };
-}
-
-function expectEqual(a, b) {
-  assert.deepStrictEqual(JSON.stringify(a, replacer, 2), JSON.stringify(b, replacer, 2));
-}
-
-function verify(ruleName, rule, testCases) {
-  function createLinterConfig(config = {}) {
-    return {
-      rules: { [ruleName]: [ 2, config ] }
-    };
-  }
-
-  describe(`rules/${ruleName}`, function() {
-
-    let linter;
-
-    beforeEach(function() {
-      linter = new Linter({
-        resolver: createResolver(rule)
-      });
-    });
-
-
-    describe('should lint valid', function() {
-
-      testCases.valid.forEach(({ config = {}, it: _it, moddleElement, name }, idx) => (
-
-        (_it || it)(getTitle(idx, name), function() {
-          return (
-            Promise.resolve(moddleElement)
-              .then(moddleRoot => {
-                return linter.lint(moddleRoot.root, createLinterConfig(config));
-              })
-              .then(lintResults => {
-                expectEqual(lintResults, {});
-              })
-          );
-        })
-
-      ));
-
-    });
-
-
-    describe('should lint invalid', function() {
-
-      testCases.invalid.forEach(({ config = {}, it: _it, moddleElement, name, report }, idx) => (
-
-        (_it || it)(getTitle(idx, name), async function() {
-
-          if (!Array.isArray(report)) {
-            report = [
-              report
-            ];
-          }
-
-          const {
-            meta
-          } = await linter.resolveRule(name, config);
-
-          const expectedResults = report.map(report => {
-            return {
-              ...report,
-              meta,
-              category: 'error'
-            };
-          });
-
-          const expectedLintResults = {
-            [ruleName]: expectedResults
-          };
-
-          return (
-            Promise.resolve(moddleElement)
-              .then(moddleRoot => {
-                return linter.lint(moddleRoot.root, createLinterConfig(config));
-              })
-              .then(lintResults => {
-                expectEqual(lintResults, expectedLintResults);
-              })
-          );
-        })
-
-      ));
-
-    });
-
-  });
-
-}
-
-function getTitle(idx, name) {
-  return `test case #${ idx + 1 }${ name ? ` ${ name }` : '' }`;
-}
-
-function replacer(_, value) {
-  if (!value) {
-    return value;
-  }
-
-  const { $type } = value;
-
-  if ($type) {
-    const { $descriptor } = value;
-
-    const { idProperty } = $descriptor;
-
-    if (idProperty) {
-      const { name } = idProperty;
-
-      const id = value.get(name);
-
-      if (id) {
-        return id;
-      } else {
-        return $type;
-      }
-    } else {
-      return $type;
-    }
-  }
-
-  return value;
-}
+const {
+  expectEqual,
+  verify,
+  getTitle,
+  replacer
+} = createRuleTester({
+  Linter: require('../linter')
+});
 
 module.exports = {
   expectEqual,
   verify,
   getTitle,
   replacer
-};
+};

package/lib/traverse.js

@@ -1,56 +1 @@
-/**
- * @typedef { import('./types.js').ModdleElement } ModdleElement
- *
- * @typedef { (element: ModdleElement) => boolean | void } EnterFn
- * @typedef { (element: ModdleElement) => void } LeaveFn
- */
-
-/**
- * Check if a type is simple, primitive.
- *
- * @param {string} type
- * @return {boolean}
- */
-function isSimpleType(type) {
-  return [ 'String', 'Boolean', 'Integer', 'Real' ].includes(type);
-}
-
-/**
- * Traverse a moddle tree, depth first from top to bottom
- * and call the passed visitor fn.
- *
- * @param { ModdleElement } element
- * @param { { enter?: EnterFn; leave?: LeaveFn } } options
- */
-module.exports = function traverse(element, options) {
-
-  const enter = options.enter;
-  const leave = options.leave;
-
-  const enterSubTree = enter && enter(element);
-
-  const descriptor = element.$descriptor;
-
-  if (enterSubTree !== false && !descriptor.isGeneric) {
-
-    const containedProperties = descriptor.properties.filter(p => {
-      return !p.isAttr && !p.isReference && !isSimpleType(p.type);
-    });
-
-    containedProperties.forEach(p => {
-      if (p.name in element) {
-        const propertyValue = element[p.name];
-
-        if (p.isMany) {
-          propertyValue.forEach(child => {
-            traverse(child, options);
-          });
-        } else {
-          traverse(propertyValue, options);
-        }
-      }
-    });
-  }
-
-  leave && leave(element);
-};
+module.exports = require('@bpmn-io/lint-core/lib/traverse');