bpmn-js 12.1.0 → 13.0.0

package/lib/import/BpmnTreeWalker.js

@@ -12,12 +12,17 @@ import {
   ensureCompatDiRef
 } from '../util/CompatibilityUtil';
 
+/**
+ * @typedef {import('diagram-js/lib/i18n/translate/translate').default} Translate
+ *
+ * @typedef {import('../model/Types').ModdleElement} ModdleElement
+ */
 
 /**
- * Returns true if an element has the given meta-model type
+ * Returns true if an element is of the given meta-model type.
  *
- * @param  {ModdleElement}  element
- * @param  {string}         type
+ * @param {ModdleElement} element
+ * @param {string} type
  *
  * @return {boolean}
  */
@@ -29,6 +34,10 @@ function is(element, type) {
 /**
  * Find a suitable display candidate for definitions where the DI does not
  * correctly specify one.
+ *
+ * @param {ModdleElement}
+ *
+ * @return {ModdleElement}
  */
 function findDisplayCandidate(definitions) {
   return find(definitions.rootElements, function(e) {
@@ -36,7 +45,10 @@ function findDisplayCandidate(definitions) {
   });
 }
 
-
+/**
+ * @param {Function} handler
+ * @param {Translate} translate
+ */
 export default function BpmnTreeWalker(handler, translate) {
 
   // list of containers already walked
@@ -105,7 +117,7 @@ export default function BpmnTreeWalker(handler, translate) {
 
   // DI handling //////////////////////
 
-  function registerDi(di) {
+  var registerDi = this.registerDi = function registerDi(di) {
     var bpmnElement = di.bpmnElement;
 
     if (bpmnElement) {
@@ -129,7 +141,7 @@ export default function BpmnTreeWalker(handler, translate) {
         { element: di }
       );
     }
-  }
+  };
 
   function handleDiagram(diagram) {
     handlePlane(diagram.plane);
@@ -149,14 +161,14 @@ export default function BpmnTreeWalker(handler, translate) {
   // Semantic handling //////////////////////
 
   /**
-   * Handle definitions and return the rendered diagram (if any)
+   * Handle definitions and return the rendered diagram (if any).
    *
    * @param {ModdleElement} definitions to walk and import
    * @param {ModdleElement} [diagram] specific diagram to import and display
    *
    * @throws {Error} if no diagram to display could be found
    */
-  function handleDefinitions(definitions, diagram) {
+  this.handleDefinitions = function handleDefinitions(definitions, diagram) {
 
     // make sure we walk the correct bpmnElement
 
@@ -234,9 +246,9 @@ export default function BpmnTreeWalker(handler, translate) {
 
     // handle all deferred elements
     handleDeferred(deferred);
-  }
+  };
 
-  function handleDeferred() {
+  var handleDeferred = this.handleDeferred = function handleDeferred() {
 
     var fn;
 
@@ -246,7 +258,7 @@ export default function BpmnTreeWalker(handler, translate) {
 
       fn();
     }
-  }
+  };
 
   function handleProcess(process, context) {
     handleFlowElementsContainer(process, context);
@@ -322,10 +334,10 @@ export default function BpmnTreeWalker(handler, translate) {
     forEach(ioSpecification.dataOutputs, contextual(handleDataOutput, context));
   }
 
-  function handleSubProcess(subProcess, context) {
+  var handleSubProcess = this.handleSubProcess = function handleSubProcess(subProcess, context) {
     handleFlowElementsContainer(subProcess, context);
     handleArtifacts(subProcess.artifacts, context);
-  }
+  };
 
   function handleFlowNode(flowNode, context) {
     var childCtx = visitIfDi(flowNode, context);
@@ -453,13 +465,4 @@ export default function BpmnTreeWalker(handler, translate) {
       }
     });
   }
-
-  // API //////////////////////
-
-  return {
-    handleDeferred: handleDeferred,
-    handleDefinitions: handleDefinitions,
-    handleSubProcess: handleSubProcess,
-    registerDi: registerDi
-  };
 }

package/lib/import/Importer.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Import the definitions into a diagram.
+ *
+ * Errors and warnings are reported through the specified callback.
+ *
+ * @param diagram
+ * @param definitions
+ * @param bpmnDiagram The diagram to be rendered (if not
+ * provided, the first one will be rendered).
+ *
+ * @return
+ */
+export function importBpmnDiagram(
+  diagram: ModdleElement,
+  definitions: ModdleElement,
+  bpmnDiagram?: ModdleElement
+): Promise<ImportBPMNDiagramResult>;
+
+type ModdleElement = import('../model/Types').ModdleElement;
+
+export type ImportBPMNDiagramResult = {
+    warnings: string[];
+};
+
+export type ImportBPMNDiagramError = ImportBPMNDiagramResult & Error;

package/lib/import/Importer.js

@@ -10,32 +10,26 @@ import { is } from '../util/ModelUtil';
 
 
 /**
- * The importBpmnDiagram result.
+ * @typedef {import('../model/Types').ModdleElement} ModdleElement
  *
- * @typedef {Object} ImportBPMNDiagramResult
+ * @typedef { {
+ *   warnings: string[];
+ * } } ImportBPMNDiagramResult
  *
- * @property {Array<string>} warnings
+ * @typedef {ImportBPMNDiagramResult & Error} ImportBPMNDiagramError
  */
 
-/**
-* The importBpmnDiagram error.
-*
-* @typedef {Error} ImportBPMNDiagramError
-*
-* @property {Array<string>} warnings
-*/
-
 /**
  * Import the definitions into a diagram.
  *
  * Errors and warnings are reported through the specified callback.
  *
- * @param  {djs.Diagram} diagram
- * @param  {ModdleElement<Definitions>} definitions
- * @param  {ModdleElement<BPMNDiagram>} [bpmnDiagram] the diagram to be rendered
- * (if not provided, the first one will be rendered)
+ * @param {ModdleElement} diagram
+ * @param {ModdleElement} definitions
+ * @param {ModdleElement} [bpmnDiagram] The diagram to be rendered (if not
+ * provided, the first one will be rendered).
  *
- * Returns {Promise<ImportBPMNDiagramResult, ImportBPMNDiagramError>}
+ * @return {Promise<ImportBPMNDiagramResult>}
  */
 export function importBpmnDiagram(diagram, definitions, bpmnDiagram) {
 
@@ -51,8 +45,8 @@ export function importBpmnDiagram(diagram, definitions, bpmnDiagram) {
    * Walk the diagram semantically, importing (=drawing)
    * all elements you encounter.
    *
-   * @param {ModdleElement<Definitions>} definitions
-   * @param {ModdleElement<BPMNDiagram>} bpmnDiagram
+   * @param {ModdleElement} definitions
+   * @param {ModdleElement} bpmnDiagram
    */
   function render(definitions, bpmnDiagram) {
 
@@ -127,10 +121,10 @@ export function importBpmnDiagram(diagram, definitions, bpmnDiagram) {
  * Returns all diagrams in the same hierarchy as the requested diagram.
  * Includes all parent and sub process diagrams.
  *
- * @param {Array} definitions
- * @param {Object} bpmnDiagram
+ * @param {ModdleElement} definitions
+ * @param {ModdleElement} bpmnDiagram
  *
- * @returns {Array<Object>}
+ * @return {ModdleElement[]}
  */
 function getDiagramsToImport(definitions, bpmnDiagram) {
   if (!bpmnDiagram) {

package/lib/import/Util.d.ts

@@ -0,0 +1 @@
+export function elementToString(e: any): string;

package/lib/import/index.d.ts

@@ -0,0 +1,6 @@
+declare namespace _default {
+    const __depends__: import("didi").ModuleDeclaration[];
+    const bpmnImporter: (string | typeof BpmnImporter)[];
+}
+export default _default;
+import BpmnImporter from './BpmnImporter';

package/lib/model/Types.d.ts

@@ -0,0 +1,24 @@
+import { Connection as BaseConnection, Element as BaseElement, Label as BaseLabel, Root as BaseRoot, Shape as BaseShape } from "diagram-js/lib/model";
+export type Moddle = any;
+export type ModdleElement = any;
+export type ModdleExtension = {};
+export type BpmnAttributes = {
+    associationDirection: 'None' | 'One' | 'Both';
+    cancelActivity: boolean;
+    eventDefinitionType: string;
+    isExpanded: boolean;
+    isForCompensation: boolean;
+    isInterrupting: boolean;
+    processRef: ModdleElement;
+    triggeredByEvent: boolean;
+};
+export type Element = {
+    businessObject: any;
+    di: any;
+    type: string;
+} & BaseElement;
+export type Connection = BaseConnection & Element;
+export type Label = BaseLabel & Element;
+export type Root = BaseRoot & Element;
+export type Shape = BaseShape & Element;
+export type Parent = Root | Shape;

package/lib/model/Types.ts

@@ -0,0 +1,40 @@
+import {
+  Connection as BaseConnection,
+  Element as BaseElement,
+  Label as BaseLabel,
+  Root as BaseRoot,
+  Shape as BaseShape
+} from "diagram-js/lib/model";
+
+export type Moddle = any;
+
+export type ModdleElement = any;
+
+export type ModdleExtension = {};
+
+export type BpmnAttributes = {
+  associationDirection: 'None' | 'One' | 'Both';
+  cancelActivity: boolean;
+  eventDefinitionType: string;
+  isExpanded: boolean;
+  isForCompensation: boolean;
+  isInterrupting: boolean;
+  processRef: ModdleElement;
+  triggeredByEvent: boolean;
+};
+
+export type Element = {
+  businessObject: any;
+  di: any;
+  type: string;
+} & BaseElement;
+
+export type Connection = BaseConnection & Element;
+
+export type Label = BaseLabel & Element;
+
+export type Root = BaseRoot & Element;
+
+export type Shape = BaseShape & Element;
+
+export type Parent = Root | Shape;

package/lib/util/CompatibilityUtil.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Wraps APIs to check:
+ *
+ * 1) If a callback is passed -> Warn users about callback deprecation.
+ * 2) If Promise class is implemented in current environment.
+ *
+ * @private
+ *
+ * @param api
+ *
+ * @return
+ */
+export function wrapForCompatibility(api: Function): Function;
+
+/**
+ * @private
+ *
+ * @param businessObject
+ */
+export function ensureCompatDiRef(businessObject: ModdleElement): void;
+
+type ModdleElement = import('../model/Types').ModdleElement;

package/lib/util/CompatibilityUtil.js

@@ -3,6 +3,10 @@ import {
   isFunction
 } from 'min-dash';
 
+/**
+ * @typedef {import('../model/Types').ModdleElement} ModdleElement
+ */
+
 // TODO(nikku): remove with future bpmn-js version
 
 /**
@@ -12,6 +16,10 @@ import {
  * 2) If Promise class is implemented in current environment.
  *
  * @private
+ *
+ * @param {Function} api
+ *
+ * @return {Function}
  */
 export function wrapForCompatibility(api) {
 
@@ -60,6 +68,11 @@ export function wrapForCompatibility(api) {
 
 var DI_ERROR_MESSAGE = 'Tried to access di from the businessObject. The di is available through the diagram element only. For more information, see https://github.com/bpmn-io/bpmn-js/issues/1472';
 
+/**
+ * @private
+ *
+ * @param {ModdleElement} businessObject
+ */
 export function ensureCompatDiRef(businessObject) {
 
   // bpmnElement can have multiple independent DIs

package/lib/util/DiUtil.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @param element
+ * @param di
+ *
+ * @return
+ */
+export function isExpanded(element: Element, di: ModdleElement): boolean;
+
+/**
+ * @param element
+ *
+ * @return
+ */
+export function isInterrupting(element: Element): boolean;
+
+/**
+ * @param element
+ *
+ * @return
+ */
+export function isEventSubProcess(element: Element): boolean;
+
+/**
+ * @param element
+ * @param eventType
+ *
+ * @return
+ */
+export function hasEventDefinition(element: Element, eventType: string): boolean;
+
+/**
+ * @param element
+ *
+ * @return
+ */
+export function hasErrorEventDefinition(element: Element): boolean;
+
+/**
+ * @param element
+ *
+ * @return
+ */
+export function hasEscalationEventDefinition(element: Element): boolean;
+
+/**
+ * @param element
+ *
+ * @return
+ */
+export function hasCompensateEventDefinition(element: Element): boolean;
+
+type Element = import('../model/Types').Element;
+type ModdleElement = import('../model/Types').ModdleElement;

package/lib/util/DiUtil.js

@@ -5,10 +5,20 @@ import {
 } from './ModelUtil';
 
 import {
-  forEach
+  some
 } from 'min-dash';
 
-
+/**
+ * @typedef {import('../model/Types').Element} Element
+ * @typedef {import('../model/Types').ModdleElement} ModdleElement
+ */
+
+/**
+ * @param {Element} element
+ * @param {ModdleElement} di
+ *
+ * @return {boolean}
+ */
 export function isExpanded(element, di) {
 
   if (is(element, 'bpmn:CallActivity')) {
@@ -32,37 +42,61 @@ export function isExpanded(element, di) {
   return true;
 }
 
+/**
+ * @param {Element} element
+ *
+ * @return {boolean}
+ */
 export function isInterrupting(element) {
   return element && getBusinessObject(element).isInterrupting !== false;
 }
 
+/**
+ * @param {Element} element
+ *
+ * @return {boolean}
+ */
 export function isEventSubProcess(element) {
   return element && !!getBusinessObject(element).triggeredByEvent;
 }
 
+/**
+ * @param {Element} element
+ * @param {string} eventType
+ *
+ * @return {boolean}
+ */
 export function hasEventDefinition(element, eventType) {
-  var bo = getBusinessObject(element),
-      hasEventDefinition = false;
-
-  if (bo.eventDefinitions) {
-    forEach(bo.eventDefinitions, function(event) {
-      if (is(event, eventType)) {
-        hasEventDefinition = true;
-      }
-    });
-  }
+  var eventDefinitions = getBusinessObject(element).eventDefinitions;
 
-  return hasEventDefinition;
+  return some(eventDefinitions, function(event) {
+    return is(event, eventType);
+  });
 }
 
+/**
+ * @param {Element} element
+ *
+ * @return {boolean}
+ */
 export function hasErrorEventDefinition(element) {
   return hasEventDefinition(element, 'bpmn:ErrorEventDefinition');
 }
 
+/**
+ * @param {Element} element
+ *
+ * @return {boolean}
+ */
 export function hasEscalationEventDefinition(element) {
   return hasEventDefinition(element, 'bpmn:EscalationEventDefinition');
 }
 
+/**
+ * @param {Element} element
+ *
+ * @return {boolean}
+ */
 export function hasCompensateEventDefinition(element) {
   return hasEventDefinition(element, 'bpmn:CompensateEventDefinition');
 }

package/lib/util/DrilldownUtil.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Get primary shape ID for a plane.
+ *
+ * @param  element
+ *
+ * @return
+ */
+export function getShapeIdFromPlane(element: Element | ModdleElement): string;
+
+/**
+ * Get plane ID for a primary shape.
+ *
+ * @param  element
+ *
+ * @return
+ */
+export function getPlaneIdFromShape(element: Element | ModdleElement): string;
+
+/**
+ * Get plane ID for primary shape ID.
+ *
+ * @param id
+ *
+ * @return
+ */
+export function toPlaneId(id: string): string;
+
+/**
+ * Check wether element is plane.
+ *
+ * @param  element
+ *
+ * @return
+ */
+export function isPlane(element: Element | ModdleElement): boolean;
+
+export const planeSuffix: string;
+type Element = import('../model/Types').Element;
+type ModdleElement = import('../model/Types').ModdleElement;

package/lib/util/DrilldownUtil.js

@@ -1,14 +1,18 @@
 import { getDi, is } from './ModelUtil';
 
+/**
+ * @typedef {import('../model/Types').Element} Element
+ * @typedef {import('../model/Types').ModdleElement} ModdleElement
+ */
 
 export var planeSuffix = '_plane';
 
 /**
  * Get primary shape ID for a plane.
  *
- * @param  {djs.model.Base|ModdleElement} element
+ * @param  {Element|ModdleElement} element
  *
- * @returns {String}
+ * @return {string}
  */
 export function getShapeIdFromPlane(element) {
   var id = element.id;
@@ -19,9 +23,9 @@ export function getShapeIdFromPlane(element) {
 /**
  * Get plane ID for a primary shape.
  *
- * @param  {djs.model.Base|ModdleElement} element
+ * @param  {Element|ModdleElement} element
  *
- * @returns {String}
+ * @return {string}
  */
 export function getPlaneIdFromShape(element) {
   var id = element.id;
@@ -36,9 +40,9 @@ export function getPlaneIdFromShape(element) {
 /**
  * Get plane ID for primary shape ID.
  *
- * @param {String} id
+ * @param {string} id
  *
- * @returns {String}
+ * @return {string}
  */
 export function toPlaneId(id) {
   return addPlaneSuffix(id);
@@ -47,9 +51,9 @@ export function toPlaneId(id) {
 /**
  * Check wether element is plane.
  *
- * @param  {djs.model.Base|ModdleElement} element
+ * @param  {Element|ModdleElement} element
  *
- * @returns {Boolean}
+ * @return {boolean}
  */
 export function isPlane(element) {
   var di = getDi(element);

package/lib/util/LabelUtil.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Return true if the given semantic has an external label.
+ *
+ * @param semantic
+ *
+ * @return
+ */
+export function isLabelExternal(semantic: Element): boolean;
+
+/**
+ * Return true if the given element has an external label.
+ *
+ * @param element
+ *
+ * @return
+ */
+export function hasExternalLabel(element: Element): boolean;
+
+/**
+ * Get the position of a sequence flow label.
+ *
+ * @param  waypoints
+ *
+ * @return
+ */
+export function getFlowLabelPosition(waypoints: Point[]): Point;
+
+/**
+ * Get the middle of a number of waypoints.
+ *
+ * @param  waypoints
+ *
+ * @return
+ */
+export function getWaypointsMid(waypoints: Point[]): Point;
+
+/**
+ * Get the middle of the external label of an element.
+ *
+ * @param element
+ *
+ * @return
+ */
+export function getExternalLabelMid(element: Element): Point;
+
+/**
+ * Return the bounds of an elements label, parsed from the elements DI or
+ * generated from its bounds.
+ *
+ * @param di
+ * @param element
+ *
+ * @return
+ */
+export function getExternalLabelBounds(di: ModdleElement, element: Element): Rect;
+
+/**
+ * @param element
+ *
+ * @return
+ */
+export function isLabel(element: Element): boolean;
+
+export namespace DEFAULT_LABEL_SIZE {
+    const width: number;
+    const height: number;
+}
+
+export const FLOW_LABEL_INDENT: number;
+type Point = import('diagram-js/lib/util/Types').Point;
+type Rect = import('diagram-js/lib/util/Types').Rect;
+type Element = import('../model/Types').Element;
+type ModdleElement = import('../model/Types').ModdleElement;