camunda-bpmn-js 3.10.2 → 3.12.0

package/dist/camunda-platform-navigated-viewer.development.js

@@ -27,6 +27,10 @@
     return obj !== undefined;
   }
 
+  function isNil(obj) {
+    return obj == null;
+  }
+
   function isArray$2(obj) {
     return nativeToString$1.call(obj) === '[object Array]';
   }
@@ -475,6 +479,58 @@
     return Object.assign(target, ...others);
   }
 
+  /**
+   * Sets a nested property of a given object to the specified value.
+   *
+   * This mutates the object and returns it.
+   *
+   * @template T
+   *
+   * @param {T} target The target of the set operation.
+   * @param {(string|number)[]} path The path to the nested value.
+   * @param {any} value The value to set.
+   *
+   * @return {T}
+   */
+  function set$2(target, path, value) {
+
+    let currentTarget = target;
+
+    forEach$1(path, function(key, idx) {
+
+      if (typeof key !== 'number' && typeof key !== 'string') {
+        throw new Error('illegal key type: ' + typeof key + '. Key should be of type number or string.');
+      }
+
+      if (key === 'constructor') {
+        throw new Error('illegal key: constructor');
+      }
+
+      if (key === '__proto__') {
+        throw new Error('illegal key: __proto__');
+      }
+
+      let nextKey = path[idx + 1];
+      let nextTarget = currentTarget[key];
+
+      if (isDefined(nextKey) && isNil(nextTarget)) {
+        nextTarget = currentTarget[key] = isNaN(+nextKey) ? {} : [];
+      }
+
+      if (isUndefined$2(nextKey)) {
+        if (isUndefined$2(value)) {
+          delete currentTarget[key];
+        } else {
+          currentTarget[key] = value;
+        }
+      } else {
+        currentTarget = nextTarget;
+      }
+    });
+
+    return target;
+  }
+
   /**
    * Pick properties from the given target.
    *
@@ -713,6 +769,26 @@
     return true;
   }
 
+  /**
+   * @param {Element} element
+   *
+   * @return {boolean}
+   */
+  function isHorizontal(element) {
+
+    if (!is$1(element, 'bpmn:Participant') && !is$1(element, 'bpmn:Lane')) {
+      return undefined;
+    }
+
+    var isHorizontal = getDi(element).isHorizontal;
+
+    if (isHorizontal === undefined) {
+      return true;
+    }
+
+    return isHorizontal;
+  }
+
   /**
    * @param {Element} element
    *
@@ -3772,10 +3848,12 @@
     }
 
     function renderLaneLabel(parentGfx, text, element, attrs = {}) {
+      var isHorizontalLane = isHorizontal(element);
+
       var textBox = renderLabel(parentGfx, text, {
         box: {
           height: 30,
-          width: getHeight(element, attrs),
+          width: isHorizontalLane ? getHeight(element, attrs) : getWidth(element, attrs),
         },
         align: 'center-middle',
         style: {
@@ -3783,9 +3861,10 @@
         }
       });
 
-      var top = -1 * getHeight(element, attrs);
-
-      transform(textBox, 0, -top, 270);
+      if (isHorizontalLane) {
+        var top = -1 * getHeight(element, attrs);
+        transform(textBox, 0, -top, 270);
+      }
     }
 
     function renderActivity(parentGfx, element, attrs = {}) {
@@ -4503,12 +4582,13 @@
         var participant = renderLane(parentGfx, element, attrs);
 
         var expandedParticipant = isExpanded(element);
+        var horizontalParticipant = isHorizontal(element);
 
         var semantic = getBusinessObject(element),
             name = semantic.get('name');
 
         if (expandedParticipant) {
-          drawLine(parentGfx, [
+          var waypoints = horizontalParticipant ? [
             {
               x: 30,
               y: 0
@@ -4517,20 +4597,43 @@
               x: 30,
               y: getHeight(element, attrs)
             }
-          ], {
+          ] : [
+            {
+              x: 0,
+              y: 30
+            },
+            {
+              x: getWidth(element, attrs),
+              y: 30
+            }
+          ];
+
+          drawLine(parentGfx, waypoints, {
             stroke: getStrokeColor(element, defaultStrokeColor, attrs.stroke),
             strokeWidth: PARTICIPANT_STROKE_WIDTH
           });
 
           renderLaneLabel(parentGfx, name, element, attrs);
         } else {
-          renderLabel(parentGfx, name, {
-            box: getBounds(element, attrs),
+          var bounds = getBounds(element, attrs);
+
+          if (!horizontalParticipant) {
+            bounds.height = getWidth(element, attrs);
+            bounds.width = getHeight(element, attrs);
+          }
+
+          var textBox = renderLabel(parentGfx, name, {
+            box: bounds,
             align: 'center-middle',
             style: {
               fill: getLabelColor(element, defaultLabelColor, defaultStrokeColor, attrs.stroke)
             }
           });
+
+          if (!horizontalParticipant) {
+            var top = -1 * getHeight(element, attrs);
+            transform(textBox, 0, -top, 270);
+          }
         }
 
         if (semantic.get('participantMultiplicity')) {
@@ -6117,10 +6220,6 @@
     translate: [ 'value', translate ]
   };
 
-  function getDefaultExportFromCjs (x) {
-  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-  }
-
   /**
    * @param {Point} point
    *
@@ -9826,7 +9925,7 @@
   }
 
   /**
-   * @typedef {import('./index').InjectAnnotated } InjectAnnotated
+   * @typedef {import('./index.js').InjectAnnotated } InjectAnnotated
    */
 
   /**
@@ -9896,9 +9995,9 @@
   }
 
   /**
-   * @typedef { import('./index').ModuleDeclaration } ModuleDeclaration
-   * @typedef { import('./index').ModuleDefinition } ModuleDefinition
-   * @typedef { import('./index').InjectorContext } InjectorContext
+   * @typedef { import('./index.js').ModuleDeclaration } ModuleDeclaration
+   * @typedef { import('./index.js').ModuleDefinition } ModuleDefinition
+   * @typedef { import('./index.js').InjectorContext } InjectorContext
    */
 
   /**
@@ -10001,11 +10100,20 @@
       };
     }
 
-    function instantiate(Type) {
+    /**
+     * Instantiate the given type, injecting dependencies.
+     *
+     * @template T
+     *
+     * @param { Function | [...string[], Function ]} type
+     *
+     * @return T
+     */
+    function instantiate(type) {
       const {
         fn,
         dependencies
-      } = fnDef(Type);
+      } = fnDef(type);
 
       // instantiate var args constructor
       const Constructor = Function.prototype.bind.apply(fn, [ null ].concat(dependencies));
