@fecp/designer 5.5.48 → 5.5.50

package/es/node_modules/diagram-js/lib/model/index.mjs

@@ -0,0 +1,69 @@
+import { assign } from "../../../min-dash/dist/index.esm.mjs";
+import e from "../../../inherits-browser/dist/index.es.mjs";
+import Refs from "../../../../_virtual/index.mjs";
+var parentRefs = new Refs({ name: "children", enumerable: true, collection: true }, { name: "parent" }), labelRefs = new Refs({ name: "labels", enumerable: true, collection: true }, { name: "labelTarget" }), attacherRefs = new Refs({ name: "attachers", collection: true }, { name: "host" }), outgoingRefs = new Refs({ name: "outgoing", collection: true }, { name: "source" }), incomingRefs = new Refs({ name: "incoming", collection: true }, { name: "target" });
+function Base() {
+  Object.defineProperty(this, "businessObject", {
+    writable: true
+  });
+  Object.defineProperty(this, "label", {
+    get: function() {
+      return this.labels[0];
+    },
+    set: function(newLabel) {
+      var label = this.label, labels = this.labels;
+      if (!newLabel && label) {
+        labels.remove(label);
+      } else {
+        labels.add(newLabel, 0);
+      }
+    }
+  });
+  parentRefs.bind(this, "parent");
+  labelRefs.bind(this, "labels");
+  outgoingRefs.bind(this, "outgoing");
+  incomingRefs.bind(this, "incoming");
+}
+function Shape() {
+  Base.call(this);
+  parentRefs.bind(this, "children");
+  attacherRefs.bind(this, "host");
+  attacherRefs.bind(this, "attachers");
+}
+e(Shape, Base);
+function Root() {
+  Shape.call(this);
+}
+e(Root, Shape);
+function Label() {
+  Shape.call(this);
+  labelRefs.bind(this, "labelTarget");
+}
+e(Label, Shape);
+function Connection() {
+  Base.call(this);
+  outgoingRefs.bind(this, "source");
+  incomingRefs.bind(this, "target");
+}
+e(Connection, Base);
+var types = {
+  connection: Connection,
+  shape: Shape,
+  label: Label,
+  root: Root
+};
+function create(type, attrs) {
+  var Type = types[type];
+  if (!Type) {
+    throw new Error("unknown type: <" + type + ">");
+  }
+  return assign(new Type(), attrs);
+}
+export {
+  Base,
+  Connection,
+  Label,
+  Root,
+  Shape,
+  create
+};

package/es/node_modules/diagram-js/lib/navigation/keyboard-move/KeyboardMove.mjs

@@ -0,0 +1,82 @@
+import { assign } from "../../../../min-dash/dist/index.esm.mjs";
+var DEFAULT_CONFIG = {
+  moveSpeed: 50,
+  moveSpeedAccelerated: 200
+};
+function KeyboardMove(config, keyboard, canvas) {
+  var self = this;
+  this._config = assign({}, DEFAULT_CONFIG, config || {});
+  keyboard.addListener(arrowsListener);
+  function arrowsListener(context) {
+    var event = context.keyEvent, config2 = self._config;
+    if (!keyboard.isCmd(event)) {
+      return;
+    }
+    if (keyboard.isKey([
+      "ArrowLeft",
+      "Left",
+      "ArrowUp",
+      "Up",
+      "ArrowDown",
+      "Down",
+      "ArrowRight",
+      "Right"
+    ], event)) {
+      var speed = keyboard.isShift(event) ? config2.moveSpeedAccelerated : config2.moveSpeed;
+      var direction;
+      switch (event.key) {
+        case "ArrowLeft":
+        case "Left":
+          direction = "left";
+          break;
+        case "ArrowUp":
+        case "Up":
+          direction = "up";
+          break;
+        case "ArrowRight":
+        case "Right":
+          direction = "right";
+          break;
+        case "ArrowDown":
+        case "Down":
+          direction = "down";
+          break;
+      }
+      self.moveCanvas({
+        speed,
+        direction
+      });
+      return true;
+    }
+  }
+  this.moveCanvas = function(opts) {
+    var dx = 0, dy = 0, speed = opts.speed;
+    var actualSpeed = speed / Math.min(Math.sqrt(canvas.viewbox().scale), 1);
+    switch (opts.direction) {
+      case "left":
+        dx = actualSpeed;
+        break;
+      case "up":
+        dy = actualSpeed;
+        break;
+      case "right":
+        dx = -actualSpeed;
+        break;
+      case "down":
+        dy = -actualSpeed;
+        break;
+    }
+    canvas.scroll({
+      dx,
+      dy
+    });
+  };
+}
+KeyboardMove.$inject = [
+  "config.keyboardMove",
+  "keyboard",
+  "canvas"
+];
+export {
+  KeyboardMove as default
+};

