cnhis-design-vue 3.1.14-beta.2 → 3.1.14-beta.5

package/es/node_modules/diagram-js/lib/features/rules/RuleProvider.js

@@ -0,0 +1,88 @@
+import e from '../../../../inherits-browser/dist/index.es.js';
+import CommandInterceptor from '../../command/CommandInterceptor.js';
+
+/**
+ * A basic provider that may be extended to implement modeling rules.
+ *
+ * Extensions should implement the init method to actually add their custom
+ * modeling checks. Checks may be added via the #addRule(action, fn) method.
+ *
+ * @param {EventBus} eventBus
+ */
+function RuleProvider(eventBus) {
+  CommandInterceptor.call(this, eventBus);
+
+  this.init();
+}
+
+RuleProvider.$inject = [ 'eventBus' ];
+
+e(RuleProvider, CommandInterceptor);
+
+
+/**
+ * Adds a modeling rule for the given action, implemented through
+ * a callback function.
+ *
+ * The function will receive the modeling specific action context
+ * to perform its check. It must return `false` to disallow the
+ * action from happening or `true` to allow the action.
+ *
+ * A rule provider may pass over the evaluation to lower priority
+ * rules by returning return nothing (or <code>undefined</code>).
+ *
+ * @example
+ *
+ * ResizableRules.prototype.init = function() {
+ *
+ *   \/**
+ *    * Return `true`, `false` or nothing to denote
+ *    * _allowed_, _not allowed_ and _continue evaluating_.
+ *    *\/
+ *   this.addRule('shape.resize', function(context) {
+ *
+ *     var shape = context.shape;
+ *
+ *     if (!context.newBounds) {
+ *       // check general resizability
+ *       if (!shape.resizable) {
+ *         return false;
+ *       }
+ *
+ *       // not returning anything (read: undefined)
+ *       // will continue the evaluation of other rules
+ *       // (with lower priority)
+ *       return;
+ *     } else {
+ *       // element must have minimum size of 10*10 points
+ *       return context.newBounds.width > 10 && context.newBounds.height > 10;
+ *     }
+ *   });
+ * };
+ *
+ * @param {string|Array<string>} actions the identifier for the modeling action to check
+ * @param {number} [priority] the priority at which this rule is being applied
+ * @param {Function} fn the callback function that performs the actual check
+ */
+RuleProvider.prototype.addRule = function(actions, priority, fn) {
+
+  var self = this;
+
+  if (typeof actions === 'string') {
+    actions = [ actions ];
+  }
+
+  actions.forEach(function(action) {
+
+    self.canExecute(action, priority, function(context, action, event) {
+      return fn(context);
+    }, true);
+  });
+};
+
+/**
+ * Implement this method to add new rules during provider initialization.
+ */
+RuleProvider.prototype.init = function() {};
+
+export { RuleProvider as default };

package/es/node_modules/diagram-js/lib/navigation/movecanvas/MoveCanvas.js

@@ -0,0 +1,120 @@
+import { set, unset } from '../../util/Cursor.js';
+import { install } from '../../util/ClickTrap.js';
+import { delta } from '../../util/PositionUtil.js';
+import { closest, event as componentEvent } from '../../../../min-dom/dist/index.esm.js';
+import { toPoint } from '../../util/Event.js';
+
+var THRESHOLD = 15;
+
+
+/**
+ * Move the canvas via mouse.
+ *
+ * @param {EventBus} eventBus
+ * @param {Canvas} canvas
+ */
+function MoveCanvas(eventBus, canvas) {
+
+  var context;
+
+
+  // listen for move on element mouse down;
+  // allow others to hook into the event before us though
+  // (dragging / element moving will do this)
+  eventBus.on('element.mousedown', 500, function(e) {
+    return handleStart(e.originalEvent);
+  });
+
+
+  function handleMove(event) {
+
+    var start = context.start,
+        button = context.button,
+        position = toPoint(event),
+        delta$1 = delta(position, start);
+
+    if (!context.dragging && length(delta$1) > THRESHOLD) {
+      context.dragging = true;
+
+      if (button === 0) {
+        install(eventBus);
+      }
+
+      set('grab');
+    }
+
+    if (context.dragging) {
+
+      var lastPosition = context.last || context.start;
+
+      delta$1 = delta(position, lastPosition);
+
+      canvas.scroll({
+        dx: delta$1.x,
+        dy: delta$1.y
+      });
+
+      context.last = position;
+    }
+
+    // prevent select
+    event.preventDefault();
+  }
+
+
+  function handleEnd(event) {
+    componentEvent.unbind(document, 'mousemove', handleMove);
+    componentEvent.unbind(document, 'mouseup', handleEnd);
+
+    context = null;
+
+    unset();
+  }
+
+  function handleStart(event) {
+
+    // event is already handled by '.djs-draggable'
+    if (closest(event.target, '.djs-draggable')) {
+      return;
+    }
+
+    var button = event.button;
+
+    // reject right mouse button or modifier key
+    if (button >= 2 || event.ctrlKey || event.shiftKey || event.altKey) {
+      return;
+    }
+
+    context = {
+      button: button,
+      start: toPoint(event)
+    };
+
+    componentEvent.bind(document, 'mousemove', handleMove);
+    componentEvent.bind(document, 'mouseup', handleEnd);
+
+    // we've handled the event
+    return true;
+  }
+
+  this.isActive = function() {
+    return !!context;
+  };
+
+}
+
+
+MoveCanvas.$inject = [
+  'eventBus',
+  'canvas'
+];
+
+
+
+// helpers ///////
+
+function length(point) {
+  return Math.sqrt(Math.pow(point.x, 2) + Math.pow(point.y, 2));
+}
+
+export { MoveCanvas as default };

