cnhis-design-vue 3.1.5-beta.13 → 3.1.5-beta.16

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/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/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/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 };

package/es/node_modules/inherits/inherits.js

@@ -0,0 +1,19 @@
+import { getDefaultExportFromCjs } from '../../_virtual/_commonjsHelpers.js';
+import { i as inherits$1 } from '../../_virtual/inherits.js';
+import { __require as requireInherits_browser } from './inherits_browser.js';
+
+(function (module) {
+	try {
+	  var util = require('util');
+	  /* istanbul ignore next */
+	  if (typeof util.inherits !== 'function') throw '';
+	  module.exports = util.inherits;
+	} catch (e) {
+	  /* istanbul ignore next */
+	  module.exports = requireInherits_browser();
+	}
+} (inherits$1));
+
+var inherits = /*@__PURE__*/getDefaultExportFromCjs(inherits$1.exports);
+
+export { inherits as default };

package/es/node_modules/inherits/inherits_browser.js

@@ -0,0 +1,38 @@
+import { i as inherits_browser } from '../../_virtual/inherits_browser.js';
+
+var hasRequiredInherits_browser;
+
+function requireInherits_browser () {
+	if (hasRequiredInherits_browser) return inherits_browser.exports;
+	hasRequiredInherits_browser = 1;
+	if (typeof Object.create === 'function') {
+	  // implementation from standard node.js 'util' module
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      ctor.prototype = Object.create(superCtor.prototype, {
+	        constructor: {
+	          value: ctor,
+	          enumerable: false,
+	          writable: true,
+	          configurable: true
+	        }
+	      });
+	    }
+	  };
+	} else {
+	  // old school shim for old browsers
+	  inherits_browser.exports = function inherits(ctor, superCtor) {
+	    if (superCtor) {
+	      ctor.super_ = superCtor;
+	      var TempCtor = function () {};
+	      TempCtor.prototype = superCtor.prototype;
+	      ctor.prototype = new TempCtor();
+	      ctor.prototype.constructor = ctor;
+	    }
+	  };
+	}
+	return inherits_browser.exports;
+}
+
+export { requireInherits_browser as __require };

package/es/packages/big-table/index.js

@@ -0,0 +1 @@
+export { default } from './index2.js';

package/es/packages/big-table/index2.js

@@ -0,0 +1,17 @@
+import { COMPONENT_NAMESPACE } from '../../src/global/variable';
+import { safeComponentRegister } from '../../src/utils';
+import { loadVxeTable } from '../../src/utils/loadVxe';
+import { expandXEUtils } from '../../src/utils/utilExpand';
+import { CGrid } from '../../packages/index';
+import './src/BigTable2.js';
+import script from './src/BigTable.vue_vue_type_script_setup_true_lang.js';
+
+const BigTable = script;
+BigTable.install = function(app) {
+  safeComponentRegister(app, BigTable, COMPONENT_NAMESPACE + "BigTable");
+  safeComponentRegister(app, CGrid, COMPONENT_NAMESPACE + "Grid");
+  loadVxeTable(app);
+  expandXEUtils();
+};
+
+export { BigTable as default };