@jylups/cmmn-js 0.0.0-stage → 0.21.0

package/lib/features/rules/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  __depends__: [
+    require('diagram-js/lib/features/rules').default
+  ],
+  __init__: [ 'cmmnRules' ],
+  cmmnRules: [ 'type', require('./CmmnRules') ]
+};

package/lib/features/search/CmmnSearchProvider.js

@@ -0,0 +1,129 @@
+'use strict';
+
+var map = require('min-dash').map,
+    filter = require('min-dash').filter,
+    sortBy = require('min-dash').sortBy;
+
+var labelUtil = require('../label-editing/LabelUtil');
+
+
+/**
+ * Provides ability to search through CMMN elements
+ */
+function CmmnSearchProvider(elementRegistry, searchPad, canvas) {
+
+  this._elementRegistry = elementRegistry;
+  this._canvas = canvas;
+
+  searchPad.registerProvider(this);
+}
+
+module.exports = CmmnSearchProvider;
+
+CmmnSearchProvider.$inject = [
+  'elementRegistry',
+  'searchPad',
+  'canvas'
+];
+
+
+/**
+ * Finds all elements that match given pattern
+ *
+ * <Result> :
+ *  {
+ *    primaryTokens: <Array<Token>>,
+ *    secondaryTokens: <Array<Token>>,
+ *    element: <Element>
+ *  }
+ *
+ * <Token> :
+ *  {
+ *    normal|matched: <String>
+ *  }
+ *
+ * @param  {String} pattern
+ * @return {Array<Result>}
+ */
+CmmnSearchProvider.prototype.find = function(pattern) {
+  var rootElement = this._canvas.getRootElement();
+
+  var elements = this._elementRegistry.filter(function(element) {
+    if (element.labelTarget) {
+      return false;
+    }
+    return true;
+  });
+
+  // do not include root element
+  elements = filter(elements, function(element) {
+    return element !== rootElement;
+  });
+
+  elements = map(elements, function(element) {
+    return {
+      primaryTokens: matchAndSplit(labelUtil.getLabel(element), pattern),
+      secondaryTokens: matchAndSplit(element.id, pattern),
+      element: element
+    };
+  });
+
+  // exclude non-matched elements
+  elements = filter(elements, function(element) {
+    return hasMatched(element.primaryTokens) || hasMatched(element.secondaryTokens);
+  });
+
+  elements = sortBy(elements, function(element) {
+    return labelUtil.getLabel(element.element) + element.element.id;
+  });
+
+  return elements;
+};
+
+
+function hasMatched(tokens) {
+  var matched = filter(tokens, function(t) {
+    return !!t.matched;
+  });
+
+  return matched.length > 0;
+}
+
+
+function matchAndSplit(text, pattern) {
+  var tokens = [],
+      originalText = text;
+
+  if (!text) {
+    return tokens;
+  }
+
+  text = text.toLowerCase();
+  pattern = pattern.toLowerCase();
+
+  var i = text.indexOf(pattern);
+
+  if (i > -1) {
+    if (i !== 0) {
+      tokens.push({
+        normal: originalText.substr(0, i)
+      });
+    }
+
+    tokens.push({
+      matched: originalText.substr(i, pattern.length)
+    });
+
+    if (pattern.length + i < text.length) {
+      tokens.push({
+        normal: originalText.substr(pattern.length + i, text.length)
+      });
+    }
+  } else {
+    tokens.push({
+      normal: originalText
+    });
+  }
+
+  return tokens;
+}

package/lib/features/search/index.js

@@ -0,0 +1,7 @@
+module.exports = {
+  __depends__: [
+    require('diagram-js/lib/features/search-pad').default
+  ],
+  __init__: [ 'cmmnSearch'],
+  cmmnSearch: [ 'type', require('./CmmnSearchProvider') ]
+};

package/lib/features/snapping/CmmnConnectSnapping.js

