bpmn-js 17.6.1 → 17.6.2

package/lib/features/modeling/behavior/LayoutConnectionBehavior.d.ts

@@ -1,16 +1,16 @@
-/**
- * A component that makes sure that Associations connected to Connections
- * are updated together with the Connection.
- *
- */
-export default class LayoutConnectionBehavior extends CommandInterceptor {
-    /**
-     * @param eventBus
-     * @param modeling
-     */
-    constructor(eventBus: EventBus, modeling: Modeling);
-}
-
-type EventBus = import('diagram-js/lib/core/EventBus').default;
-type Modeling = import('../Modeling').default;
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+/**
+ * A component that makes sure that Associations connected to Connections
+ * are updated together with the Connection.
+ *
+ */
+export default class LayoutConnectionBehavior extends CommandInterceptor {
+    /**
+     * @param eventBus
+     * @param modeling
+     */
+    constructor(eventBus: EventBus, modeling: Modeling);
+}
+
+type EventBus = import('diagram-js/lib/core/EventBus').default;
+type Modeling = import('../Modeling').default;
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';

package/lib/features/modeling/behavior/LayoutConnectionBehavior.js

@@ -1,121 +1,121 @@
-import {
-  assign
-} from 'min-dash';
-
-import inherits from 'inherits-browser';
-
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
-
-import { getConnectionAdjustment as getConnectionAnchorPoint } from './util/ConnectionLayoutUtil';
-
-/**
- * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
- * @typedef {import('../Modeling').default} Modeling
- */
-
-/**
- * A component that makes sure that Associations connected to Connections
- * are updated together with the Connection.
- *
- * @param {EventBus} eventBus
- * @param {Modeling} modeling
- */
-export default function LayoutConnectionBehavior(eventBus, modeling) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  function getnewAnchorPoint(event, point) {
-
-    var context = event.context,
-        connection = context.connection,
-        hints = assign({}, context.hints),
-        newWaypoints = context.newWaypoints || connection.waypoints,
-        oldWaypoints = context.oldWaypoints;
-
-
-    if (typeof hints.startChanged === 'undefined') {
-      hints.startChanged = !!hints.connectionStart;
-    }
-
-    if (typeof hints.endChanged === 'undefined') {
-      hints.endChanged = !!hints.connectionEnd;
-    }
-
-    return getConnectionAnchorPoint(point, newWaypoints, oldWaypoints, hints);
-  }
-
-  this.postExecute([
-    'connection.layout',
-    'connection.updateWaypoints'
-  ], function(event) {
-    var context = event.context;
-
-    var connection = context.connection,
-        outgoing = connection.outgoing,
-        incoming = connection.incoming;
-
-    incoming.forEach(function(connection) {
-      var endPoint = connection.waypoints[connection.waypoints.length - 1];
-      var newEndpoint = getnewAnchorPoint(event, endPoint);
-
-      var newWaypoints = [].concat(connection.waypoints.slice(0, -1), [ newEndpoint ]);
-
-      modeling.updateWaypoints(connection, newWaypoints);
-    });
-
-    outgoing.forEach(function(connection) {
-      var startpoint = connection.waypoints[0];
-      var newStartpoint = getnewAnchorPoint(event, startpoint);
-
-      var newWaypoints = [].concat([ newStartpoint ], connection.waypoints.slice(1));
-
-      modeling.updateWaypoints(connection, newWaypoints);
-    });
-
-  });
-
-
-  this.postExecute([
-    'connection.move'
-  ], function(event) {
-    var context = event.context;
-
-    var connection = context.connection,
-        outgoing = connection.outgoing,
-        incoming = connection.incoming,
-        delta = context.delta;
-
-    incoming.forEach(function(connection) {
-      var endPoint = connection.waypoints[connection.waypoints.length - 1];
-      var newEndpoint = {
-        x: endPoint.x + delta.x,
-        y: endPoint.y + delta.y
-      };
-
-      var newWaypoints = [].concat(connection.waypoints.slice(0, -1), [ newEndpoint ]);
-
-      modeling.updateWaypoints(connection, newWaypoints);
-    });
-
-    outgoing.forEach(function(connection) {
-      var startpoint = connection.waypoints[0];
-      var newStartpoint = {
-        x: startpoint.x + delta.x,
-        y: startpoint.y + delta.y
-      };
-
-      var newWaypoints = [].concat([ newStartpoint ], connection.waypoints.slice(1));
-
-      modeling.updateWaypoints(connection, newWaypoints);
-    });
-
-  });
-
-}
-
-inherits(LayoutConnectionBehavior, CommandInterceptor);
-
-LayoutConnectionBehavior.$inject = [
-  'eventBus',
-  'modeling'
-];
+import {
+  assign
+} from 'min-dash';
+
+import inherits from 'inherits-browser';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
+import { getConnectionAdjustment as getConnectionAnchorPoint } from './util/ConnectionLayoutUtil';
+
+/**
+ * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+ * @typedef {import('../Modeling').default} Modeling
+ */
+
+/**
+ * A component that makes sure that Associations connected to Connections
+ * are updated together with the Connection.
+ *
+ * @param {EventBus} eventBus
+ * @param {Modeling} modeling
+ */
+export default function LayoutConnectionBehavior(eventBus, modeling) {
+
+  CommandInterceptor.call(this, eventBus);
+
+  function getnewAnchorPoint(event, point) {
+
+    var context = event.context,
+        connection = context.connection,
+        hints = assign({}, context.hints),
+        newWaypoints = context.newWaypoints || connection.waypoints,
+        oldWaypoints = context.oldWaypoints;
+
+
+    if (typeof hints.startChanged === 'undefined') {
+      hints.startChanged = !!hints.connectionStart;
+    }
+
+    if (typeof hints.endChanged === 'undefined') {
+      hints.endChanged = !!hints.connectionEnd;
+    }
+
+    return getConnectionAnchorPoint(point, newWaypoints, oldWaypoints, hints);
+  }
+
+  this.postExecute([
+    'connection.layout',
+    'connection.updateWaypoints'
+  ], function(event) {
+    var context = event.context;
+
+    var connection = context.connection,
+        outgoing = connection.outgoing,
+        incoming = connection.incoming;
+
+    incoming.forEach(function(connection) {
+      var endPoint = connection.waypoints[connection.waypoints.length - 1];
+      var newEndpoint = getnewAnchorPoint(event, endPoint);
+
+      var newWaypoints = [].concat(connection.waypoints.slice(0, -1), [ newEndpoint ]);
+
+      modeling.updateWaypoints(connection, newWaypoints);
+    });
+
+    outgoing.forEach(function(connection) {
+      var startpoint = connection.waypoints[0];
+      var newStartpoint = getnewAnchorPoint(event, startpoint);
+
+      var newWaypoints = [].concat([ newStartpoint ], connection.waypoints.slice(1));
+
+      modeling.updateWaypoints(connection, newWaypoints);
+    });
+
+  });
+
+
+  this.postExecute([
+    'connection.move'
+  ], function(event) {
+    var context = event.context;
+
+    var connection = context.connection,
+        outgoing = connection.outgoing,
+        incoming = connection.incoming,
+        delta = context.delta;
+
+    incoming.forEach(function(connection) {
+      var endPoint = connection.waypoints[connection.waypoints.length - 1];
+      var newEndpoint = {
+        x: endPoint.x + delta.x,
+        y: endPoint.y + delta.y
+      };
+
+      var newWaypoints = [].concat(connection.waypoints.slice(0, -1), [ newEndpoint ]);
+
+      modeling.updateWaypoints(connection, newWaypoints);
+    });
+
+    outgoing.forEach(function(connection) {
+      var startpoint = connection.waypoints[0];
+      var newStartpoint = {
+        x: startpoint.x + delta.x,
+        y: startpoint.y + delta.y
+      };
+
+      var newWaypoints = [].concat([ newStartpoint ], connection.waypoints.slice(1));
+
+      modeling.updateWaypoints(connection, newWaypoints);
+    });
+
+  });
+
+}
+
+inherits(LayoutConnectionBehavior, CommandInterceptor);
+
+LayoutConnectionBehavior.$inject = [
+  'eventBus',
+  'modeling'
+];

