camunda-bpmn-js 4.3.2 → 4.4.0

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

@@ -5137,8 +5137,8 @@
    * @typedef { number | Partial<Padding> } PaddingConfig
    *
    * @typedef { {
-   *   horizontal: 'center' | 'left';
-   *   vertical: 'top' | 'center';
+   *   horizontal: 'center' | 'left' | 'right';
+   *   vertical: 'top' | 'middle';
    * } } Alignment
    *
    *  @typedef { 'center-middle' | 'center-top' } AlignmentConfig
@@ -5402,7 +5402,7 @@
   /**
    * Creates a new label utility
    *
-   * @param {TextConfig} config
+   * @param {TextConfig} [config]
    */
   function Text(config) {
 
@@ -7388,6 +7388,7 @@
   /**
    * @typedef {import('../../model/Types').Element} Element
    *
+   * @typedef {import('./OutlineProvider').default} OutlineProvider
    * @typedef {import('../../core/EventBus').default} EventBus
    * @typedef {import('../../draw/Styles').default} Styles
    */
@@ -7546,7 +7547,7 @@
    * Returns the outline for an element.
    *
    * @param {Element} element
-   **/
+   */
   Outline.prototype.getOutline = function(element) {
     var outline;
     var providers = this._getProviders();
@@ -8127,7 +8128,7 @@
     }, config && config.defaults);
 
     /**
-     * @type {Map<string, Overlay>}
+     * @type {Record<string, Overlay>}
      */
     this._overlays = {};
 
@@ -9952,16 +9953,19 @@
    * @typedef { import('./index.js').ModuleDeclaration } ModuleDeclaration
    * @typedef { import('./index.js').ModuleDefinition } ModuleDefinition
    * @typedef { import('./index.js').InjectorContext } InjectorContext
+   *
+   * @typedef { import('./index.js').TypedDeclaration<any, any> } TypedDeclaration
    */
 
   /**
    * Create a new injector with the given modules.
    *
    * @param {ModuleDefinition[]} modules
-   * @param {InjectorContext} [parent]
+   * @param {InjectorContext} [_parent]
    */
-  function Injector(modules, parent) {
-    parent = parent || {
+  function Injector(modules, _parent) {
+
+    const parent = _parent || /** @type InjectorContext */ ({
       get: function(name, strict) {
         currentlyResolving.push(name);
 
@@ -9971,7 +9975,7 @@
           throw error(`No provider for "${ name }"!`);
         }
       }
-    };
+    });
 
     const currentlyResolving = [];
     const providers = this._providers = Object.create(parent._providers || null);
@@ -9994,12 +9998,13 @@
      * @return {any}
      */
     function get(name, strict) {
-      if (!providers[name] && name.indexOf('.') !== -1) {
+      if (!providers[name] && name.includes('.')) {
+
         const parts = name.split('.');
-        let pivot = get(parts.shift());
+        let pivot = get(/** @type { string } */ (parts.shift()));
 
         while (parts.length) {
-          pivot = pivot[parts.shift()];
+          pivot = pivot[/** @type { string } */ (parts.shift())];
         }
 
         return pivot;
@@ -10039,6 +10044,9 @@
         }
       }
 
+      /**
+       * @type {string[]}
+       */
       const inject = fn.$inject || parseAnnotations(fn);
       const dependencies = inject.map(dep => {
         if (hasOwnProp(locals, dep)) {
@@ -10050,7 +10058,7 @@
 
       return {
         fn: fn,
-        dependencies: dependencies
+        dependencies
       };
     }
 
@@ -10070,7 +10078,7 @@
       } = fnDef(type);
 
       // instantiate var args constructor
-      const Constructor = Function.prototype.bind.apply(fn, [ null ].concat(dependencies));
+      const Constructor = Function.prototype.bind.call(fn, null, ...dependencies);
 
       return new Constructor();
     }
@@ -10250,13 +10258,17 @@
           return;
         }
 
-        if (moduleDefinition[key][2] === 'private') {
-          providers[key] = moduleDefinition[key];
+        const typeDeclaration = /** @type { TypedDeclaration } */ (
+          moduleDefinition[key]
+        );
+
+        if (typeDeclaration[2] === 'private') {
+          providers[key] = typeDeclaration;
           return;
         }
 
-        const type = moduleDefinition[key][0];
-        const value = moduleDefinition[key][1];
+        const type = typeDeclaration[0];
+        const value = typeDeclaration[1];
 
         providers[key] = [ factoryMap[type], arrayUnwrap(type, value), type ];
       });