@@ -0,0 +1,110 @@
+var SnapUtil = require('diagram-js/lib/features/snapping/SnapUtil'),
+    mid =SnapUtil.mid,
+    setSnapped = SnapUtil.setSnapped;
+
+var isCmd = require('diagram-js/lib/features/keyboard/KeyboardUtil').isCmd;
+
+var ModelUtil = require('../../util/ModelUtil'),
+    is = ModelUtil.is,
+    getDefinition = ModelUtil.getDefinition,
+    getBusinessObject = ModelUtil.getBusinessObject;
+
+var HIGHER_PRIORITY = 1250;
+
+
+/**
+   * Snap during connect.
+   *
+   * @param {EventBus} eventBus
+   * @param {Rules} rules
+   */
+function CmmnConnectSnapping(eventBus, rules) {
+  eventBus.on([
+    'connect.hover',
+    'connect.move',
+    'connect.end',
+  ], HIGHER_PRIORITY, function(event) {
+    var context = event.context,
+        source = context.source,
+        target = context.target,
+        canExecute = context.canExecute;
+
+    if (!canExecute) {
+      return;
+    }
+
+    if (event.originalEvent && isCmd(event.originalEvent)) {
+      return;
+    }
+
+    if (!context.initialSourcePosition) {
+      context.initialSourcePosition = context.sourcePosition;
+    }
+
+    var connectionAttrs = rules.allowed('connection.create', {
+      source: source,
+      target: target
+    });
+
+    if (connectionAttrs && isCenterSnapTarget(source)) {
+      // snap source
+      context.sourcePosition = mid(source);
+    }
+
+    if (connectionAttrs && isCenterSnapTarget(target)) {
+
+      // snap target
+      snapToPosition(event, mid(target));
+    }
+  });
+}
+
+CmmnConnectSnapping.$inject = [
+  'eventBus',
+  'rules'
+];
+
+module.exports = CmmnConnectSnapping;
+
+// helpers //////////
+
+function snapToPosition(event, position) {
+  setSnapped(event, 'x', position.x);
+  setSnapped(event, 'y', position.y);
+}
+
+/**
+ * Returns true if element should be center snapped when
+ * creating a connection.
+ *
+ * This applies to all collapsed and non container elements.
+ *
+ * @param {djs.model.Base} element
+ *
+ * @return {Boolean}
+ */
+function isCenterSnapTarget(element) {
+
+  if (!element) {
+    return false;
+  }
+
+  if (is(element, 'cmmn:Stage')) {
+    return false;
+  }
+
+  var bo = getBusinessObject(element);
+  var definition = getDefinition(element) || element;
+
+  if (!is(definition, 'cmmn:PlanFragment')) {
+    return true;
+  }
+
+  var di = bo.di;
+
+  if (di && di.isCollapsed === true) {
+    return true;
+  }
+
+  return false;
+}

package/lib/features/snapping/CmmnCreateMoveSnapping.js