package/lib/features/modeling/behavior/MessageFlowBehavior.d.ts

@@ -1,15 +1,15 @@
-/**
- * BPMN-specific message flow behavior.
- *
- */
-export default class MessageFlowBehavior extends CommandInterceptor {
-    /**
-     * @param eventBus
-     * @param modeling
-     */
-    constructor(eventBus: EventBus, modeling: Modeling);
-}
-
-type EventBus = import('diagram-js/lib/core/EventBus').default;
-type Modeling = import('../Modeling').default;
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+/**
+ * BPMN-specific message flow behavior.
+ *
+ */
+export default class MessageFlowBehavior extends CommandInterceptor {
+    /**
+     * @param eventBus
+     * @param modeling
+     */
+    constructor(eventBus: EventBus, modeling: Modeling);
+}
+
+type EventBus = import('diagram-js/lib/core/EventBus').default;
+type Modeling = import('../Modeling').default;
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';

package/lib/features/modeling/behavior/NonInterruptingBehavior.d.ts

@@ -1,4 +1,4 @@
-export default class NonInterruptingBehavior extends CommandInterceptor {
-    constructor(injector: any, modeling: any);
-}
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+export default class NonInterruptingBehavior extends CommandInterceptor {
+    constructor(injector: any, modeling: any);
+}
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';

