@jylups/cmmn-js 0.0.0-stage → 0.21.0

package/lib/features/modeling/cmd/UpdateSemanticParentHandler.js

@@ -0,0 +1,94 @@
+'use strict';
+
+var flatten = require('min-dash').flatten;
+
+var Collections = require('diagram-js/lib/util/Collections');
+
+
+function UpdateSemanticParentHandler() {
+}
+
+module.exports = UpdateSemanticParentHandler;
+
+
+// api /////////////////
+
+UpdateSemanticParentHandler.prototype.preExecute = function(context) {
+  var element = context.element,
+      shape = context.shape;
+
+  if (!element) {
+    throw new Error('element required');
+  }
+
+  var bo = element.businessObject || element;
+
+  context.businessObject = bo;
+  context.oldParent = bo.$parent;
+
+  var changed = [];
+
+  if (element.businessObject) {
+    changed.push(element);
+  }
+
+  if (shape) {
+    changed.push(shape);
+  }
+
+  context.changed = flatten(changed);
+};
+
+UpdateSemanticParentHandler.prototype.execute = function(context) {
+
+  var businessObject = context.businessObject,
+      newParent = context.newParent,
+      containment = context.containment;
+
+  this.updateSemanticParent(businessObject, newParent, containment);
+
+  // indicate changed on objects affected by the update
+  return context.changed;
+};
+
+
+UpdateSemanticParentHandler.prototype.revert = function(context) {
+
+  var businessObject = context.businessObject,
+      newParent = context.oldParent,
+      containment = context.containment;
+
+  this.updateSemanticParent(businessObject, newParent, containment);
+
+  return context.changed;
+};
+
+
+UpdateSemanticParentHandler.prototype.updateSemanticParent = function(element, newParent, containment) {
+
+  if (element.$parent === newParent) {
+    return;
+  }
+
+  var children;
+
+  if (element.$parent && containment) {
+    // remove from old parent
+    children = element.$parent.get(containment);
+    Collections.remove(children, element);
+  }
+
+  element.$parent = null;
+
+  if (newParent) {
+
+    if (containment) {
+      // add to new parent
+      children = newParent.get(containment);
+      children.push(element);
+    }
+
+    element.$parent = newParent;
+  }
+
+};

package/lib/features/modeling/index.js

@@ -0,0 +1,20 @@
+module.exports = {
+  __init__: [ 'modeling', 'cmmnUpdater' ],
+  __depends__: [
+    require('./behavior'),
+    require('../ordering'),
+    require('../replace'),
+    require('../rules'),
+    require('diagram-js/lib/command').default,
+    require('diagram-js/lib/features/selection').default,
+    require('diagram-js/lib/features/label-support').default,
+    require('diagram-js/lib/features/attach-support').default,
+    require('diagram-js/lib/features/change-support').default
+  ],
+  cmmnFactory: [ 'type', require('./CmmnFactory') ],
+  cmmnUpdater: [ 'type', require('./CmmnUpdater') ],
+  elementFactory: [ 'type', require('./ElementFactory') ],
+  modeling: [ 'type', require('./Modeling') ],
+  layouter: [ 'type', require('./CmmnLayouter') ],
+  connectionDocking: [ 'type', require('diagram-js/lib/layout/CroppingConnectionDocking').default ]
+};

package/lib/features/modeling/util/ModelingUtil.js