@@ -0,0 +1,148 @@
+'use strict';
+
+var inherits = require('inherits');
+
+var SnapUtil = require('diagram-js/lib/features/snapping/SnapUtil');
+
+var CreateMoveSnapping = require('diagram-js/lib/features/snapping/CreateMoveSnapping').default;
+
+var isSnapped = SnapUtil.isSnapped,
+    setSnapped = SnapUtil.setSnapped;
+
+var asTRBL = require('diagram-js/lib/layout/LayoutUtil').asTRBL,
+    getMid = require('diagram-js/lib/layout/LayoutUtil').getMid;
+
+var getCriterionAttachment = require('./CmmnSnappingUtil').getCriterionAttachment;
+
+var forEach = require('min-dash').forEach;
+
+
+/**
+ * Cmmn specific create move snapping functionality
+ *
+ * @param {EventBus} eventBus
+ * @param {CmmnRules} cmmnRules
+ */
+function CmmnCreateMoveSnapping(eventBus, cmmnRules, injector) {
+
+  injector.invoke(CreateMoveSnapping, this);
+
+  function canAttach(shape, target, position) {
+    return cmmnRules.canAttach([ shape ], target, null, position) === 'attach';
+  }
+
+  eventBus.on([
+    'create.move',
+    'create.end',
+    'shape.move.move',
+    'shape.move.end'
+  ], 1500, function(event) {
+
+    var context = event.context,
+        target = context.target,
+        shape = context.shape;
+
+    if (target && !isSnapped(event) && canAttach(shape, target, event)) {
+      snapCriterion(event, shape, target);
+    }
+  });
+
+
+  function snapCriterion(event, shape, target) {
+    var targetTRBL = asTRBL(target);
+
+    var direction = getCriterionAttachment(event, target);
+
+    if (/top/.test(direction)) {
+      setSnapped(event, 'y', targetTRBL.top);
+    } else
+    if (/bottom/.test(direction)) {
+      setSnapped(event, 'y', targetTRBL.bottom);
+    }
+
+    if (/left/.test(direction)) {
+      setSnapped(event, 'x', targetTRBL.left);
+    } else
+    if (/right/.test(direction)) {
+      setSnapped(event, 'x', targetTRBL.right);
+    }
+  }
+}
+
+inherits(CmmnCreateMoveSnapping, CreateMoveSnapping);
+
+CmmnCreateMoveSnapping.$inject = [ 'eventBus', 'cmmnRules', 'injector' ];
+
+module.exports = CmmnCreateMoveSnapping;
+
+
+CmmnCreateMoveSnapping.prototype.initSnap = function(event) {
+  var snapContext = CreateMoveSnapping.prototype.initSnap.call(this, event);
+
+  var shape = event.shape;
+
+  // snap to docking points
+  forEach(shape.outgoing, function(connection) {
+    var docking = connection.waypoints[0];
+
+    docking = docking.original || docking;
+
+    snapContext.setSnapOrigin(connection.id + '-docking', {
+      x: docking.x - event.x,
+      y: docking.y - event.y
+    });
+  });
+
+  forEach(shape.incoming, function(connection) {
+    var docking = connection.waypoints[connection.waypoints.length - 1];
+
+    docking = docking.original || docking;
+
+    snapContext.setSnapOrigin(connection.id + '-docking', {
+      x: docking.x - event.x,
+      y: docking.y - event.y
+    });
+  });
+
+  return snapContext;
+};
+
+
+CmmnCreateMoveSnapping.prototype.addSnapTargetPoints = function(snapPoints, shape, target) {
+  CreateMoveSnapping.prototype.addSnapTargetPoints.call(this, snapPoints, shape, target);
+
+  var snapTargets = this.getSnapTargets(shape, target);
+
+  // snap to docking points
+  forEach(shape.incoming, function(connection) {
+
+    if (!includes(snapTargets, connection.source)) {
+      snapPoints.add('mid', getMid(connection.source));
+    }
+
+    var docking = connection.waypoints[0];
+
+    snapPoints.add(connection.id + '-docking', docking.original || docking);
+  });
+
+
+  forEach(shape.outgoing, function(connection) {
+
+    if (!includes(snapTargets, connection.target)) {
+      snapPoints.add('mid', getMid(connection.target));
+    }
+
+    var docking = connection.waypoints[ connection.waypoints.length - 1 ];
+
+    snapPoints.add(connection.id + '-docking', docking.original || docking);
+  });
+
+  return snapPoints;
+};
+
+
+// helpers ////////////////////
+
+function includes(array, value) {
+  return array.indexOf(value) !== -1;
+}

