bpmn-js 9.4.1 → 10.0.0

package/lib/BaseViewer.js

@@ -107,13 +107,13 @@ inherits(BaseViewer, Diagram);
  *
  * Returns {Promise<ImportXMLResult, ImportXMLError>}
  */
-BaseViewer.prototype.importXML = wrapForCompatibility(function importXML(xml, bpmnDiagram) {
+BaseViewer.prototype.importXML = wrapForCompatibility(async function importXML(xml, bpmnDiagram) {
 
-  var self = this;
+  const self = this;
 
   function ParseCompleteEvent(data) {
 
-    var event = self.get('eventBus').createEvent(data);
+    const event = self.get('eventBus').createEvent(data);
 
     // TODO(nikku): remove with future bpmn-js version
     Object.defineProperty(event, 'context', {
@@ -136,54 +136,59 @@ BaseViewer.prototype.importXML = wrapForCompatibility(function importXML(xml, bp
     return event;
   }
 
-  return new Promise(function(resolve, reject) {
+  let aggregatedWarnings = [];
+  try {
 
     // hook in pre-parse listeners +
     // allow xml manipulation
-    xml = self._emit('import.parse.start', { xml: xml }) || xml;
+    xml = this._emit('import.parse.start', { xml: xml }) || xml;
 
-    self._moddle.fromXML(xml, 'bpmn:Definitions').then(function(result) {
-      var definitions = result.rootElement;
-      var references = result.references;
-      var parseWarnings = result.warnings;
-      var elementsById = result.elementsById;
+    let parseResult;
+    try {
+      parseResult = await this._moddle.fromXML(xml, 'bpmn:Definitions');
+    } catch (error) {
+      this._emit('import.parse.complete', {
+        error
+      });
 
-      // hook in post parse listeners +
-      // allow definitions manipulation
-      definitions = self._emit('import.parse.complete', ParseCompleteEvent({
-        error: null,
-        definitions: definitions,
-        elementsById: elementsById,
-        references: references,
-        warnings: parseWarnings
-      })) || definitions;
+      throw error;
+    }
 
-      self.importDefinitions(definitions, bpmnDiagram).then(function(result) {
-        var allWarnings = [].concat(parseWarnings, result.warnings || []);
+    let definitions = parseResult.rootElement;
+    const references = parseResult.references;
+    const parseWarnings = parseResult.warnings;
+    const elementsById = parseResult.elementsById;
 
-        self._emit('import.done', { error: null, warnings: allWarnings });
+    aggregatedWarnings = aggregatedWarnings.concat(parseWarnings);
 
-        return resolve({ warnings: allWarnings });
-      }).catch(function(err) {
-        var allWarnings = [].concat(parseWarnings, err.warnings || []);
+    // hook in post parse listeners +
+    // allow definitions manipulation
+    definitions = this._emit('import.parse.complete', ParseCompleteEvent({
+      error: null,
+      definitions: definitions,
+      elementsById: elementsById,
+      references: references,
+      warnings: aggregatedWarnings
+    })) || definitions;
 
-        self._emit('import.done', { error: err, warnings: allWarnings });
+    const importResult = await this.importDefinitions(definitions, bpmnDiagram);
 
-        return reject(addWarningsToError(err, allWarnings));
-      });
-    }).catch(function(err) {
+    aggregatedWarnings = aggregatedWarnings.concat(importResult.warnings);
 
-      self._emit('import.parse.complete', {
-        error: err
-      });
+    this._emit('import.done', { error: null, warnings: aggregatedWarnings });
 
-      err = checkValidationError(err);
+    return { warnings: aggregatedWarnings };
+  } catch (err) {
+    let error = err;
+    aggregatedWarnings = aggregatedWarnings.concat(error.warnings || []);
+    addWarningsToError(error, aggregatedWarnings);
 
-      self._emit('import.done', { error: err, warnings: err.warnings });
+    error = checkValidationError(error);
 
-      return reject(err);
-    });
-  });
+    this._emit('import.done', { error, warnings: error.warnings });
+
+    throw error;
+  }
 });
 
 /**
@@ -222,24 +227,11 @@ BaseViewer.prototype.importXML = wrapForCompatibility(function importXML(xml, bp
  *
  * Returns {Promise<ImportDefinitionsResult, ImportDefinitionsError>}
  */
-BaseViewer.prototype.importDefinitions = wrapForCompatibility(function importDefinitions(definitions, bpmnDiagram) {
-
-  var self = this;
-
-  return new Promise(function(resolve, reject) {
-
-    self._setDefinitions(definitions);
-
-    self.open(bpmnDiagram).then(function(result) {
+BaseViewer.prototype.importDefinitions = wrapForCompatibility(async function importDefinitions(definitions, bpmnDiagram) {
+  this._setDefinitions(definitions);
+  const result = await this.open(bpmnDiagram);
 
-      var warnings = result.warnings;
-
-      return resolve({ warnings: warnings });
-    }).catch(function(err) {
-
-      return reject(err);
-    });
-  });
+  return { warnings: result.warnings };
 });
 
 /**
@@ -277,50 +269,43 @@ BaseViewer.prototype.importDefinitions = wrapForCompatibility(function importDef
  *
  * Returns {Promise<OpenResult, OpenError>}
  */
-BaseViewer.prototype.open = wrapForCompatibility(function open(bpmnDiagramOrId) {
-
-  var definitions = this._definitions;
-  var bpmnDiagram = bpmnDiagramOrId;
-
-  var self = this;
-
-  return new Promise(function(resolve, reject) {
-    if (!definitions) {
-      var err1 = new Error('no XML imported');
+BaseViewer.prototype.open = wrapForCompatibility(async function open(bpmnDiagramOrId) {
 
-      return reject(addWarningsToError(err1, []));
-    }
+  const definitions = this._definitions;
+  let bpmnDiagram = bpmnDiagramOrId;
 
-    if (typeof bpmnDiagramOrId === 'string') {
-      bpmnDiagram = findBPMNDiagram(definitions, bpmnDiagramOrId);
+  if (!definitions) {
+    const error = new Error('no XML imported');
+    addWarningsToError(error, []);
 
-      if (!bpmnDiagram) {
-        var err2 = new Error('BPMNDiagram <' + bpmnDiagramOrId + '> not found');
+    throw error;
+  }
 
-        return reject(addWarningsToError(err2, []));
-      }
-    }
+  if (typeof bpmnDiagramOrId === 'string') {
+    bpmnDiagram = findBPMNDiagram(definitions, bpmnDiagramOrId);
 
-    // clear existing rendered diagram
-    // catch synchronous exceptions during #clear()
-    try {
-      self.clear();
-    } catch (error) {
+    if (!bpmnDiagram) {
+      const error = new Error('BPMNDiagram <' + bpmnDiagramOrId + '> not found');
+      addWarningsToError(error, []);
 
-      return reject(addWarningsToError(error, []));
+      throw error;
     }
+  }
 
-    // perform graphical import
-    importBpmnDiagram(self, definitions, bpmnDiagram).then(function(result) {
+  // clear existing rendered diagram
+  // catch synchronous exceptions during #clear()
+  try {
+    this.clear();
+  } catch (error) {
+    addWarningsToError(error, []);
 
-      var warnings = result.warnings;
+    throw error;
+  }
 
-      return resolve({ warnings: warnings });
-    }).catch(function(err) {
+  // perform graphical import
+  const { warnings } = await importBpmnDiagram(this, definitions, bpmnDiagram);
 
-      return reject(err);
-    });
-  });
+  return { warnings };
 });
 
 /**
@@ -351,53 +336,42 @@ BaseViewer.prototype.open = wrapForCompatibility(function open(bpmnDiagramOrId)
  *
  * Returns {Promise<SaveXMLResult, Error>}
  */
-BaseViewer.prototype.saveXML = wrapForCompatibility(function saveXML(options) {
+BaseViewer.prototype.saveXML = wrapForCompatibility(async function saveXML(options) {
 
   options = options || {};
 
-  var self = this;
-
-  var definitions = this._definitions;
-
-  return new Promise(function(resolve) {
+  let definitions = this._definitions,
+      error, xml;
 
+  try {
     if (!definitions) {
-      return resolve({
-        error: new Error('no definitions loaded')
-      });
+      throw new Error('no definitions loaded');
     }
 
     // allow to fiddle around with definitions
-    definitions = self._emit('saveXML.start', {
-      definitions: definitions
+    definitions = this._emit('saveXML.start', {
+      definitions
     }) || definitions;
 
-    self._moddle.toXML(definitions, options).then(function(result) {
+    const result = await this._moddle.toXML(definitions, options);
+    xml = result.xml;
 
-      var xml = result.xml;
-
-      xml = self._emit('saveXML.serialized', {
-        xml: xml
-      }) || xml;
-
-      return resolve({
-        xml: xml
-      });
-    });
-  }).catch(function(error) {
-    return { error: error };
-  }).then(function(result) {
+    xml = this._emit('saveXML.serialized', {
+      xml
+    }) || xml;
+  } catch (err) {
+    error = err;
+  }
 
-    self._emit('saveXML.done', result);
+  const result = error ? { error } : { xml };
 
-    var error = result.error;
+  this._emit('saveXML.done', result);
 
-    if (error) {
-      return Promise.reject(error);
-    }
+  if (error) {
+    throw error;
+  }
 
-    return result;
-  });
+  return result;
 });
 
 /**
@@ -425,53 +399,45 @@ BaseViewer.prototype.saveXML = wrapForCompatibility(function saveXML(options) {
  *
  * Returns {Promise<SaveSVGResult, Error>}
  */
-BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) {
-
-  options = options || {};
-
-  var self = this;
+BaseViewer.prototype.saveSVG = wrapForCompatibility(async function saveSVG(options = {}) {
+  this._emit('saveSVG.start');
 
-  return new Promise(function(resolve, reject) {
+  let svg, err;
 
-    self._emit('saveSVG.start');
-
-    var svg, err;
-
-    try {
-      var canvas = self.get('canvas');
+  try {
+    const canvas = this.get('canvas');
 
-      var contentNode = canvas.getActiveLayer(),
+    const contentNode = canvas.getActiveLayer(),
           defsNode = domQuery('defs', canvas._svg);
 
-      var contents = innerSVG(contentNode),
+    const contents = innerSVG(contentNode),
           defs = defsNode ? '<defs>' + innerSVG(defsNode) + '</defs>' : '';
 
-      var bbox = contentNode.getBBox();
-
-      svg =
-        '<?xml version="1.0" encoding="utf-8"?>\n' +
-        '<!-- created with bpmn-js / http://bpmn.io -->\n' +
-        '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n' +
-        '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" ' +
-             'width="' + bbox.width + '" height="' + bbox.height + '" ' +
-             'viewBox="' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '" version="1.1">' +
-          defs + contents +
-        '</svg>';
-    } catch (e) {
-      err = e;
-    }
+    const bbox = contentNode.getBBox();
+
+    svg =
+      '<?xml version="1.0" encoding="utf-8"?>\n' +
+      '<!-- created with bpmn-js / http://bpmn.io -->\n' +
+      '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">\n' +
+      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" ' +
+      'width="' + bbox.width + '" height="' + bbox.height + '" ' +
+      'viewBox="' + bbox.x + ' ' + bbox.y + ' ' + bbox.width + ' ' + bbox.height + '" version="1.1">' +
+      defs + contents +
+      '</svg>';
+  } catch (e) {
+    err = e;
+  }
 
-    self._emit('saveSVG.done', {
-      error: err,
-      svg: svg
-    });
+  this._emit('saveSVG.done', {
+    error: err,
+    svg: svg
+  });
 
-    if (!err) {
-      return resolve({ svg: svg });
-    }
+  if (err) {
+    throw err;
+  }
 
-    return reject(err);
-  });
+  return { svg };
 });
 
 /**
@@ -479,8 +445,8 @@ BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) {
  *
  * @example
  *
- * var elementRegistry = viewer.get('elementRegistry');
- * var startEventShape = elementRegistry.get('StartEvent_1');
+ * const elementRegistry = viewer.get('elementRegistry');
+ * const startEventShape = elementRegistry.get('StartEvent_1');
  *
  * @param {string} name
  *
@@ -495,7 +461,7 @@ BaseViewer.prototype.saveSVG = wrapForCompatibility(function saveSVG(options) {
  * @example
  *
  * viewer.invoke(function(elementRegistry) {
- *   var startEventShape = elementRegistry.get('StartEvent_1');
+ *   const startEventShape = elementRegistry.get('StartEvent_1');
  * });
  *
  * @param {Function} fn to be invoked
@@ -602,8 +568,8 @@ BaseViewer.prototype.getDefinitions = function() {
 
 BaseViewer.prototype.detach = function() {
 
-  var container = this._container,
-      parentNode = container.parentNode;
+  const container = this._container,
+        parentNode = container.parentNode;
 
   if (!parentNode) {
     return;
@@ -616,18 +582,18 @@ BaseViewer.prototype.detach = function() {
 
 BaseViewer.prototype._init = function(container, moddle, options) {
 
-  var baseModules = options.modules || this.getModules(),
-      additionalModules = options.additionalModules || [],
-      staticModules = [
-        {
-          bpmnjs: [ 'value', this ],
-          moddle: [ 'value', moddle ]
-        }
-      ];
+  const baseModules = options.modules || this.getModules(),
+        additionalModules = options.additionalModules || [],
+        staticModules = [
+          {
+            bpmnjs: [ 'value', this ],
+            moddle: [ 'value', moddle ]
+          }
+        ];
 
-  var diagramModules = [].concat(staticModules, baseModules, additionalModules);
+  const diagramModules = [].concat(staticModules, baseModules, additionalModules);
 
-  var diagramOptions = assign(omit(options, [ 'additionalModules' ]), {
+  const diagramOptions = assign(omit(options, [ 'additionalModules' ]), {
     canvas: assign({}, options.canvas, { container: container }),
     modules: diagramModules
   });
@@ -654,7 +620,7 @@ BaseViewer.prototype._emit = function(type, event) {
 
 BaseViewer.prototype._createContainer = function(options) {
 
-  var container = domify('<div class="bjs-container"></div>');
+  const container = domify('<div class="bjs-container"></div>');
 
   assignStyle(container, {
     width: ensureUnit(options.width),
@@ -666,7 +632,7 @@ BaseViewer.prototype._createContainer = function(options) {
 };
 
 BaseViewer.prototype._createModdle = function(options) {
-  var moddleOptions = assign({}, this._moddleExtensions, options.moddleExtensions);
+  const moddleOptions = assign({}, this._moddleExtensions, options.moddleExtensions);
 
   return new BpmnModdle(moddleOptions);
 };
@@ -685,8 +651,8 @@ function checkValidationError(err) {
   // check if we can help the user by indicating wrong BPMN 2.0 xml
   // (in case he or the exporting tool did not get that right)
 
-  var pattern = /unparsable content <([^>]+)> detected([\s\S]*)$/;
-  var match = pattern.exec(err.message);
+  const pattern = /unparsable content <([^>]+)> detected([\s\S]*)$/;
+  const match = pattern.exec(err.message);
 
   if (match) {
     err.message =
@@ -697,7 +663,7 @@ function checkValidationError(err) {
   return err;
 }
 
-var DEFAULT_OPTIONS = {
+const DEFAULT_OPTIONS = {
   width: '100%',
   height: '100%',
   position: 'relative'
@@ -753,18 +719,18 @@ import {
  * @param {Element} container
  */
 function addProjectLogo(container) {
-  var img = BPMNIO_IMG;
+  const img = BPMNIO_IMG;
 
-  var linkMarkup =
+  const linkMarkup =
     '<a href="http://bpmn.io" ' +
-       'target="_blank" ' +
-       'class="bjs-powered-by" ' +
-       'title="Powered by bpmn.io" ' +
-      '>' +
-      img +
+    'target="_blank" ' +
+    'class="bjs-powered-by" ' +
+    'title="Powered by bpmn.io" ' +
+    '>' +
+    img +
     '</a>';
 
-  var linkElement = domify(linkMarkup);
+  const linkElement = domify(linkMarkup);
 
   assignStyle(domQuery('svg', linkElement), LOGO_STYLES);
   assignStyle(linkElement, LINK_STYLES, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bpmn-js",
-  "version": "9.4.1",
+  "version": "10.0.0",
   "description": "A bpmn 2.0 toolkit and web modeler",
   "main": "index.js",
   "files": [
@@ -66,7 +66,7 @@
     "cross-env": "^7.0.3",
     "del": "^6.0.0",
     "eslint": "^8.22.0",
-    "eslint-plugin-bpmn-io": "^0.14.1",
+    "eslint-plugin-bpmn-io": "^0.15.1",
     "eslint-plugin-import": "^2.26.0",
     "execa": "^5.1.1",
     "karma": "^6.4.0",