@@ -0,0 +1,138 @@
+'use strict';
+
+var some = require('min-dash').some;
+
+var ModelUtil = require('../../../util/ModelUtil'),
+    is = ModelUtil.is,
+    getBusinessObject = ModelUtil.getBusinessObject;
+
+var Model = require('diagram-js/lib/model');
+
+/**
+ * Return true if given elements are the same.
+ *
+ * @param {Object} a
+ * @param {Object} b
+ *
+ * @return {boolean}
+ */
+function isSame(a, b) {
+  return a === b;
+}
+
+module.exports.isSame = isSame;
+
+
+/**
+ * Return true if given cases are the same.
+ *
+ * @param {ModdleElement} a
+ * @param {ModdleElement} b
+ *
+ * @return {boolean}
+ */
+function isSameCase(a, b) {
+  return isSame(getCase(a), getCase(b));
+}
+
+module.exports.isSameCase = isSameCase;
+
+function getCase(element) {
+  return getParent(getBusinessObject(element), 'cmmn:Case');
+}
+
+module.exports.getCase = getCase;
+
+
+/**
+ * Return the parents of the element with any of the given types.
+ *
+ * @param {ModdleElement} element
+ * @param {String|Array<String>} anyType
+ *
+ * @return {Array<ModdleElement>}
+ */
+function getParents(element, anyType) {
+
+  var parents = [];
+
+  if (typeof anyType === 'string') {
+    anyType = [ anyType ];
+  }
+
+  while (element) {
+    element = element.$parent || element.parent;
+
+    if (element) {
+
+      if (anyType) {
+        if (isAny(element, anyType)) {
+          parents.push(element);
+        }
+      }
+      else {
+        parents.push(element);
+      }
+
+    }
+
+  }
+
+  return parents;
+}
+
+module.exports.getParents = getParents;
+
+/**
+ * Return the parent of the element with any of the given types.
+ *
+ * @param {ModdleElement} element
+ * @param {String|Array<String>} anyType
+ *
+ * @return {ModdleElement}
+ */
+function getParent(element, anyType) {
+
+  if (typeof anyType === 'string') {
+    anyType = [ anyType ];
+  }
+
+  while ((element = element.$parent || element.parent)) {
+    if (anyType) {
+      if (isAny(element, anyType)) {
+        return element;
+      }
+    }
+    else {
+      return element;
+    }
+  }
+
+  return null;
+}
+
+module.exports.getParent = getParent;
+
+
+/**
+ * Return true if element has any of the given types.
+ *
+ * @param {djs.model.Base} element
+ * @param {Array<String>} types
+ *
+ * @return {Boolean}
+ */
+function isAny(element, types) {
+  return some(types, function(t) {
+    return is(element, t);
+  });
+}
+
+module.exports.isAny = isAny;
+
+
+function isLabel(element) {
+  return element instanceof Model.Label;
+}
+
+module.exports.isLabel = isLabel;

package/lib/features/modeling/util/PlanItemDefinitionUtil.js

