@fecp/designer 5.5.48 → 5.5.50

package/es/node_modules/diagram-js/lib/features/overlays/Overlays.mjs

@@ -0,0 +1,321 @@
+import { assign, isString, filter, matchPattern, isObject, isArray, forEach, find, isDefined } from "../../../../min-dash/dist/index.esm.mjs";
+import { domify as domify$1, assignStyle as assign$1, remove, clear, attr, classes } from "../../../../min-dom/dist/index.esm.mjs";
+import { getBBox } from "../../util/Elements.mjs";
+import IdGenerator from "../../util/IdGenerator.mjs";
+var ids = new IdGenerator("ov");
+var LOW_PRIORITY = 500;
+function Overlays(config, eventBus, canvas, elementRegistry) {
+  this._eventBus = eventBus;
+  this._canvas = canvas;
+  this._elementRegistry = elementRegistry;
+  this._ids = ids;
+  this._overlayDefaults = assign({
+    // no show constraints
+    show: null,
+    // always scale
+    scale: true
+  }, config && config.defaults);
+  this._overlays = {};
+  this._overlayContainers = [];
+  this._overlayRoot = createRoot(canvas.getContainer());
+  this._init();
+}
+Overlays.$inject = [
+  "config.overlays",
+  "eventBus",
+  "canvas",
+  "elementRegistry"
+];
+Overlays.prototype.get = function(search) {
+  if (isString(search)) {
+    search = { id: search };
+  }
+  if (isString(search.element)) {
+    search.element = this._elementRegistry.get(search.element);
+  }
+  if (search.element) {
+    var container = this._getOverlayContainer(search.element, true);
+    if (container) {
+      return search.type ? filter(container.overlays, matchPattern({ type: search.type })) : container.overlays.slice();
+    } else {
+      return [];
+    }
+  } else if (search.type) {
+    return filter(this._overlays, matchPattern({ type: search.type }));
+  } else {
+    return search.id ? this._overlays[search.id] : null;
+  }
+};
+Overlays.prototype.add = function(element, type, overlay) {
+  if (isObject(type)) {
+    overlay = type;
+    type = null;
+  }
+  if (!element.id) {
+    element = this._elementRegistry.get(element);
+  }
+  if (!overlay.position) {
+    throw new Error("must specifiy overlay position");
+  }
+  if (!overlay.html) {
+    throw new Error("must specifiy overlay html");
+  }
+  if (!element) {
+    throw new Error("invalid element specified");
+  }
+  var id = this._ids.next();
+  overlay = assign({}, this._overlayDefaults, overlay, {
+    id,
+    type,
+    element,
+    html: overlay.html
+  });
+  this._addOverlay(overlay);
+  return id;
+};
+Overlays.prototype.remove = function(filter2) {
+  var overlays = this.get(filter2) || [];
+  if (!isArray(overlays)) {
+    overlays = [overlays];
+  }
+  var self = this;
+  forEach(overlays, function(overlay) {
+    var container = self._getOverlayContainer(overlay.element, true);
+    if (overlay) {
+      remove(overlay.html);
+      remove(overlay.htmlContainer);
+      delete overlay.htmlContainer;
+      delete overlay.element;
+      delete self._overlays[overlay.id];
+    }
+    if (container) {
+      var idx = container.overlays.indexOf(overlay);
+      if (idx !== -1) {
+        container.overlays.splice(idx, 1);
+      }
+    }
+  });
+};
+Overlays.prototype.show = function() {
+  setVisible(this._overlayRoot);
+};
+Overlays.prototype.hide = function() {
+  setVisible(this._overlayRoot, false);
+};
+Overlays.prototype.clear = function() {
+  this._overlays = {};
+  this._overlayContainers = [];
+  clear(this._overlayRoot);
+};
+Overlays.prototype._updateOverlayContainer = function(container) {
+  var element = container.element, html = container.html;
+  var x = element.x, y = element.y;
+  if (element.waypoints) {
+    var bbox = getBBox(element);
+    x = bbox.x;
+    y = bbox.y;
+  }
+  setPosition(html, x, y);
+  attr(container.html, "data-container-id", element.id);
+};
+Overlays.prototype._updateOverlay = function(overlay) {
+  var position = overlay.position, htmlContainer = overlay.htmlContainer, element = overlay.element;
+  var left = position.left, top = position.top;
+  if (position.right !== void 0) {
+    var width;
+    if (element.waypoints) {
+      width = getBBox(element).width;
+    } else {
+      width = element.width;
+    }
+    left = position.right * -1 + width;
+  }
+  if (position.bottom !== void 0) {
+    var height;
+    if (element.waypoints) {
+      height = getBBox(element).height;
+    } else {
+      height = element.height;
+    }
+    top = position.bottom * -1 + height;
+  }
+  setPosition(htmlContainer, left || 0, top || 0);
+  this._updateOverlayVisibilty(overlay, this._canvas.viewbox());
+};
+Overlays.prototype._createOverlayContainer = function(element) {
+  var html = domify$1('<div class="djs-overlays" />');
+  assign$1(html, { position: "absolute" });
+  this._overlayRoot.appendChild(html);
+  var container = {
+    html,
+    element,
+    overlays: []
+  };
+  this._updateOverlayContainer(container);
+  this._overlayContainers.push(container);
+  return container;
+};
+Overlays.prototype._updateRoot = function(viewbox) {
+  var scale = viewbox.scale || 1;
+  var matrix = "matrix(" + [
+    scale,
+    0,
+    0,
+    scale,
+    -1 * viewbox.x * scale,
+    -1 * viewbox.y * scale
+  ].join(",") + ")";
+  setTransform(this._overlayRoot, matrix);
+};
+Overlays.prototype._getOverlayContainer = function(element, raw) {
+  var container = find(this._overlayContainers, function(c) {
+    return c.element === element;
+  });
+  if (!container && !raw) {
+    return this._createOverlayContainer(element);
+  }
+  return container;
+};
+Overlays.prototype._addOverlay = function(overlay) {
+  var id = overlay.id, element = overlay.element, html = overlay.html, htmlContainer, overlayContainer;
+  if (html.get && html.constructor.prototype.jquery) {
+    html = html.get(0);
+  }
+  if (isString(html)) {
+    html = domify$1(html);
+  }
+  overlayContainer = this._getOverlayContainer(element);
+  htmlContainer = domify$1('<div class="djs-overlay" data-overlay-id="' + id + '">');
+  assign$1(htmlContainer, { position: "absolute" });
+  htmlContainer.appendChild(html);
+  if (overlay.type) {
+    classes(htmlContainer).add("djs-overlay-" + overlay.type);
+  }
+  var elementRoot = this._canvas.findRoot(element);
+  var activeRoot = this._canvas.getRootElement();
+  setVisible(htmlContainer, elementRoot === activeRoot);
+  overlay.htmlContainer = htmlContainer;
+  overlayContainer.overlays.push(overlay);
+  overlayContainer.html.appendChild(htmlContainer);
+  this._overlays[id] = overlay;
+  this._updateOverlay(overlay);
+  this._updateOverlayVisibilty(overlay, this._canvas.viewbox());
+};
+Overlays.prototype._updateOverlayVisibilty = function(overlay, viewbox) {
+  var show = overlay.show, rootElement = this._canvas.findRoot(overlay.element), minZoom = show && show.minZoom, maxZoom = show && show.maxZoom, htmlContainer = overlay.htmlContainer, activeRootElement = this._canvas.getRootElement(), visible = true;
+  if (rootElement !== activeRootElement) {
+    visible = false;
+  } else if (show) {
+    if (isDefined(minZoom) && minZoom > viewbox.scale || isDefined(maxZoom) && maxZoom < viewbox.scale) {
+      visible = false;
+    }
+  }
+  setVisible(htmlContainer, visible);
+  this._updateOverlayScale(overlay, viewbox);
+};
+Overlays.prototype._updateOverlayScale = function(overlay, viewbox) {
+  var shouldScale = overlay.scale, minScale, maxScale, htmlContainer = overlay.htmlContainer;
+  var scale, transform = "";
+  if (shouldScale !== true) {
+    if (shouldScale === false) {
+      minScale = 1;
+      maxScale = 1;
+    } else {
+      minScale = shouldScale.min;
+      maxScale = shouldScale.max;
+    }
+    if (isDefined(minScale) && viewbox.scale < minScale) {
+      scale = (1 / viewbox.scale || 1) * minScale;
+    }
+    if (isDefined(maxScale) && viewbox.scale > maxScale) {
+      scale = (1 / viewbox.scale || 1) * maxScale;
+    }
+  }
+  if (isDefined(scale)) {
+    transform = "scale(" + scale + "," + scale + ")";
+  }
+  setTransform(htmlContainer, transform);
+};
+Overlays.prototype._updateOverlaysVisibilty = function(viewbox) {
+  var self = this;
+  forEach(this._overlays, function(overlay) {
+    self._updateOverlayVisibilty(overlay, viewbox);
+  });
+};
+Overlays.prototype._init = function() {
+  var eventBus = this._eventBus;
+  var self = this;
+  function updateViewbox(viewbox) {
+    self._updateRoot(viewbox);
+    self._updateOverlaysVisibilty(viewbox);
+    self.show();
+  }
+  eventBus.on("canvas.viewbox.changing", function(event) {
+    self.hide();
+  });
+  eventBus.on("canvas.viewbox.changed", function(event) {
+    updateViewbox(event.viewbox);
+  });
+  eventBus.on(["shape.remove", "connection.remove"], function(e) {
+    var element = e.element;
+    var overlays = self.get({ element });
+    forEach(overlays, function(o) {
+      self.remove(o.id);
+    });
+    var container = self._getOverlayContainer(element);
+    if (container) {
+      remove(container.html);
+      var i = self._overlayContainers.indexOf(container);
+      if (i !== -1) {
+        self._overlayContainers.splice(i, 1);
+      }
+    }
+  });
+  eventBus.on("element.changed", LOW_PRIORITY, function(e) {
+    var element = e.element;
+    var container = self._getOverlayContainer(element, true);
+    if (container) {
+      forEach(container.overlays, function(overlay) {
+        self._updateOverlay(overlay);
+      });
+      self._updateOverlayContainer(container);
+    }
+  });
+  eventBus.on("element.marker.update", function(e) {
+    var container = self._getOverlayContainer(e.element, true);
+    if (container) {
+      classes(container.html)[e.add ? "add" : "remove"](e.marker);
+    }
+  });
+  eventBus.on("root.set", function() {
+    self._updateOverlaysVisibilty(self._canvas.viewbox());
+  });
+  eventBus.on("diagram.clear", this.clear, this);
+};
+function createRoot(parentNode) {
+  var root = domify$1(
+    '<div class="djs-overlay-container" />'
+  );
+  assign$1(root, {
+    position: "absolute",
+    width: 0,
+    height: 0
+  });
+  parentNode.insertBefore(root, parentNode.firstChild);
+  return root;
+}
+function setPosition(el, x, y) {
+  assign$1(el, { left: x + "px", top: y + "px" });
+}
+function setVisible(el, visible) {
+  el.style.display = visible === false ? "none" : "";
+}
+function setTransform(el, transform) {
+  el.style["transform-origin"] = "top left";
+  ["", "-ms-", "-webkit-"].forEach(function(prefix) {
+    el.style[prefix + "transform"] = transform;
+  });
+}
+export {
+  Overlays as default
+};