package/lib/features/snapping/CmmnResizeSnapping.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var is = require('../../util/ModelUtil').is,
+    getDefinition = require('../../util/ModelUtil').getDefinition,
+    isCollapsed = require('../../util/DiUtil').isCollapsed;
+
+var SLIGHTLY_HIGHER_PRIORITY = 1001;
+
+
+/**
+ * Cmmn specific resize snapping functionality
+ *
+ * @param {EventBus} eventBus
+ * @param {CmmnRules} cmmnRules
+ */
+function CmmnResizeSnapping(eventBus) {
+
+  eventBus.on('resize.start', SLIGHTLY_HIGHER_PRIORITY + 500, function(event) {
+    var context = event.context,
+        shape = context.shape;
+
+    if (isStage(shape) && !isCollapsed(shape)) {
+      context.minDimensions = { width: 140, height: 120 };
+    }
+
+    if (is(shape, 'cmmn:TextAnnotation')) {
+      context.minDimensions = { width: 50, height: 30 };
+    }
+
+  });
+
+}
+
+CmmnResizeSnapping.$inject = [ 'eventBus', 'cmmnRules', 'injector' ];
+
+module.exports = CmmnResizeSnapping;
+
+// helpers //////////
+
+function isStage(element) {
+  return is(getDefinition(element), 'cmmn:PlanFragment');
+}

package/lib/features/snapping/CmmnSnappingUtil.js

@@ -0,0 +1,76 @@
+'use strict';
+
+var getOrientation = require('diagram-js/lib/layout/LayoutUtil').getOrientation;
+
+var is = require('../../util/ModelUtil').is,
+    getDefinition = require('../../util/ModelUtil').getDefinition;
+
+
+/**
+ * Get orientation of the given position rectangle in relation to the
+ * given target rectangle. When the position is near a corner (respecting
+ * the given offet) the string 'corner' is returned.
+ *
+ * A padding (positive or negative) may be passed to influence
+ * horizontal / vertical orientation and intersection.
+ *
+ * @param {Bounds} position
+ * @param {Bounds} target
+ * @param {Point|Number} padding
+ * @param {Number} offset
+ */
+function getCornerlessOrientation(position, target, padding, offset) {
+
+  // don't snap to top left corner
+  if (position.x - offset < target.x &&
+      position.y - offset < target.y) {
+    return 'corner';
+  }
+
+  // don't snap to top right corner
+  if (position.x + offset > target.x + target.width &&
+      position.y - offset < target.y) {
+    return 'corner';
+  }
+
+  // don't snap to bottom left corner
+  if (position.x - offset < target.x &&
+      position.y + offset > target.y + target.height) {
+    return 'corner';
+  }
+
+  // don't snap to bottom right corner
+  if (position.x + offset > target.x + target.width &&
+      position.y + offset > target.y + target.height) {
+    return 'corner';
+  }
+
+  return getOrientation(position, target, padding);
+}
+
+
+function getCriterionAttachment(position, target) {
+
+  var orientation;
+
+  var definition = getDefinition(target);
+
+  if (is(target, 'cmmn:PlanItem') && is(definition, 'cmmn:Stage')) {
+    orientation = getCornerlessOrientation(position, target, -15, 20);
+
+  } else
+  if (is(definition, 'cmmn:Milestone')) {
+    orientation = getCornerlessOrientation(position, target, -3, 7);
+
+  } else {
+    orientation = getOrientation(position, target, -15);
+  }
+
+  if (orientation !== 'intersect') {
+    return orientation;
+  } else {
+    return null;
+  }
+}
+
+module.exports.getCriterionAttachment = getCriterionAttachment;

package/lib/features/snapping/index.js

@@ -0,0 +1,17 @@
+var CmmnConnectSnapping = require('./CmmnConnectSnapping');
+var CmmnCreateMoveSnapping = require('./CmmnCreateMoveSnapping');
+var CmmnResizeSnapping = require('./CmmnResizeSnapping');
+var SnappingModule = require('diagram-js/lib/features/snapping').default;
+
+
+module.exports = {
+  __depends__: [ SnappingModule ],
+  __init__: [
+    'connectSnapping',
+    'createMoveSnapping',
+    'resizeSnapping'
+  ],
+  connectSnapping: [ 'type', CmmnConnectSnapping ],
+  createMoveSnapping: [ 'type', CmmnCreateMoveSnapping],
+  resizeSnapping: [ 'type', CmmnResizeSnapping ]
+};