package/es/node_modules/diagram-js/lib/navigation/movecanvas/index.js

@@ -0,0 +1,8 @@
+import MoveCanvas from './MoveCanvas.js';
+
+var MoveCanvasModule = {
+  __init__: [ 'moveCanvas' ],
+  moveCanvas: [ 'type', MoveCanvas ]
+};
+
+export { MoveCanvasModule as default };

package/es/node_modules/diagram-js/lib/navigation/zoomscroll/ZoomScroll.js

@@ -0,0 +1,227 @@
+import { closest, event as componentEvent } from '../../../../min-dom/dist/index.esm.js';
+import { getStepSize, cap } from './ZoomUtil.js';
+import { log10 } from '../../util/Math.js';
+import { bind } from '../../../../min-dash/dist/index.esm.js';
+
+var sign = Math.sign || function(n) {
+  return n >= 0 ? 1 : -1;
+};
+
+var RANGE = { min: 0.2, max: 4 },
+    NUM_STEPS = 10;
+
+var DELTA_THRESHOLD = 0.1;
+
+var DEFAULT_SCALE = 0.75;
+
+/**
+ * An implementation of zooming and scrolling within the
+ * {@link Canvas} via the mouse wheel.
+ *
+ * Mouse wheel zooming / scrolling may be disabled using
+ * the {@link toggle(enabled)} method.
+ *
+ * @param {Object} [config]
+ * @param {boolean} [config.enabled=true] default enabled state
+ * @param {number} [config.scale=.75] scroll sensivity
+ * @param {EventBus} eventBus
+ * @param {Canvas} canvas
+ */
+function ZoomScroll(config, eventBus, canvas) {
+
+  config = config || {};
+
+  this._enabled = false;
+
+  this._canvas = canvas;
+  this._container = canvas._container;
+
+  this._handleWheel = bind(this._handleWheel, this);
+
+  this._totalDelta = 0;
+  this._scale = config.scale || DEFAULT_SCALE;
+
+  var self = this;
+
+  eventBus.on('canvas.init', function(e) {
+    self._init(config.enabled !== false);
+  });
+}
+
+ZoomScroll.$inject = [
+  'config.zoomScroll',
+  'eventBus',
+  'canvas'
+];
+
+ZoomScroll.prototype.scroll = function scroll(delta) {
+  this._canvas.scroll(delta);
+};
+
+
+ZoomScroll.prototype.reset = function reset() {
+  this._canvas.zoom('fit-viewport');
+};
+
+/**
+ * Zoom depending on delta.
+ *
+ * @param {number} delta
+ * @param {Object} position
+ */
+ZoomScroll.prototype.zoom = function zoom(delta, position) {
+
+  // zoom with half the step size of stepZoom
+  var stepSize = getStepSize(RANGE, NUM_STEPS * 2);
+
+  // add until threshold reached
+  this._totalDelta += delta;
+
+  if (Math.abs(this._totalDelta) > DELTA_THRESHOLD) {
+    this._zoom(delta, position, stepSize);
+
+    // reset
+    this._totalDelta = 0;
+  }
+};
+
+
+ZoomScroll.prototype._handleWheel = function handleWheel(event) {
+
+  // event is already handled by '.djs-scrollable'
+  if (closest(event.target, '.djs-scrollable', true)) {
+    return;
+  }
+
+  var element = this._container;
+
+  event.preventDefault();
+
+  // pinch to zoom is mapped to wheel + ctrlKey = true
+  // in modern browsers (!)
+
+  var isZoom = event.ctrlKey;
+
+  var isHorizontalScroll = event.shiftKey;
+
+  var factor = -1 * this._scale,
+      delta;
+
+  if (isZoom) {
+    factor *= event.deltaMode === 0 ? 0.020 : 0.32;
+  } else {
+    factor *= event.deltaMode === 0 ? 1.0 : 16.0;
+  }
+
+  if (isZoom) {
+    var elementRect = element.getBoundingClientRect();
+
+    var offset = {
+      x: event.clientX - elementRect.left,
+      y: event.clientY - elementRect.top
+    };
+
+    delta = (
+      Math.sqrt(
+        Math.pow(event.deltaY, 2) +
+        Math.pow(event.deltaX, 2)
+      ) * sign(event.deltaY) * factor
+    );
+
+    // zoom in relative to diagram {x,y} coordinates
+    this.zoom(delta, offset);
+  } else {
+
+    if (isHorizontalScroll) {
+      delta = {
+        dx: factor * event.deltaY,
+        dy: 0
+      };
+    } else {
+      delta = {
+        dx: factor * event.deltaX,
+        dy: factor * event.deltaY
+      };
+    }
+
+    this.scroll(delta);
+  }
+};
+
+/**
+ * Zoom with fixed step size.
+ *
+ * @param {number} delta - Zoom delta (1 for zooming in, -1 for out).
+ * @param {Object} position
+ */
+ZoomScroll.prototype.stepZoom = function stepZoom(delta, position) {
+
+  var stepSize = getStepSize(RANGE, NUM_STEPS);
+
+  this._zoom(delta, position, stepSize);
+};
+
+
+/**
+ * Zoom in/out given a step size.
+ *
+ * @param {number} delta
+ * @param {Object} position
+ * @param {number} stepSize
+ */
+ZoomScroll.prototype._zoom = function(delta, position, stepSize) {
+  var canvas = this._canvas;
+
+  var direction = delta > 0 ? 1 : -1;
+
+  var currentLinearZoomLevel = log10(canvas.zoom());
+
+  // snap to a proximate zoom step
+  var newLinearZoomLevel = Math.round(currentLinearZoomLevel / stepSize) * stepSize;
+
+  // increase or decrease one zoom step in the given direction
+  newLinearZoomLevel += stepSize * direction;
+
+  // calculate the absolute logarithmic zoom level based on the linear zoom level
+  // (e.g. 2 for an absolute x2 zoom)
+  var newLogZoomLevel = Math.pow(10, newLinearZoomLevel);
+
+  canvas.zoom(cap(RANGE, newLogZoomLevel), position);
+};
+
+
+/**
+ * Toggle the zoom scroll ability via mouse wheel.
+ *
+ * @param  {boolean} [newEnabled] new enabled state
+ */
+ZoomScroll.prototype.toggle = function toggle(newEnabled) {
+
+  var element = this._container;
+  var handleWheel = this._handleWheel;
+
+  var oldEnabled = this._enabled;
+
+  if (typeof newEnabled === 'undefined') {
+    newEnabled = !oldEnabled;
+  }
+
+  // only react on actual changes
+  if (oldEnabled !== newEnabled) {
+
+    // add or remove wheel listener based on
+    // changed enabled state
+    componentEvent[newEnabled ? 'bind' : 'unbind'](element, 'wheel', handleWheel, false);
+  }
+
+  this._enabled = newEnabled;
+
+  return newEnabled;
+};
+
+
+ZoomScroll.prototype._init = function(newEnabled) {
+  this.toggle(newEnabled);
+};
+
+export { ZoomScroll as default };