package/es/node_modules/diagram-js/lib/features/overlays/index.mjs

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

package/es/node_modules/diagram-js/lib/features/root-elements/RootElementsBehavior.mjs

@@ -0,0 +1,24 @@
+import e from "../../../../inherits-browser/dist/index.es.mjs";
+import CommandInterceptor from "../../command/CommandInterceptor.mjs";
+function RootElementsBehavior(canvas, injector) {
+  injector.invoke(CommandInterceptor, this);
+  this.executed(function(event) {
+    var context = event.context;
+    if (context.rootElement) {
+      canvas.setRootElement(context.rootElement);
+    } else {
+      context.rootElement = canvas.getRootElement();
+    }
+  });
+  this.revert(function(event) {
+    var context = event.context;
+    if (context.rootElement) {
+      canvas.setRootElement(context.rootElement);
+    }
+  });
+}
+e(RootElementsBehavior, CommandInterceptor);
+RootElementsBehavior.$inject = ["canvas", "injector"];
+export {
+  RootElementsBehavior as default
+};

package/es/node_modules/diagram-js/lib/features/root-elements/index.mjs

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

package/es/node_modules/diagram-js/lib/features/selection/Selection.mjs

@@ -0,0 +1,57 @@
+import { isArray, forEach } from "../../../../min-dash/dist/index.esm.mjs";
+function Selection(eventBus, canvas) {
+  this._eventBus = eventBus;
+  this._canvas = canvas;
+  this._selectedElements = [];
+  var self = this;
+  eventBus.on(["shape.remove", "connection.remove"], function(e) {
+    var element = e.element;
+    self.deselect(element);
+  });
+  eventBus.on(["diagram.clear", "root.set"], function(e) {
+    self.select(null);
+  });
+}
+Selection.$inject = ["eventBus", "canvas"];
+Selection.prototype.deselect = function(element) {
+  var selectedElements = this._selectedElements;
+  var idx = selectedElements.indexOf(element);
+  if (idx !== -1) {
+    var oldSelection = selectedElements.slice();
+    selectedElements.splice(idx, 1);
+    this._eventBus.fire("selection.changed", { oldSelection, newSelection: selectedElements });
+  }
+};
+Selection.prototype.get = function() {
+  return this._selectedElements;
+};
+Selection.prototype.isSelected = function(element) {
+  return this._selectedElements.indexOf(element) !== -1;
+};
+Selection.prototype.select = function(elements, add) {
+  var selectedElements = this._selectedElements, oldSelection = selectedElements.slice();
+  if (!isArray(elements)) {
+    elements = elements ? [elements] : [];
+  }
+  var canvas = this._canvas;
+  var rootElement = canvas.getRootElement();
+  elements = elements.filter(function(element) {
+    var elementRoot = canvas.findRoot(element);
+    return rootElement === elementRoot;
+  });
+  if (add) {
+    forEach(elements, function(element) {
+      if (selectedElements.indexOf(element) !== -1) {
+        return;
+      } else {
+        selectedElements.push(element);
+      }
+    });
+  } else {
+    this._selectedElements = selectedElements = elements.slice();
+  }
+  this._eventBus.fire("selection.changed", { oldSelection, newSelection: selectedElements });
+};
+export {
+  Selection as default
+};