package/es/node_modules/diagram-js/lib/navigation/keyboard-move/index.mjs

@@ -0,0 +1,12 @@
+import KeyboardModule from "../../features/keyboard/index.mjs";
+import KeyboardMove from "./KeyboardMove.mjs";
+const KeyboardMoveModule = {
+  __depends__: [
+    KeyboardModule
+  ],
+  __init__: ["keyboardMove"],
+  keyboardMove: ["type", KeyboardMove]
+};
+export {
+  KeyboardMoveModule as default
+};

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

@@ -0,0 +1,67 @@
+import { set, unset } from "../../util/Cursor.mjs";
+import { install } from "../../util/ClickTrap.mjs";
+import { delta } from "../../util/PositionUtil.mjs";
+import { closest, event } from "../../../../min-dom/dist/index.esm.mjs";
+import { toPoint } from "../../util/Event.mjs";
+var THRESHOLD = 15;
+function MoveCanvas(eventBus, canvas) {
+  var context;
+  eventBus.on("element.mousedown", 500, function(e) {
+    return handleStart(e.originalEvent);
+  });
+  function handleMove(event2) {
+    var start = context.start, button = context.button, position = toPoint(event2), 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;
+    }
+    event2.preventDefault();
+  }
+  function handleEnd(event$1) {
+    event.unbind(document, "mousemove", handleMove);
+    event.unbind(document, "mouseup", handleEnd);
+    context = null;
+    unset();
+  }
+  function handleStart(event$1) {
+    if (closest(event$1.target, ".djs-draggable")) {
+      return;
+    }
+    var button = event$1.button;
+    if (button >= 2 || event$1.ctrlKey || event$1.shiftKey || event$1.altKey) {
+      return;
+    }
+    context = {
+      button,
+      start: toPoint(event$1)
+    };
+    event.bind(document, "mousemove", handleMove);
+    event.bind(document, "mouseup", handleEnd);
+    return true;
+  }
+  this.isActive = function() {
+    return !!context;
+  };
+}
+MoveCanvas.$inject = [
+  "eventBus",
+  "canvas"
+];
+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.mjs

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

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