@@ -0,0 +1,183 @@
+'use strict';
+
+var ModelUtil = require('../../../util/ModelUtil'),
+    is = ModelUtil.is,
+    getDefinition = ModelUtil.getDefinition,
+    getBusinessObject = ModelUtil.getBusinessObject;
+
+var isAny = require('./ModelingUtil').isAny,
+    getParent = require('./ModelingUtil').getParent;
+
+var eachElement = require('diagram-js/lib/util/Elements').eachElement;
+
+
+/**
+ * Returns all contained discretionary items.
+ *
+ * @param {ModdleElement} element
+ *
+ * @return {Array<ModdleElement>} all discretionary items
+ */
+function getAllDiscretionaryItems(element) {
+
+  element = getBusinessObject(element);
+
+  if (isItemCapable(element)) {
+    element = getDefinition(element);
+  }
+
+  var result = [];
+
+  if (isPlanningTableCapable(element)) {
+    element = element.planningTable;
+
+    if (element) {
+
+      var items = element.get('tableItems');
+      eachElement(items, function(item) {
+        if (isDiscretionaryItem(item)) {
+          result.push(item);
+        }
+        else {
+          return item.get('tableItems');
+        }
+      });
+    }
+  }
+
+  return result;
+}
+
+module.exports.getAllDiscretionaryItems = getAllDiscretionaryItems;
+
+
+/**
+ * Returns all directed item capables elements of the given element.
+ *
+ * @param {ModdleElement} element
+ *
+ * @return {Array<ModdleElement>} all direct item capables
+ */
+function getDirectItemCapables(element) {
+
+  element = getBusinessObject(element);
+
+  if (isItemCapable(element)) {
+    element = getDefinition(element);
+  }
+
+  var result = [];
+
+  function add(item) {
+    result.push(item);
+  }
+
+  if (element) {
+
+    var items;
+
+    if (is(element, 'cmmn:PlanFragment')) {
+      items = element.get('planItems');
+      eachElement(items, add);
+    }
+
+    if (isPlanningTableCapable(element)) {
+      items = getAllDiscretionaryItems(element);
+      eachElement(items, add);
+    }
+
+  }
+
+  return result;
+}
+
+module.exports.getDirectItemCapables = getDirectItemCapables;
+
+
+/**
+ * Returns true if the given element is either a discretionary item
+ * or a plan item
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {boolean} when it is a discretionary item or a plan item
+ */
+function isItemCapable(element) {
+  return isAny(element, [ 'cmmn:DiscretionaryItem', 'cmmn:PlanItem' ]);
+}
+
+module.exports.isItemCapable = isItemCapable;
+
+
+/**
+ * Returns true if the given element is either a human task or
+ * a stage.
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {boolean} when it is a human task or stage
+ */
+function isPlanningTableCapable(element) {
+  return isAny(element, [ 'cmmn:HumanTask', 'cmmn:Stage' ]);
+}
+
+module.exports.isPlanningTableCapable = isPlanningTableCapable;
+
+
+/**
+ * Returns true if the given element is a discretionary item.
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {boolean} when it is a discretionary item
+ */
+function isDiscretionaryItem(element) {
+  return is(element, 'cmmn:DiscretionaryItem');
+}
+
+module.exports.isDiscretionaryItem = isDiscretionaryItem;
+
+
+/**
+ * Returns true if the given element is a discretionary to a human task.
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {boolean} when it is discretionary to a human task
+ */
+function isDiscretionaryToHumanTask(element) {
+  var bo = getBusinessObject(element);
+  var parent = getParent(bo, 'cmmn:PlanItemDefinition');
+  return is(parent, 'cmmn:HumanTask');
+}
+
+module.exports.isDiscretionaryToHumanTask = isDiscretionaryToHumanTask;
+
+
+/**
+ * Returns true if the given element is a human task.
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {boolean} when it is a human task
+ */
+function isHumanTask(element) {
+  return is(element, 'cmmn:HumanTask');
+}
+
+module.exports.isHumanTask = isHumanTask;
+
+
+/**
+ * Returns true if the given element is a plan fragment and not
+ * a stage.
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {boolean} when it is a plan fragment
+ */
+function isPlanFragment(element) {
+  return is(element, 'cmmn:PlanFragment') && !is(element, 'cmmn:Stage');
+}
+
+module.exports.isPlanFragment = isPlanFragment;

package/lib/features/ordering/CmmnOrderingProvider.js