package/es/node_modules/diagram-js/lib/features/selection/SelectionBehavior.mjs

@@ -0,0 +1,67 @@
+import { isPrimaryButton, hasPrimaryModifier, hasSecondaryModifier } from "../../util/Mouse.mjs";
+import { isArray, find } from "../../../../min-dash/dist/index.esm.mjs";
+function SelectionBehavior(eventBus, selection, canvas, elementRegistry) {
+  eventBus.on("create.end", 500, function(event) {
+    var context = event.context, canExecute = context.canExecute, elements = context.elements, hints = context.hints || {}, autoSelect = hints.autoSelect;
+    if (canExecute) {
+      if (autoSelect === false) {
+        return;
+      }
+      if (isArray(autoSelect)) {
+        selection.select(autoSelect);
+      } else {
+        selection.select(elements.filter(isShown));
+      }
+    }
+  });
+  eventBus.on("connect.end", 500, function(event) {
+    var context = event.context, connection = context.connection;
+    if (connection) {
+      selection.select(connection);
+    }
+  });
+  eventBus.on("shape.move.end", 500, function(event) {
+    var previousSelection = event.previousSelection || [];
+    var shape = elementRegistry.get(event.context.shape.id);
+    var isSelected = find(previousSelection, function(selectedShape) {
+      return shape.id === selectedShape.id;
+    });
+    if (!isSelected) {
+      selection.select(shape);
+    }
+  });
+  eventBus.on("element.click", function(event) {
+    if (!isPrimaryButton(event)) {
+      return;
+    }
+    var element = event.element;
+    if (element === canvas.getRootElement()) {
+      element = null;
+    }
+    var isSelected = selection.isSelected(element), isMultiSelect = selection.get().length > 1;
+    var add = hasPrimaryModifier(event) || hasSecondaryModifier(event);
+    if (isSelected && isMultiSelect) {
+      if (add) {
+        return selection.deselect(element);
+      } else {
+        return selection.select(element);
+      }
+    } else if (!isSelected) {
+      selection.select(element, add);
+    } else {
+      selection.deselect(element);
+    }
+  });
+}
+SelectionBehavior.$inject = [
+  "eventBus",
+  "selection",
+  "canvas",
+  "elementRegistry"
+];
+function isShown(element) {
+  return !element.hidden;
+}
+export {
+  SelectionBehavior as default
+};