@@ -10644,6 +10656,7 @@
    * @typedef {import('../util/Types').Point} Point
    * @typedef {import('../util/Types').Rect} Rect
    * @typedef {import('../util/Types').RectTRBL} RectTRBL
+   * @typedef {import('../util/Types').ScrollDelta} ScrollDelta
    */
 
   function round(number, resolution) {
@@ -11344,7 +11357,7 @@
   Canvas.prototype.setRootElement = function(rootElement) {
 
     if (rootElement === this._rootElement) {
-      return;
+      return rootElement;
     }
 
     let plane;
@@ -11779,7 +11792,7 @@
   /**
    * Gets or sets the scroll of the canvas.
    *
-   * @param {Point} [delta] The scroll to be set.
+   * @param {ScrollDelta} [delta] The scroll to be set.
    *
    * @return {Point}
    */
@@ -13150,6 +13163,8 @@
    * var sum = eventBus.fire('sum', 1, 2);
    * console.log(sum); // 3
    * ```
+   *
+   * @template [EventMap=null]
    */
   function EventBus() {
 
@@ -13163,8 +13178,9 @@
     this.on('diagram.destroy', 1, this._destroy, this);
   }
 
-
   /**
+   * @overlord
+   *
    * Register an event listener for events with the given name.
    *
    * The callback will be invoked with `event, ...additionalArguments`
@@ -13183,6 +13199,25 @@
    * @param {EventBusEventCallback<T>} callback
    * @param {any} [that] callback context
    */
+  /**
+   * Register an event listener for events with the given name.
+   *
+   * The callback will be invoked with `event, ...additionalArguments`
+   * that have been passed to {@link EventBus#fire}.
+   *
+   * Returning false from a listener will prevent the events default action
+   * (if any is specified). To stop an event from being processed further in
+   * other listeners execute {@link Event#stopPropagation}.
+   *
+   * Returning anything but `undefined` from a listener will stop the listener propagation.
+   *
+   * @template {keyof EventMap} EventName
+   *
+   * @param {EventName} events to subscribe to
+   * @param {number} [priority=1000] listen priority
+   * @param {EventBusEventCallback<EventMap[EventName]>} callback
+   * @param {any} [that] callback context
+   */
   EventBus.prototype.on = function(events, priority, callback, that) {
 
     events = isArray$2(events) ? events : [ events ];
@@ -13220,6 +13255,8 @@
   };
 
   /**
+   * @overlord
+   *
    * Register an event listener that is called only once.
    *
    * @template T
@@ -13229,6 +13266,16 @@
    * @param {EventBusEventCallback<T>} callback
    * @param {any} [that] callback context
    */
+  /**
+   * Register an event listener that is called only once.
+   *
+   * @template {keyof EventMap} EventName
+   *
+   * @param {EventName} events to subscribe to
+   * @param {number} [priority=1000] listen priority
+   * @param {EventBusEventCallback<EventMap[EventName]>} callback
+   * @param {any} [that] callback context
+   */
   EventBus.prototype.once = function(events, priority, callback, that) {
     var self = this;
 
@@ -13954,6 +14001,16 @@
    * } & Record<string, any> } DiagramOptions
    */
 
+  /**
+   * @template T
+   * @typedef {import('didi').FactoryFunction<T>} FactoryFunction
+   */
+
+  /**
+   * @template T
+   * @typedef {import('didi').ArrayFunc<T>} ArrayFunc
+   */
+
   /**
    * Bootstrap an injector from a list of modules, instantiating a number of default components
    *
@@ -13972,9 +14029,10 @@
   /**
    * Creates an injector from passed options.
    *
+   * @template ServiceMap
    * @param {DiagramOptions} [options]
    *
-   * @return {Injector}
+   * @return {Injector<ServiceMap>}
    */
   function createInjector(options) {
 
@@ -14001,6 +14059,7 @@
    *
    * @class
    * @constructor
+   * @template [ServiceMap=null]
    *
    * @example Creating a plug-in that logs whenever a shape is added to the canvas.
    *
@@ -14039,44 +14098,17 @@
    * ```
    *
    * @param {DiagramOptions} [options]
-   * @param {Injector} [injector] An (optional) injector to bootstrap the diagram with.
+   * @param {Injector<ServiceMap>} [injector] An (optional) injector to bootstrap the diagram with.
    */
   function Diagram(options, injector) {
 
-    this._injector = injector = injector || createInjector(options);
-
-    // API
-
-    /**
-     * Resolves a diagram service.
-     *
-     * @template T
-     *
-     * @param {string} name The name of the service to get.
-     * @param {boolean} [strict=true] If false, resolve missing services to null.
-     *
-     * @return {T|null}
-     */
-    this.get = injector.get;
-
     /**
-     * Executes a function with its dependencies injected.
-     *
-     * @template T
-     *
-     * @param {Function} func function to be invoked
-     * @param {InjectionContext} [context] context of the invocation
-     * @param {LocalsMap} [locals] locals provided
-     *
-     * @return {T|null}
+     * @type {Injector<ServiceMap>}
      */
-    this.invoke = injector.invoke;
+    this._injector = injector || createInjector(options);
 
     // init
 
-    // indicate via event
-
-
     /**
      * An event indicating that all plug-ins are loaded.
      *
@@ -14099,6 +14131,82 @@
     this.get('eventBus').fire('diagram.init');
   }
 
+  /**
+   * @overlord
+   *
+   * Resolves a diagram service.
+   *
+   * @template T
+   *
+   * @param {string} name The name of the service to get.
+   *
+   * @return {T}
+   */
+  /**
+   * @overlord
+   *
+   * Resolves a diagram service.
+   *
+   * @template T
+   *
+   * @param {string} name The name of the service to get.
+   * @param {true} strict If false, resolve missing services to null.
+   *
+   * @return {T}
+   */
+  /**
+   * @overlord
+   *
+   * Resolves a diagram service.
+   *
+   * @template T
+   *
+   * @param {string} name The name of the service to get.
+   * @param {boolean} strict If false, resolve missing services to null.
+   *
+   * @return {T|null}
+   */
+  /**
+   * Resolves a diagram service.
+   *
+   * @template {keyof ServiceMap} Name
+   *
+   * @param {Name} name The name of the service to get.
+   *
+   * @return {ServiceMap[Name]}
+   */
+  Diagram.prototype.get = function(name, strict) {
+    return this._injector.get(name, strict);
+  };
+
+  /**
+   * @overlord
+   *
+   * Invoke the given function, injecting dependencies. Return the result.
+   *
+   * @template T
+   *
+   * @param {FactoryFunction<T>} func
+   * @param {InjectionContext} [context]
+   * @param {LocalsMap} [locals]
+   *
+   * @return {T}
+   */
+  /**
+   * Invoke the given function, injecting dependencies provided in
+   * array notation. Return the result.
+   *
+   * @template T
+   *
+   * @param {ArrayFunc<T>} func function to be invoked
+   * @param {InjectionContext} [context] context of the invocation
+   * @param {LocalsMap} [locals] locals provided
+   *
+   * @return {T}
+   */
+  Diagram.prototype.invoke = function(func, context, locals) {
+    return this._injector.invoke(func, context, locals);
+  };
 
   /**
    * Destroys the diagram