@@ -0,0 +1,113 @@
+import { closest, event } from "../../../../min-dom/dist/index.esm.mjs";
+import { getStepSize, cap } from "./ZoomUtil.mjs";
+import { log10 } from "../../util/Math.mjs";
+import { bind } from "../../../../min-dash/dist/index.esm.mjs";
+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;
+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");
+};
+ZoomScroll.prototype.zoom = function zoom(delta, position) {
+  var stepSize = getStepSize(RANGE, NUM_STEPS * 2);
+  this._totalDelta += delta;
+  if (Math.abs(this._totalDelta) > DELTA_THRESHOLD) {
+    this._zoom(delta, position, stepSize);
+    this._totalDelta = 0;
+  }
+};
+ZoomScroll.prototype._handleWheel = function handleWheel(event2) {
+  if (closest(event2.target, ".djs-scrollable", true)) {
+    return;
+  }
+  var element = this._container;
+  event2.preventDefault();
+  var isZoom = event2.ctrlKey;
+  var isHorizontalScroll = event2.shiftKey;
+  var factor = -1 * this._scale, delta;
+  if (isZoom) {
+    factor *= event2.deltaMode === 0 ? 0.02 : 0.32;
+  } else {
+    factor *= event2.deltaMode === 0 ? 1 : 16;
+  }
+  if (isZoom) {
+    var elementRect = element.getBoundingClientRect();
+    var offset = {
+      x: event2.clientX - elementRect.left,
+      y: event2.clientY - elementRect.top
+    };
+    delta = Math.sqrt(
+      Math.pow(event2.deltaY, 2) + Math.pow(event2.deltaX, 2)
+    ) * sign(event2.deltaY) * factor;
+    this.zoom(delta, offset);
+  } else {
+    if (isHorizontalScroll) {
+      delta = {
+        dx: factor * event2.deltaY,
+        dy: 0
+      };
+    } else {
+      delta = {
+        dx: factor * event2.deltaX,
+        dy: factor * event2.deltaY
+      };
+    }
+    this.scroll(delta);
+  }
+};
+ZoomScroll.prototype.stepZoom = function stepZoom(delta, position) {
+  var stepSize = getStepSize(RANGE, NUM_STEPS);
+  this._zoom(delta, position, stepSize);
+};
+ZoomScroll.prototype._zoom = function(delta, position, stepSize) {
+  var canvas = this._canvas;
+  var direction = delta > 0 ? 1 : -1;
+  var currentLinearZoomLevel = log10(canvas.zoom());
+  var newLinearZoomLevel = Math.round(currentLinearZoomLevel / stepSize) * stepSize;
+  newLinearZoomLevel += stepSize * direction;
+  var newLogZoomLevel = Math.pow(10, newLinearZoomLevel);
+  canvas.zoom(cap(RANGE, newLogZoomLevel), position);
+};
+ZoomScroll.prototype.toggle = function toggle(newEnabled) {
+  var element = this._container;
+  var handleWheel2 = this._handleWheel;
+  var oldEnabled = this._enabled;
+  if (typeof newEnabled === "undefined") {
+    newEnabled = !oldEnabled;
+  }
+  if (oldEnabled !== newEnabled) {
+    event[newEnabled ? "bind" : "unbind"](element, "wheel", handleWheel2, 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.mjs

@@ -0,0 +1,13 @@
+import { log10 } from "../../util/Math.mjs";
+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/navigation/zoomscroll/index.mjs

@@ -0,0 +1,8 @@
+import ZoomScroll from "./ZoomScroll.mjs";
+const ZoomScrollModule = {
+  __init__: ["zoomScroll"],
+  zoomScroll: ["type", ZoomScroll]
+};
+export {
+  ZoomScrollModule as default
+};

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

@@ -0,0 +1,14 @@
+var TRAP_PRIORITY = 5e3;
+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/Collections.mjs

@@ -0,0 +1,39 @@
+function remove(collection, element) {
+  if (!collection || !element) {
+    return -1;
+  }
+  var idx = collection.indexOf(element);
+  if (idx !== -1) {
+    collection.splice(idx, 1);
+  }
+  return idx;
+}
+function add(collection, element, idx) {
+  if (!collection || !element) {
+    return;
+  }
+  if (typeof idx !== "number") {
+    idx = -1;
+  }
+  var currentIdx = collection.indexOf(element);
+  if (currentIdx !== -1) {
+    if (currentIdx === idx) {
+      return;
+    } else {
+      if (idx !== -1) {
+        collection.splice(currentIdx, 1);
+      } else {
+        return;
+      }
+    }
+  }
+  if (idx !== -1) {
+    collection.splice(idx, 0, element);
+  } else {
+    collection.push(element);
+  }
+}
+export {
+  add,
+  remove
+};

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

@@ -0,0 +1,16 @@
+import { classes } from "../../../min-dom/dist/index.esm.mjs";
+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/Elements.mjs

@@ -0,0 +1,50 @@
+import { isArray, forEach } from "../../../min-dash/dist/index.esm.mjs";
+function getBBox(elements, stopRecursion) {
+  stopRecursion = !!stopRecursion;
+  if (!isArray(elements)) {
+    elements = [elements];
+  }
+  var minX, minY, maxX, maxY;
+  forEach(elements, function(element) {
+    var bbox = element;
+    if (element.waypoints && !stopRecursion) {
+      bbox = getBBox(element.waypoints, true);
+    }
+    var x = bbox.x, y = bbox.y, height = bbox.height || 0, width = bbox.width || 0;
+    if (x < minX || minX === void 0) {
+      minX = x;
+    }
+    if (y < minY || minY === void 0) {
+      minY = y;
+    }
+    if (x + width > maxX || maxX === void 0) {
+      maxX = x + width;
+    }
+    if (y + height > maxY || maxY === void 0) {
+      maxY = y + height;
+    }
+  });
+  return {
+    x: minX,
+    y: minY,
+    height: maxY - minY,
+    width: maxX - minX
+  };
+}
+function getType(element) {
+  if ("waypoints" in element) {
+    return "connection";
+  }
+  if ("x" in element) {
+    return "shape";
+  }
+  return "root";
+}
+function isFrameElement(element) {
+  return !!(element && element.isFrame);
+}
+export {
+  getBBox,
+  getType,
+  isFrameElement
+};

package/es/node_modules/diagram-js/lib/util/EscapeUtil.mjs

@@ -0,0 +1,17 @@
+import "../../../../_virtual/css.escape.mjs";
+var HTML_ESCAPE_MAP = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHTML(str) {
+  str = "" + str;
+  return str && str.replace(/[&<>"']/g, function(match) {
+    return HTML_ESCAPE_MAP[match];
+  });
+}
+export {
+  escapeHTML
+};

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

@@ -0,0 +1,19 @@
+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/GraphicsUtil.mjs

@@ -0,0 +1,10 @@
+function getVisual(gfx) {
+  return gfx.childNodes[0];
+}
+function getChildren(gfx) {
+  return gfx.parentNode.childNodes[1];
+}
+export {
+  getChildren,
+  getVisual
+};

package/es/node_modules/diagram-js/lib/util/IdGenerator.mjs

@@ -0,0 +1,10 @@
+function IdGenerator(prefix) {
+  this._counter = 0;
+  this._prefix = (prefix ? prefix + "-" : "") + Math.floor(Math.random() * 1e9) + "-";
+}
+IdGenerator.prototype.next = function() {
+  return this._prefix + ++this._counter;
+};
+export {
+  IdGenerator as default
+};

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

@@ -0,0 +1,6 @@
+function log10(x) {
+  return Math.log(x) / Math.log(10);
+}
+export {
+  log10
+};

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

@@ -0,0 +1,34 @@
+import { getOriginal } from "./Event.mjs";
+import { isMac } from "./Platform.mjs";
+function isButton(event, button) {
+  return (getOriginal(event) || event).button === button;
+}
+function isPrimaryButton(event) {
+  return isButton(event, 0);
+}
+function isAuxiliaryButton(event) {
+  return isButton(event, 1);
+}
+function hasPrimaryModifier(event) {
+  var originalEvent = getOriginal(event) || event;
+  if (!isPrimaryButton(event)) {
+    return false;
+  }
+  if (isMac()) {
+    return originalEvent.metaKey;
+  } else {
+    return originalEvent.ctrlKey;
+  }
+}
+function hasSecondaryModifier(event) {
+  var originalEvent = getOriginal(event) || event;
+  return isPrimaryButton(event) && originalEvent.shiftKey;
+}
+export {
+  hasPrimaryModifier,
+  hasSecondaryModifier,
+  isAuxiliaryButton,
+  isButton,
+  isMac,
+  isPrimaryButton
+};

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

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

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

@@ -0,0 +1,9 @@
+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.mjs

@@ -0,0 +1,29 @@
+import { create, attr } from "../../../tiny-svg/dist/index.esm.mjs";
+function componentsToPath(elements) {
+  return elements.join(",").replace(/,?([A-z]),?/g, "$1");
+}
+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;
+}
+function updateLine(gfx, points) {
+  attr(gfx, { points: toSVGPoints(points) });
+  return gfx;
+}
+export {
+  componentsToPath,
+  createLine,
+  toSVGPoints,
+  updateLine
+};

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

@@ -0,0 +1,25 @@
+import { createTransform, transform as transform$1 } from "../../../tiny-svg/dist/index.esm.mjs";
+function transform(gfx, x, y, angle, amount) {
+  var translate2 = createTransform();
+  translate2.setTranslate(x, y);
+  var rotate2 = createTransform();
+  rotate2.setRotate(angle || 0, 0, 0);
+  var scale = createTransform();
+  scale.setScale(1, 1);
+  transform$1(gfx, [translate2, rotate2, scale]);
+}
+function translate(gfx, x, y) {
+  var translate2 = createTransform();
+  translate2.setTranslate(x, y);
+  transform$1(gfx, translate2);
+}
+function rotate(gfx, angle) {
+  var rotate2 = createTransform();
+  rotate2.setRotate(angle, 0, 0);
+  transform$1(gfx, rotate2);
+}
+export {
+  rotate,
+  transform,
+  translate
+};