package/es/node_modules/diagram-js/lib/navigation/zoomscroll/ZoomUtil.js

@@ -0,0 +1,24 @@
+import { log10 } from '../../util/Math.js';
+
+/**
+ * Get step size for given range and number of steps.
+ *
+ * @param {Object} range
+ * @param {number} range.min
+ * @param {number} range.max
+ */
+function getStepSize(range, steps) {
+
+  var minLinearRange = log10(range.min),
+      maxLinearRange = log10(range.max);
+
+  var absoluteLinearRange = Math.abs(minLinearRange) + Math.abs(maxLinearRange);
+
+  return absoluteLinearRange / steps;
+}
+
+function cap(range, scale) {
+  return Math.max(range.min, Math.min(range.max, scale));
+}
+
+export { cap, getStepSize };

package/es/node_modules/diagram-js/lib/util/ClickTrap.js

@@ -0,0 +1,23 @@
+var TRAP_PRIORITY = 5000;
+
+/**
+ * Installs a click trap that prevents a ghost click following a dragging operation.
+ *
+ * @return {Function} a function to immediately remove the installed trap.
+ */
+function install(eventBus, eventName) {
+
+  eventName = eventName || 'element.click';
+
+  function trap() {
+    return false;
+  }
+
+  eventBus.once(eventName, TRAP_PRIORITY, trap);
+
+  return function() {
+    eventBus.off(eventName, trap);
+  };
+}
+
+export { install };

package/es/node_modules/diagram-js/lib/util/Cursor.js