@@ -10013,6 +10121,17 @@
       return new Constructor();
     }
 
+    /**
+     * Invoke the given function, injecting dependencies. Return the result.
+     *
+     * @template T
+     *
+     * @param { Function | [...string[], Function ]} func
+     * @param { Object } [context]
+     * @param { Object } [locals]
+     *
+     * @return {T} invocation result
+     */
     function invoke(func, context, locals) {
       const {
         fn,
@@ -12281,32 +12400,17 @@
     }
   };
 
-  var objectRefs = {exports: {}};
-
-  var collection = {};
-
-  /**
-   * An empty collection stub. Use {@link RefsCollection.extend} to extend a
-   * collection with ref semantics.
-   *
-   * @class RefsCollection
-   */
-
   /**
    * Extends a collection with {@link Refs} aware methods
    *
-   * @memberof RefsCollection
-   * @static
-   *
-   * @param  {Array<Object>} collection
-   * @param  {Refs} refs instance
-   * @param  {Object} property represented by the collection
-   * @param  {Object} target object the collection is attached to
+   * @param {Array<Object>} collection
+   * @param {Refs} refs instance
+   * @param {Object} property represented by the collection
+   * @param {Object} target object the collection is attached to
    *
    * @return {RefsCollection<Object>} the extended array
    */
   function extend(collection, refs, property, target) {
-
     var inverseProperty = property.inverse;
 
     /**
@@ -12317,7 +12421,7 @@
      * @param {Object} element the element to remove
      */
     Object.defineProperty(collection, 'remove', {
-      value: function(element) {
+      value: function (element) {
         var idx = this.indexOf(element);
         if (idx !== -1) {
           this.splice(idx, 1);
@@ -12325,7 +12429,6 @@
           // unset inverse
           refs.unset(element, inverseProperty, target);
         }
-
         return element;
       }
     });
@@ -12338,7 +12441,7 @@
      * @param {Object} element the element to check for
      */
     Object.defineProperty(collection, 'contains', {
-      value: function(element) {
+      value: function (element) {
         return this.indexOf(element) !== -1;
       }
     });
@@ -12353,12 +12456,9 @@
      *                 (possibly moving other elements around)
      */
     Object.defineProperty(collection, 'add', {
-      value: function(element, idx) {
-
+      value: function (element, idx) {
         var currentIdx = this.indexOf(element);
-
         if (typeof idx === 'undefined') {
-
           if (currentIdx !== -1) {
             // element already in collection (!)
             return;
@@ -12370,14 +12470,12 @@
 
         // handle already in collection
         if (currentIdx !== -1) {
-
           // remove element from currentIdx
           this.splice(currentIdx, 1);
         }
 
         // add element at idx
         this.splice(idx, 0, element);
-
         if (currentIdx === -1) {
           // set inverse, unless element was
           // in collection already
@@ -12391,69 +12489,53 @@
     Object.defineProperty(collection, '__refs_collection', {
       value: true
     });
-
     return collection;
   }
 
-
+  /**
+   * Checks if a given collection is extended
+   *
+   * @param {Array<Object>} collection
+   *
+   * @return {boolean}
+   */
   function isExtended(collection) {
     return collection.__refs_collection === true;
   }
 
-  collection.extend = extend;
-
-  collection.isExtended = isExtended;
-
-  var Collection = collection;
-
   function hasOwnProperty$1(e, property) {
     return Object.prototype.hasOwnProperty.call(e, property.name || property);
   }
-
   function defineCollectionProperty(ref, property, target) {
-
-    var collection = Collection.extend(target[property.name] || [], ref, property, target);
-
+    var collection = extend(target[property.name] || [], ref, property, target);
     Object.defineProperty(target, property.name, {
       enumerable: property.enumerable,
       value: collection
     });
-
     if (collection.length) {
-
-      collection.forEach(function(o) {
+      collection.forEach(function (o) {
         ref.set(o, property.inverse, target);
       });
     }
   }
-
-
   function defineProperty$1(ref, property, target) {
-
     var inverseProperty = property.inverse;
-
     var _value = target[property.name];
-
     Object.defineProperty(target, property.name, {
       configurable: property.configurable,
       enumerable: property.enumerable,
-
-      get: function() {
+      get: function () {
         return _value;
       },
-
-      set: function(value) {
-
+      set: function (value) {
         // return if we already performed all changes
         if (value === _value) {
           return;
         }
-
         var old = _value;
 
         // temporary set null
         _value = null;
-
         if (old) {
           ref.unset(old, inverseProperty, target);
         }
@@ -12465,7 +12547,6 @@
         ref.set(_value, inverseProperty, target);
       }
     });
-
   }
 
   /**
@@ -12511,16 +12592,14 @@
    *
    * wheels[0].car // undefined
    */
-  function Refs$1(a, b) {
-
-    if (!(this instanceof Refs$1)) {
-      return new Refs$1(a, b);
+  function Refs(a, b) {
+    if (!(this instanceof Refs)) {
+      return new Refs(a, b);
     }
 
     // link
     a.inverse = b;
     b.inverse = a;
-
     this.props = {};
     this.props[a.name] = a;
     this.props[b.name] = b;
@@ -12535,43 +12614,34 @@
    * @param  {Object} target
    * @param  {String} property
    */
-  Refs$1.prototype.bind = function(target, property) {
+  Refs.prototype.bind = function (target, property) {
     if (typeof property === 'string') {
       if (!this.props[property]) {
         throw new Error('no property <' + property + '> in ref');
       }
       property = this.props[property];
     }
-
     if (property.collection) {
       defineCollectionProperty(this, property, target);
     } else {
       defineProperty$1(this, property, target);
     }
   };
-
-  Refs$1.prototype.ensureRefsCollection = function(target, property) {
-
+  Refs.prototype.ensureRefsCollection = function (target, property) {
     var collection = target[property.name];
-
-    if (!Collection.isExtended(collection)) {
+    if (!isExtended(collection)) {
       defineCollectionProperty(this, property, target);
     }
-
     return collection;
   };
-
-  Refs$1.prototype.ensureBound = function(target, property) {
+  Refs.prototype.ensureBound = function (target, property) {
     if (!hasOwnProperty$1(target, property)) {
       this.bind(target, property);
     }
   };
-
-  Refs$1.prototype.unset = function(target, property, value) {
-
+  Refs.prototype.unset = function (target, property, value) {
     if (target) {
       this.ensureBound(target, property);
-
       if (property.collection) {
         this.ensureRefsCollection(target, property).remove(value);
       } else {
@@ -12579,12 +12649,9 @@
       }
     }
   };
-
-  Refs$1.prototype.set = function(target, property, value) {
-
+  Refs.prototype.set = function (target, property, value) {
     if (target) {
       this.ensureBound(target, property);
-
       if (property.collection) {
         this.ensureRefsCollection(target, property).add(value);
       } else {
@@ -12593,15 +12660,6 @@
     }
   };
 
-  var refs = Refs$1;
-
-  objectRefs.exports = refs;
-
-  objectRefs.exports.Collection = collection;
-
-  var objectRefsExports = objectRefs.exports;
-  var Refs = /*@__PURE__*/getDefaultExportFromCjs(objectRefsExports);
-
   var parentRefs = new Refs({ name: 'children', enumerable: true, collection: true }, { name: 'parent' }),
       labelRefs = new Refs({ name: 'labels', enumerable: true, collection: true }, { name: 'labelTarget' }),
       attacherRefs = new Refs({ name: 'attachers', collection: true }, { name: 'host' }),
@@ -14418,6 +14476,17 @@
     this.idProperty = p;
   };
 
+  DescriptorBuilder.prototype.assertNotTrait = function(typeDescriptor) {
+
+    const _extends = typeDescriptor.extends || [];
+
+    if (_extends.length) {
+      throw new Error(
+        `cannot create <${ typeDescriptor.name }> extending <${ typeDescriptor.extends }>`
+      );
+    }
+  };
+
   DescriptorBuilder.prototype.assertNotDefined = function(p, name) {
     var propertyName = p.name,
         definedProperty = this.propertiesByName[propertyName];
@@ -14436,6 +14505,10 @@
 
   DescriptorBuilder.prototype.addTrait = function(t, inherited) {
 
+    if (inherited) {
+      this.assertNotTrait(t);
+    }
+
     var typesByName = this.allTypesByName,
         types = this.allTypes;
 
@@ -14569,7 +14642,9 @@
     });
 
     forEach$1(type.extends, bind$2(function(extendsName) {
-      var extended = this.typeMap[extendsName];
+      var extendsNameNs = parseName(extendsName, ns.prefix);
+
+      var extended = this.typeMap[extendsNameNs.name];
 
       extended.traits = extended.traits || [];
       extended.traits.push(name);
@@ -14598,24 +14673,33 @@
 
     var self = this;
 
+    /**
+     * Traverse the selected super type or trait
+     *
+     * @param {String} cls
+     * @param {Boolean} [trait=false]
+     */
+    function traverse(cls, trait) {
+      var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
+      self.mapTypes(parentNs, iterator, trait);
+    }
+
     /**
      * Traverse the selected trait.
      *
      * @param {String} cls
      */
     function traverseTrait(cls) {
-      return traverseSuper(cls, true);
+      return traverse(cls, true);
     }
 
     /**
-     * Traverse the selected super type or trait
+     * Traverse the selected super type
      *
      * @param {String} cls
-     * @param {Boolean} [trait=false]
      */
-    function traverseSuper(cls, trait) {
-      var parentNs = parseName(cls, isBuiltIn(cls) ? '' : nsName.prefix);
-      self.mapTypes(parentNs, iterator, trait);
+    function traverseSuper(cls) {
+      return traverse(cls, false);
     }
 
     if (!type) {
@@ -14698,7 +14782,7 @@
       throw new TypeError('property name must be a non-empty string');
     }
 
-    var property = this.model.getPropertyDescriptor(target, name);
+    var property = this.getProperty(target, name);
 
     var propertyName = property && property.name;
 
@@ -14709,7 +14793,7 @@
       if (property) {
         delete target[propertyName];
       } else {
-        delete target.$attrs[name];
+        delete target.$attrs[stripGlobal(name)];
       }
     } else {
 
@@ -14722,7 +14806,7 @@
           defineProperty(target, property, value);
         }
       } else {
-        target.$attrs[name] = value;
+        target.$attrs[stripGlobal(name)] = value;
       }
     }
   };
@@ -14737,10 +14821,10 @@
    */
   Properties.prototype.get = function(target, name) {
 
-    var property = this.model.getPropertyDescriptor(target, name);
+    var property = this.getProperty(target, name);
 
     if (!property) {
-      return target.$attrs[name];
+      return target.$attrs[stripGlobal(name)];
     }
 
     var propertyName = property.name;
@@ -14794,6 +14878,44 @@
     this.define(target, '$model', { value: model });
   };
 
+  /**
+   * Return property with the given name on the element.
+   *
+   * @param {any} target
+   * @param {string} name
+   *
+   * @return {object | null} property
+   */
+  Properties.prototype.getProperty = function(target, name) {
+
+    var model = this.model;
+
+    var property = model.getPropertyDescriptor(target, name);
+
+    if (property) {
+      return property;
+    }
+
+    if (name.includes(':')) {
+      return null;
+    }
+
+    const strict = model.config.strict;
+
+    if (typeof strict !== 'undefined') {
+      const error = new TypeError(`unknown property <${ name }> on <${ target.$type }>`);
+
+      if (strict) {
+        throw error;
+      } else {
+
+        // eslint-disable-next-line no-undef
+        typeof console !== 'undefined' && console.warn(error);
+      }
+    }
+
+    return null;
+  };
 
   function isUndefined(val) {
     return typeof val === 'undefined';
@@ -14808,6 +14930,10 @@
     });
   }
 
+  function stripGlobal(name) {
+    return name.replace(/^:/, '');
+  }
+
   // Moddle implementation /////////////////////////////////////////////////
 
   /**
@@ -14830,8 +14956,10 @@
    * var moddle = new Moddle([pkg]);
    *
    * @param {Array<Package>} packages the packages to contain
+   *
+   * @param { { strict?: boolean } } [config] moddle configuration
    */
-  function Moddle(packages) {
+  function Moddle(packages, config = {}) {
 
     this.properties = new Properties(this);
 
@@ -14839,6 +14967,8 @@
     this.registry = new Registry(packages, this.properties);
 
     this.typeCache = {};
+
+    this.config = config;
   }
 
 
@@ -14932,6 +15062,12 @@
       $type: name,
       $instanceOf: function(type) {
         return type === this.$type;
+      },
+      get: function(key) {
+        return this[key];
+      },
+      set: function(key, value) {
+        set$2(this, [ key ], value);
       }
     };
 
@@ -14947,6 +15083,8 @@
 
     this.properties.defineDescriptor(element, descriptor);
     this.properties.defineModel(element, this);
+    this.properties.define(element, 'get', { enumerable: false, writable: true });
+    this.properties.define(element, 'set', { enumerable: false, writable: true });
     this.properties.define(element, '$parent', { enumerable: false, writable: true });
     this.properties.define(element, '$instanceOf', { enumerable: false, writable: true });