@@ -0,0 +1,146 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var OrderingProvider = require('diagram-js/lib/features/ordering/OrderingProvider').default;
+var findIndex = require('min-dash').findIndex;
+var find = require('min-dash').find;
+var is = require('../../util/ModelUtil').is;
+var isAny = require('../modeling/util/ModelingUtil').isAny;
+
+function CmmnOrderingProvider(eventBus) {
+
+  OrderingProvider.call(this, eventBus);
+
+  var orders = [
+    { type: 'label', order: { level: 10 } },
+    { type: 'cmmn:Criterion', order: { level: 6 } },
+    {
+      type: 'cmmn:OnPart',
+      order: {
+        level: 9,
+        containers: [
+          'cmmn:Stage'
+        ]
+      }
+    },
+    {
+      type: 'cmmn:Association',
+      order: {
+        level: 9,
+        containers: [
+          'cmmndi:CMMNDiagram'
+        ]
+      }
+    },
+    {
+      type: 'cmmndi:CMMNEdge',
+      order: {
+        level: 9,
+        containers: [
+          'cmmn:PlanItem',
+          'cmmn:DiscretionaryItem',
+          'cmmn:Stage'
+        ]
+      }
+    }
+  ];
+
+  function computeOrder(element) {
+
+    if (isCMMNEdge(element)) {
+      element = element.businessObject.cmmnElementRef || element;
+    }
+
+    var entry = find(orders, function(o) {
+      return is(element, o.type);
+    });
+
+    return entry && entry.order || { level: 1 };
+  }
+
+  function getOrder(element) {
+
+    var order = element.order;
+
+    if (!order) {
+      element.order = order = computeOrder(element);
+    }
+
+    return order;
+  }
+
+  function findActualParent(element, newParent, containers) {
+
+    var actualParent = newParent;
+
+    if (isCMMNEdge(element) && element.source) {
+      actualParent = element.source.parent;
+    }
+
+    while (actualParent) {
+
+      if (isAny(actualParent, containers)) {
+        break;
+      }
+
+      actualParent = actualParent.parent;
+    }
+
+    if (!actualParent) {
+      throw new Error('no parent for ' + element.id + ' in ' + newParent.id);
+    }
+
+    return actualParent;
+  }
+
+  this.getOrdering = function(element, newParent) {
+
+    var elementOrder = getOrder(element);
+
+    if (elementOrder.containers) {
+      newParent = findActualParent(element, newParent, elementOrder.containers);
+    }
+
+    var currentIndex = newParent.children.indexOf(element);
+
+    var insertIndex = findIndex(newParent.children, function(child) {
+
+      // do not compare with labels, they are created
+      // in the wrong order (right after elements) during import and
+      // mess up the positioning.
+      if (!element.labelTarget && child.labelTarget) {
+        return false;
+      }
+
+      return elementOrder.level < getOrder(child).level;
+    });
+
+
+    // if the element is already in the child list at
+    // a smaller index, we need to adjust the insert index.
+    // this takes into account that the element is being removed
+    // before being re-inserted
+    if (insertIndex !== -1) {
+      if (currentIndex !== -1 && currentIndex < insertIndex) {
+        insertIndex -= 1;
+      }
+    }
+
+    return {
+      index: insertIndex,
+      parent: newParent
+    };
+
+  };
+}
+
+CmmnOrderingProvider.$inject = [ 'eventBus' ];
+
+inherits(CmmnOrderingProvider, OrderingProvider);
+
+module.exports = CmmnOrderingProvider;
+
+function isCMMNEdge(element) {
+  return is(element, 'cmmndi:CMMNEdge');
+}

package/lib/features/ordering/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  __init__: [ 'cmmnOrderingProvider' ],
+  cmmnOrderingProvider: [ 'type', require('./CmmnOrderingProvider') ]
+};

package/lib/features/outline/Outline.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var BaseOutline = require('diagram-js/lib/features/outline/Outline').default;
+
+var inherits = require('inherits');
+
+var isCasePlanModel = require('../../util/ModelUtil').isCasePlanModel;
+
+var svgAttr = require('tiny-svg').attr;
+
+
+/**
+ * This is a subclass of the Outline module from diagram-js.
+ * It defines outlines which differ from the element size basis.
+ *
+ * @param {EventBus} eventBus
+ * @param {Styles} styles
+ * @param {ElementRegistry} elementRegistry
+ */
+function Outline(eventBus, styles, elementRegistry) {
+  BaseOutline.call(this, eventBus, styles, elementRegistry);
+}
+
+inherits(Outline, BaseOutline);
+
+Outline.$inject = [ 'eventBus', 'styles', 'elementRegistry' ];
+
+Outline.prototype.baseUpdateShapeOutline = BaseOutline.prototype.updateShapeOutline;
+
+Outline.prototype.updateShapeOutline = function(outline, element) {
+
+  if (!isCasePlanModel(element)) {
+
+    this.baseUpdateShapeOutline(outline, element);
+  } else {
+
+    // update outlines for casePlanModels
+    svgAttr(outline, {
+      x: -this.offset,
+      y: -this.offset - 18,
+      width: element.width + this.offset * 2,
+      height: element.height + 18 + this.offset * 2
+    });
+  }
+};
+
+module.exports = Outline;

package/lib/features/outline/index.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = {
+  __init__: [ 'outline' ],
+  outline: [ 'type', require('./Outline') ]
+};