package/es/node_modules/diagram-js/lib/features/selection/SelectionVisuals.mjs

@@ -0,0 +1,80 @@
+import { forEach, assign } from "../../../../min-dash/dist/index.esm.mjs";
+import { clear, classes, create, attr, append } from "../../../../tiny-svg/dist/index.esm.mjs";
+import { getBBox } from "../../util/Elements.mjs";
+var MARKER_HOVER = "hover", MARKER_SELECTED = "selected";
+var SELECTION_OUTLINE_PADDING = 6;
+function SelectionVisuals(canvas, eventBus, selection) {
+  this._canvas = canvas;
+  var self = this;
+  this._multiSelectionBox = null;
+  function addMarker(e, cls) {
+    canvas.addMarker(e, cls);
+  }
+  function removeMarker(e, cls) {
+    canvas.removeMarker(e, cls);
+  }
+  eventBus.on("element.hover", function(event) {
+    addMarker(event.element, MARKER_HOVER);
+  });
+  eventBus.on("element.out", function(event) {
+    removeMarker(event.element, MARKER_HOVER);
+  });
+  eventBus.on("selection.changed", function(event) {
+    function deselect(s) {
+      removeMarker(s, MARKER_SELECTED);
+    }
+    function select(s) {
+      addMarker(s, MARKER_SELECTED);
+    }
+    var oldSelection = event.oldSelection, newSelection = event.newSelection;
+    forEach(oldSelection, function(e) {
+      if (newSelection.indexOf(e) === -1) {
+        deselect(e);
+      }
+    });
+    forEach(newSelection, function(e) {
+      if (oldSelection.indexOf(e) === -1) {
+        select(e);
+      }
+    });
+    self._updateSelectionOutline(newSelection);
+  });
+  eventBus.on("element.changed", function(event) {
+    if (selection.isSelected(event.element)) {
+      self._updateSelectionOutline(selection.get());
+    }
+  });
+}
+SelectionVisuals.$inject = [
+  "canvas",
+  "eventBus",
+  "selection"
+];
+SelectionVisuals.prototype._updateSelectionOutline = function(selection) {
+  var layer = this._canvas.getLayer("selectionOutline");
+  clear(layer);
+  var enabled = selection.length > 1;
+  var container = this._canvas.getContainer();
+  classes(container)[enabled ? "add" : "remove"]("djs-multi-select");
+  if (!enabled) {
+    return;
+  }
+  var bBox = addSelectionOutlinePadding(getBBox(selection));
+  var rect = create("rect");
+  attr(rect, assign({
+    rx: 3
+  }, bBox));
+  classes(rect).add("djs-selection-outline");
+  append(layer, rect);
+};
+function addSelectionOutlinePadding(bBox) {
+  return {
+    x: bBox.x - SELECTION_OUTLINE_PADDING,
+    y: bBox.y - SELECTION_OUTLINE_PADDING,
+    width: bBox.width + SELECTION_OUTLINE_PADDING * 2,
+    height: bBox.height + SELECTION_OUTLINE_PADDING * 2
+  };
+}
+export {
+  SelectionVisuals as default
+};