package/lib/features/modeling/behavior/NonInterruptingBehavior.js

@@ -1,41 +1,41 @@
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
-import inherits from 'inherits-browser';
-
-import { canBeNonInterrupting, getInterruptingProperty } from './util/NonInterruptingUtil';
-import { getBusinessObject } from '../../../util/ModelUtil';
-
-export default function NonInterruptingBehavior(injector, modeling) {
-  injector.invoke(CommandInterceptor, this);
-
-  this.postExecuted('shape.replace', function(event) {
-    const oldShape = event.context.oldShape;
-    const newShape = event.context.newShape;
-    const hints = event.context.hints;
-
-    if (!canBeNonInterrupting(newShape)) {
-      return;
-    }
-
-    const property = getInterruptingProperty(newShape);
-    const isExplicitChange = hints.targetElement && hints.targetElement[property] !== undefined;
-
-    if (isExplicitChange) {
-      return;
-    }
-
-    const isOldInterrupting = getBusinessObject(oldShape).get(property);
-    const isNewInterruptingDefault = getBusinessObject(newShape).get(property);
-
-    if (isOldInterrupting === isNewInterruptingDefault) {
-      return;
-    }
-
-    modeling.updateProperties(newShape, {
-      [property]: isOldInterrupting
-    });
-  });
-}
-
-NonInterruptingBehavior.$inject = [ 'injector', 'modeling' ];
-
-inherits(NonInterruptingBehavior, CommandInterceptor);
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+import inherits from 'inherits-browser';
+
+import { canBeNonInterrupting, getInterruptingProperty } from './util/NonInterruptingUtil';
+import { getBusinessObject } from '../../../util/ModelUtil';
+
+export default function NonInterruptingBehavior(injector, modeling) {
+  injector.invoke(CommandInterceptor, this);
+
+  this.postExecuted('shape.replace', function(event) {
+    const oldShape = event.context.oldShape;
+    const newShape = event.context.newShape;
+    const hints = event.context.hints;
+
+    if (!canBeNonInterrupting(newShape)) {
+      return;
+    }
+
+    const property = getInterruptingProperty(newShape);
+    const isExplicitChange = hints.targetElement && hints.targetElement[property] !== undefined;
+
+    if (isExplicitChange) {
+      return;
+    }
+
+    const isOldInterrupting = getBusinessObject(oldShape).get(property);
+    const isNewInterruptingDefault = getBusinessObject(newShape).get(property);
+
+    if (isOldInterrupting === isNewInterruptingDefault) {
+      return;
+    }
+
+    modeling.updateProperties(newShape, {
+      [property]: isOldInterrupting
+    });
+  });
+}
+
+NonInterruptingBehavior.$inject = [ 'injector', 'modeling' ];
+
+inherits(NonInterruptingBehavior, CommandInterceptor);

