camunda-bpmn-js 3.11.0 → 3.12.1

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.
    *
@@ -12344,36 +12400,17 @@
     }
   };
 
-  function getDefaultExportFromCjs (x) {
-  	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-  }
-
-  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;
 
     /**
@@ -12384,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);
@@ -12392,7 +12429,6 @@
           // unset inverse
           refs.unset(element, inverseProperty, target);
         }
-
         return element;
       }
     });
@@ -12405,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;
       }
     });
@@ -12420,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;
@@ -12437,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
@@ -12458,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);
         }
@@ -12532,7 +12547,6 @@
         ref.set(_value, inverseProperty, target);
       }
     });
-
   }
 
   /**
@@ -12578,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;
@@ -12602,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 {
@@ -12646,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 {
@@ -12660,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' }),
@@ -14485,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];
@@ -14503,6 +14505,10 @@
 
   DescriptorBuilder.prototype.addTrait = function(t, inherited) {
 
+    if (inherited) {
+      this.assertNotTrait(t);
+    }
+
     var typesByName = this.allTypesByName,
         types = this.allTypes;
 
@@ -14636,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);
@@ -14665,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) {
@@ -14765,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;
 
@@ -14776,7 +14793,7 @@
       if (property) {
         delete target[propertyName];
       } else {
-        delete target.$attrs[name];
+        delete target.$attrs[stripGlobal(name)];
       }
     } else {
 
@@ -14789,7 +14806,7 @@
           defineProperty(target, property, value);
         }
       } else {
-        target.$attrs[name] = value;
+        target.$attrs[stripGlobal(name)] = value;
       }
     }
   };
@@ -14804,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;
@@ -14861,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';
@@ -14875,6 +14930,10 @@
     });
   }
 
+  function stripGlobal(name) {
+    return name.replace(/^:/, '');
+  }
+
   // Moddle implementation /////////////////////////////////////////////////
 
   /**
@@ -14897,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);
 
@@ -14906,6 +14967,8 @@
     this.registry = new Registry(packages, this.properties);
 
     this.typeCache = {};
+
+    this.config = config;
   }
 
 
@@ -14999,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);
       }
     };
 
@@ -15014,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 });