package/es/node_modules/diagram-js/lib/features/selection/index.mjs

@@ -0,0 +1,18 @@
+import InteractionEventsModule from "../interaction-events/index.mjs";
+import OutlineModule from "../outline/index.mjs";
+import Selection from "./Selection.mjs";
+import SelectionVisuals from "./SelectionVisuals.mjs";
+import SelectionBehavior from "./SelectionBehavior.mjs";
+const SelectionModule = {
+  __init__: ["selectionVisuals", "selectionBehavior"],
+  __depends__: [
+    InteractionEventsModule,
+    OutlineModule
+  ],
+  selection: ["type", Selection],
+  selectionVisuals: ["type", SelectionVisuals],
+  selectionBehavior: ["type", SelectionBehavior]
+};
+export {
+  SelectionModule as default
+};

package/es/node_modules/diagram-js/lib/i18n/translate/index.mjs

@@ -0,0 +1,7 @@
+import translate$1 from "./translate.mjs";
+const translate = {
+  translate: ["value", translate$1]
+};
+export {
+  translate as default
+};

package/es/node_modules/diagram-js/lib/i18n/translate/translate.mjs

@@ -0,0 +1,9 @@
+function translate(template, replacements) {
+  replacements = replacements || {};
+  return template.replace(/{([^}]+)}/g, function(_, key) {
+    return replacements[key] || "{" + key + "}";
+  });
+}
+export {
+  translate as default
+};