package/lib/features/modeling/behavior/RemoveElementBehavior.d.ts

@@ -1,13 +1,13 @@
-export default class RemoveElementBehavior extends CommandInterceptor {
-    /**
-     * @param eventBus
-     * @param bpmnRules
-     * @param modeling
-     */
-    constructor(eventBus: EventBus, bpmnRules: BpmnRules, modeling: Modeling);
-}
-
-type EventBus = import('diagram-js/lib/core/EventBus').default;
-type BpmnRules = import('../../rules/BpmnRules').default;
-type Modeling = import('../Modeling').default;
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+export default class RemoveElementBehavior extends CommandInterceptor {
+    /**
+     * @param eventBus
+     * @param bpmnRules
+     * @param modeling
+     */
+    constructor(eventBus: EventBus, bpmnRules: BpmnRules, modeling: Modeling);
+}
+
+type EventBus = import('diagram-js/lib/core/EventBus').default;
+type BpmnRules = import('../../rules/BpmnRules').default;
+type Modeling = import('../Modeling').default;
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';

package/lib/features/modeling/behavior/RemoveElementBehavior.js

@@ -1,92 +1,92 @@
-import inherits from 'inherits-browser';
-
-import { is } from '../../../util/ModelUtil';
-
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
-
-import lineIntersect from './util/LineIntersect';
-
-/**
- * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
- * @typedef {import('../../rules/BpmnRules').default} BpmnRules
- * @typedef {import('../Modeling').default} Modeling
- */
-
-/**
- * @param {EventBus} eventBus
- * @param {BpmnRules} bpmnRules
- * @param {Modeling} modeling
- */
-export default function RemoveElementBehavior(eventBus, bpmnRules, modeling) {
-
-  CommandInterceptor.call(this, eventBus);
-
-  /**
-   * Combine sequence flows when deleting an element
-   * if there is one incoming and one outgoing
-   * sequence flow
-   */
-  this.preExecute('shape.delete', function(e) {
-
-    var shape = e.context.shape;
-
-    // only handle [a] -> [shape] -> [b] patterns
-    if (shape.incoming.length !== 1 || shape.outgoing.length !== 1) {
-      return;
-    }
-
-    var inConnection = shape.incoming[0],
-        outConnection = shape.outgoing[0];
-
-    // only handle sequence flows
-    if (!is(inConnection, 'bpmn:SequenceFlow') || !is(outConnection, 'bpmn:SequenceFlow')) {
-      return;
-    }
-
-    if (bpmnRules.canConnect(inConnection.source, outConnection.target, inConnection)) {
-
-      // compute new, combined waypoints
-      var newWaypoints = getNewWaypoints(inConnection.waypoints, outConnection.waypoints);
-
-      modeling.reconnectEnd(inConnection, outConnection.target, newWaypoints);
-    }
-  });
-
-}
-
-inherits(RemoveElementBehavior, CommandInterceptor);
-
-RemoveElementBehavior.$inject = [
-  'eventBus',
-  'bpmnRules',
-  'modeling'
-];
-
-
-// helpers //////////////////////
-
-function getDocking(point) {
-  return point.original || point;
-}
-
-
-function getNewWaypoints(inWaypoints, outWaypoints) {
-
-  var intersection = lineIntersect(
-    getDocking(inWaypoints[inWaypoints.length - 2]),
-    getDocking(inWaypoints[inWaypoints.length - 1]),
-    getDocking(outWaypoints[1]),
-    getDocking(outWaypoints[0]));
-
-  if (intersection) {
-    return [].concat(
-      inWaypoints.slice(0, inWaypoints.length - 1),
-      [ intersection ],
-      outWaypoints.slice(1));
-  } else {
-    return [
-      getDocking(inWaypoints[0]),
-      getDocking(outWaypoints[outWaypoints.length - 1])
-    ];
-  }
+import inherits from 'inherits-browser';
+
+import { is } from '../../../util/ModelUtil';
+
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+
+import lineIntersect from './util/LineIntersect';
+
+/**
+ * @typedef {import('diagram-js/lib/core/EventBus').default} EventBus
+ * @typedef {import('../../rules/BpmnRules').default} BpmnRules
+ * @typedef {import('../Modeling').default} Modeling
+ */
+
+/**
+ * @param {EventBus} eventBus
+ * @param {BpmnRules} bpmnRules
+ * @param {Modeling} modeling
+ */
+export default function RemoveElementBehavior(eventBus, bpmnRules, modeling) {
+
+  CommandInterceptor.call(this, eventBus);
+
+  /**
+   * Combine sequence flows when deleting an element
+   * if there is one incoming and one outgoing
+   * sequence flow
+   */
+  this.preExecute('shape.delete', function(e) {
+
+    var shape = e.context.shape;
+
+    // only handle [a] -> [shape] -> [b] patterns
+    if (shape.incoming.length !== 1 || shape.outgoing.length !== 1) {
+      return;
+    }
+
+    var inConnection = shape.incoming[0],
+        outConnection = shape.outgoing[0];
+
+    // only handle sequence flows
+    if (!is(inConnection, 'bpmn:SequenceFlow') || !is(outConnection, 'bpmn:SequenceFlow')) {
+      return;
+    }
+
+    if (bpmnRules.canConnect(inConnection.source, outConnection.target, inConnection)) {
+
+      // compute new, combined waypoints
+      var newWaypoints = getNewWaypoints(inConnection.waypoints, outConnection.waypoints);
+
+      modeling.reconnectEnd(inConnection, outConnection.target, newWaypoints);
+    }
+  });
+
+}
+
+inherits(RemoveElementBehavior, CommandInterceptor);
+
+RemoveElementBehavior.$inject = [
+  'eventBus',
+  'bpmnRules',
+  'modeling'
+];
+
+
+// helpers //////////////////////
+
+function getDocking(point) {
+  return point.original || point;
+}
+
+
+function getNewWaypoints(inWaypoints, outWaypoints) {
+
+  var intersection = lineIntersect(
+    getDocking(inWaypoints[inWaypoints.length - 2]),
+    getDocking(inWaypoints[inWaypoints.length - 1]),
+    getDocking(outWaypoints[1]),
+    getDocking(outWaypoints[0]));
+
+  if (intersection) {
+    return [].concat(
+      inWaypoints.slice(0, inWaypoints.length - 1),
+      [ intersection ],
+      outWaypoints.slice(1));
+  } else {
+    return [
+      getDocking(inWaypoints[0]),
+      getDocking(outWaypoints[outWaypoints.length - 1])
+    ];
+  }
 }

package/lib/features/modeling/behavior/RemoveEmbeddedLabelBoundsBehavior.d.ts

@@ -1,16 +1,16 @@
-/**
- * BPMN specific behavior ensuring that bpmndi:Label's dc:Bounds are removed
- * when shape is resized.
- *
- */
-export default class RemoveEmbeddedLabelBoundsBehavior extends CommandInterceptor {
-    /**
-     * @param eventBus
-     * @param modeling
-     */
-    constructor(eventBus: EventBus, modeling: Modeling);
-}
-
-type EventBus = import('diagram-js/lib/core/EventBus').default;
-type Modeling = import('../Modeling').default;
-import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';
+/**
+ * BPMN specific behavior ensuring that bpmndi:Label's dc:Bounds are removed
+ * when shape is resized.
+ *
+ */
+export default class RemoveEmbeddedLabelBoundsBehavior extends CommandInterceptor {
+    /**
+     * @param eventBus
+     * @param modeling
+     */
+    constructor(eventBus: EventBus, modeling: Modeling);
+}
+
+type EventBus = import('diagram-js/lib/core/EventBus').default;
+type Modeling = import('../Modeling').default;
+import CommandInterceptor from 'diagram-js/lib/command/CommandInterceptor';