@@ -0,0 +1,20 @@
+import { classes } from '../../../min-dom/dist/index.esm.js';
+
+var CURSOR_CLS_PATTERN = /^djs-cursor-.*$/;
+
+
+function set(mode) {
+  var classes$1 = classes(document.body);
+
+  classes$1.removeMatching(CURSOR_CLS_PATTERN);
+
+  if (mode) {
+    classes$1.add('djs-cursor-' + mode);
+  }
+}
+
+function unset() {
+  set(null);
+}
+
+export { set, unset };

package/es/node_modules/diagram-js/lib/util/Event.js

@@ -0,0 +1,22 @@
+function getOriginal(event) {
+  return event.originalEvent || event.srcEvent;
+}
+
+
+function toPoint(event) {
+
+  if (event.pointers && event.pointers.length) {
+    event = event.pointers[0];
+  }
+
+  if (event.touches && event.touches.length) {
+    event = event.touches[0];
+  }
+
+  return event ? {
+    x: event.clientX,
+    y: event.clientY
+  } : null;
+}
+
+export { getOriginal, toPoint };

package/es/node_modules/diagram-js/lib/util/Math.js

@@ -0,0 +1,9 @@
+/**
+ * Get the logarithm of x with base 10
+ * @param  {Integer} value
+ */
+function log10(x) {
+  return Math.log(x) / Math.log(10);
+}
+
+export { log10 };

package/es/node_modules/diagram-js/lib/util/Mouse.js

@@ -0,0 +1,30 @@
+import { getOriginal } from './Event.js';
+import { isMac } from './Platform.js';
+export { isMac } from './Platform.js';
+
+function isButton(event, button) {
+  return (getOriginal(event) || event).button === button;
+}
+
+function isPrimaryButton(event) {
+
+  // button === 0 -> left áka primary mouse button
+  return isButton(event, 0);
+}
+
+function hasPrimaryModifier(event) {
+  var originalEvent = getOriginal(event) || event;
+
+  if (!isPrimaryButton(event)) {
+    return false;
+  }
+
+  // Use cmd as primary modifier key for mac OS
+  if (isMac()) {
+    return originalEvent.metaKey;
+  } else {
+    return originalEvent.ctrlKey;
+  }
+}
+
+export { hasPrimaryModifier, isButton, isPrimaryButton };

package/es/node_modules/diagram-js/lib/util/Platform.js

@@ -0,0 +1,5 @@
+function isMac() {
+  return (/mac/i).test(navigator.platform);
+}
+
+export { isMac };

package/es/node_modules/diagram-js/lib/util/PositionUtil.js

@@ -0,0 +1,8 @@
+function delta(a, b) {
+  return {
+    x: a.x - b.x,
+    y: a.y - b.y
+  };
+}
+
+export { delta };

package/es/node_modules/diagram-js/lib/util/RenderUtil.js

@@ -0,0 +1,25 @@
+import { create, attr } from '../../../tiny-svg/dist/index.esm.js';
+
+function toSVGPoints(points) {
+  var result = '';
+
+  for (var i = 0, p; (p = points[i]); i++) {
+    result += p.x + ',' + p.y + ' ';
+  }
+
+  return result;
+}
+
+function createLine(points, attrs) {
+
+  var line = create('polyline');
+  attr(line, { points: toSVGPoints(points) });
+
+  if (attrs) {
+    attr(line, attrs);
+  }
+
+  return line;
+}
+
+export { createLine, toSVGPoints };

package/es/node_modules/diagram-js/lib/util/SvgTransformUtil.js

@@ -0,0 +1,48 @@
+import { createTransform, transform as transform$1 } from '../../../tiny-svg/dist/index.esm.js';
+
+/**
+ * @param {<SVGElement>} element
+ * @param {number} x
+ * @param {number} y
+ * @param {number} angle
+ * @param {number} amount
+ */
+function transform(gfx, x, y, angle, amount) {
+  var translate = createTransform();
+  translate.setTranslate(x, y);
+
+  var rotate = createTransform();
+  rotate.setRotate(angle || 0, 0, 0);
+
+  var scale = createTransform();
+  scale.setScale(amount || 1, amount || 1);
+
+  transform$1(gfx, [ translate, rotate, scale ]);
+}
+
+
+/**
+ * @param {SVGElement} element
+ * @param {number} x
+ * @param {number} y
+ */
+function translate(gfx, x, y) {
+  var translate = createTransform();
+  translate.setTranslate(x, y);
+
+  transform$1(gfx, translate);
+}
+
+
+/**
+ * @param {SVGElement} element
+ * @param {number} angle
+ */
+function rotate(gfx, angle) {
+  var rotate = createTransform();
+  rotate.setRotate(angle, 0, 0);
+
+  transform$1(gfx, rotate);
+}
+
+export { rotate, transform, translate };