package/es/node_modules/diagram-js/lib/layout/LayoutUtil.mjs

@@ -0,0 +1,82 @@
+function roundPoint(point) {
+  return {
+    x: Math.round(point.x),
+    y: Math.round(point.y)
+  };
+}
+function asTRBL(bounds) {
+  return {
+    top: bounds.y,
+    right: bounds.x + (bounds.width || 0),
+    bottom: bounds.y + (bounds.height || 0),
+    left: bounds.x
+  };
+}
+function asBounds(trbl) {
+  return {
+    x: trbl.left,
+    y: trbl.top,
+    width: trbl.right - trbl.left,
+    height: trbl.bottom - trbl.top
+  };
+}
+function getBoundsMid(bounds) {
+  return roundPoint({
+    x: bounds.x + (bounds.width || 0) / 2,
+    y: bounds.y + (bounds.height || 0) / 2
+  });
+}
+function getConnectionMid(connection) {
+  var waypoints = connection.waypoints;
+  var parts = waypoints.reduce(function(parts2, point, index) {
+    var lastPoint = waypoints[index - 1];
+    if (lastPoint) {
+      var lastPart = parts2[parts2.length - 1];
+      var startLength = lastPart && lastPart.endLength || 0;
+      var length = distance(lastPoint, point);
+      parts2.push({
+        start: lastPoint,
+        end: point,
+        startLength,
+        endLength: startLength + length,
+        length
+      });
+    }
+    return parts2;
+  }, []);
+  var totalLength = parts.reduce(function(length, part) {
+    return length + part.length;
+  }, 0);
+  var midLength = totalLength / 2;
+  var i = 0;
+  var midSegment = parts[i];
+  while (midSegment.endLength < midLength) {
+    midSegment = parts[++i];
+  }
+  var segmentProgress = (midLength - midSegment.startLength) / midSegment.length;
+  var midPoint = {
+    x: midSegment.start.x + (midSegment.end.x - midSegment.start.x) * segmentProgress,
+    y: midSegment.start.y + (midSegment.end.y - midSegment.start.y) * segmentProgress
+  };
+  return midPoint;
+}
+function getMid(element) {
+  if (isConnection(element)) {
+    return getConnectionMid(element);
+  }
+  return getBoundsMid(element);
+}
+function distance(a, b) {
+  return Math.sqrt(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2));
+}
+function isConnection(element) {
+  return !!element.waypoints;
+}
+export {
+  asBounds,
+  asTRBL,
+  getBoundsMid,
+  getConnectionMid,
+  getMid,
+  roundPoint
+};