@fecp/designer 5.5.48 → 5.5.49

package/lib/node_modules/diagram-js/lib/core/ElementRegistry.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../tiny-svg/dist/index.esm.js");
+var ELEMENT_ID = "data-element-id";
+function ElementRegistry(eventBus) {
+  this._elements = {};
+  this._eventBus = eventBus;
+}
+ElementRegistry.$inject = ["eventBus"];
+ElementRegistry.prototype.add = function(element, gfx, secondaryGfx) {
+  var id = element.id;
+  this._validateId(id);
+  index_esm.attr(gfx, ELEMENT_ID, id);
+  if (secondaryGfx) {
+    index_esm.attr(secondaryGfx, ELEMENT_ID, id);
+  }
+  this._elements[id] = { element, gfx, secondaryGfx };
+};
+ElementRegistry.prototype.remove = function(element) {
+  var elements = this._elements, id = element.id || element, container = id && elements[id];
+  if (container) {
+    index_esm.attr(container.gfx, ELEMENT_ID, "");
+    if (container.secondaryGfx) {
+      index_esm.attr(container.secondaryGfx, ELEMENT_ID, "");
+    }
+    delete elements[id];
+  }
+};
+ElementRegistry.prototype.updateId = function(element, newId) {
+  this._validateId(newId);
+  if (typeof element === "string") {
+    element = this.get(element);
+  }
+  this._eventBus.fire("element.updateId", {
+    element,
+    newId
+  });
+  var gfx = this.getGraphics(element), secondaryGfx = this.getGraphics(element, true);
+  this.remove(element);
+  element.id = newId;
+  this.add(element, gfx, secondaryGfx);
+};
+ElementRegistry.prototype.updateGraphics = function(filter, gfx, secondary) {
+  var id = filter.id || filter;
+  var container = this._elements[id];
+  if (secondary) {
+    container.secondaryGfx = gfx;
+  } else {
+    container.gfx = gfx;
+  }
+  if (gfx) {
+    index_esm.attr(gfx, ELEMENT_ID, id);
+  }
+  return gfx;
+};
+ElementRegistry.prototype.get = function(filter) {
+  var id;
+  if (typeof filter === "string") {
+    id = filter;
+  } else {
+    id = filter && index_esm.attr(filter, ELEMENT_ID);
+  }
+  var container = this._elements[id];
+  return container && container.element;
+};
+ElementRegistry.prototype.filter = function(fn) {
+  var filtered = [];
+  this.forEach(function(element, gfx) {
+    if (fn(element, gfx)) {
+      filtered.push(element);
+    }
+  });
+  return filtered;
+};
+ElementRegistry.prototype.find = function(fn) {
+  var map = this._elements, keys = Object.keys(map);
+  for (var i = 0; i < keys.length; i++) {
+    var id = keys[i], container = map[id], element = container.element, gfx = container.gfx;
+    if (fn(element, gfx)) {
+      return element;
+    }
+  }
+};
+ElementRegistry.prototype.getAll = function() {
+  return this.filter(function(e) {
+    return e;
+  });
+};
+ElementRegistry.prototype.forEach = function(fn) {
+  var map = this._elements;
+  Object.keys(map).forEach(function(id) {
+    var container = map[id], element = container.element, gfx = container.gfx;
+    return fn(element, gfx);
+  });
+};
+ElementRegistry.prototype.getGraphics = function(filter, secondary) {
+  var id = filter.id || filter;
+  var container = this._elements[id];
+  return container && (secondary ? container.secondaryGfx : container.gfx);
+};
+ElementRegistry.prototype._validateId = function(id) {
+  if (!id) {
+    throw new Error("element must have an id");
+  }
+  if (this._elements[id]) {
+    throw new Error("element with id " + id + " already added");
+  }
+};
+exports.default = ElementRegistry;

package/lib/node_modules/diagram-js/lib/core/EventBus.js

@@ -0,0 +1,202 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../min-dash/dist/index.esm.js");
+var FN_REF = "__fn";
+var DEFAULT_PRIORITY = 1e3;
+var slice = Array.prototype.slice;
+function EventBus() {
+  this._listeners = {};
+  this.on("diagram.destroy", 1, this._destroy, this);
+}
+EventBus.prototype.on = function(events, priority, callback, that) {
+  events = index_esm.isArray(events) ? events : [events];
+  if (index_esm.isFunction(priority)) {
+    that = callback;
+    callback = priority;
+    priority = DEFAULT_PRIORITY;
+  }
+  if (!index_esm.isNumber(priority)) {
+    throw new Error("priority must be a number");
+  }
+  var actualCallback = callback;
+  if (that) {
+    actualCallback = index_esm.bind(callback, that);
+    actualCallback[FN_REF] = callback[FN_REF] || callback;
+  }
+  var self = this;
+  events.forEach(function(e) {
+    self._addListener(e, {
+      priority,
+      callback: actualCallback,
+      next: null
+    });
+  });
+};
+EventBus.prototype.once = function(event, priority, callback, that) {
+  var self = this;
+  if (index_esm.isFunction(priority)) {
+    that = callback;
+    callback = priority;
+    priority = DEFAULT_PRIORITY;
+  }
+  if (!index_esm.isNumber(priority)) {
+    throw new Error("priority must be a number");
+  }
+  function wrappedCallback() {
+    wrappedCallback.__isTomb = true;
+    var result = callback.apply(that, arguments);
+    self.off(event, wrappedCallback);
+    return result;
+  }
+  wrappedCallback[FN_REF] = callback;
+  this.on(event, priority, wrappedCallback);
+};
+EventBus.prototype.off = function(events, callback) {
+  events = index_esm.isArray(events) ? events : [events];
+  var self = this;
+  events.forEach(function(event) {
+    self._removeListener(event, callback);
+  });
+};
+EventBus.prototype.createEvent = function(data) {
+  var event = new InternalEvent();
+  event.init(data);
+  return event;
+};
+EventBus.prototype.fire = function(type, data) {
+  var event, firstListener, returnValue, args;
+  args = slice.call(arguments);
+  if (typeof type === "object") {
+    data = type;
+    type = data.type;
+  }
+  if (!type) {
+    throw new Error("no event type specified");
+  }
+  firstListener = this._listeners[type];
+  if (!firstListener) {
+    return;
+  }
+  if (data instanceof InternalEvent) {
+    event = data;
+  } else {
+    event = this.createEvent(data);
+  }
+  args[0] = event;
+  var originalType = event.type;
+  if (type !== originalType) {
+    event.type = type;
+  }
+  try {
+    returnValue = this._invokeListeners(event, args, firstListener);
+  } finally {
+    if (type !== originalType) {
+      event.type = originalType;
+    }
+  }
+  if (returnValue === void 0 && event.defaultPrevented) {
+    returnValue = false;
+  }
+  return returnValue;
+};
+EventBus.prototype.handleError = function(error) {
+  return this.fire("error", { error }) === false;
+};
+EventBus.prototype._destroy = function() {
+  this._listeners = {};
+};
+EventBus.prototype._invokeListeners = function(event, args, listener) {
+  var returnValue;
+  while (listener) {
+    if (event.cancelBubble) {
+      break;
+    }
+    returnValue = this._invokeListener(event, args, listener);
+    listener = listener.next;
+  }
+  return returnValue;
+};
+EventBus.prototype._invokeListener = function(event, args, listener) {
+  var returnValue;
+  if (listener.callback.__isTomb) {
+    return returnValue;
+  }
+  try {
+    returnValue = invokeFunction(listener.callback, args);
+    if (returnValue !== void 0) {
+      event.returnValue = returnValue;
+      event.stopPropagation();
+    }
+    if (returnValue === false) {
+      event.preventDefault();
+    }
+  } catch (error) {
+    if (!this.handleError(error)) {
+      console.error("unhandled error in event listener", error);
+      throw error;
+    }
+  }
+  return returnValue;
+};
+EventBus.prototype._addListener = function(event, newListener) {
+  var listener = this._getListeners(event), previousListener;
+  if (!listener) {
+    this._setListeners(event, newListener);
+    return;
+  }
+  while (listener) {
+    if (listener.priority < newListener.priority) {
+      newListener.next = listener;
+      if (previousListener) {
+        previousListener.next = newListener;
+      } else {
+        this._setListeners(event, newListener);
+      }
+      return;
+    }
+    previousListener = listener;
+    listener = listener.next;
+  }
+  previousListener.next = newListener;
+};
+EventBus.prototype._getListeners = function(name) {
+  return this._listeners[name];
+};
+EventBus.prototype._setListeners = function(name, listener) {
+  this._listeners[name] = listener;
+};
+EventBus.prototype._removeListener = function(event, callback) {
+  var listener = this._getListeners(event), nextListener, previousListener, listenerCallback;
+  if (!callback) {
+    this._setListeners(event, null);
+    return;
+  }
+  while (listener) {
+    nextListener = listener.next;
+    listenerCallback = listener.callback;
+    if (listenerCallback === callback || listenerCallback[FN_REF] === callback) {
+      if (previousListener) {
+        previousListener.next = nextListener;
+      } else {
+        this._setListeners(event, nextListener);
+      }
+    }
+    previousListener = listener;
+    listener = nextListener;
+  }
+};
+function InternalEvent() {
+}
+InternalEvent.prototype.stopPropagation = function() {
+  this.cancelBubble = true;
+};
+InternalEvent.prototype.preventDefault = function() {
+  this.defaultPrevented = true;
+};
+InternalEvent.prototype.init = function(data) {
+  index_esm.assign(this, data || {});
+};
+function invokeFunction(fn, args) {
+  return fn.apply(null, args);
+}
+exports.default = EventBus;

package/lib/node_modules/diagram-js/lib/core/GraphicsFactory.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm$2 = require("../../../min-dash/dist/index.esm.js");
+const GraphicsUtil = require("../util/GraphicsUtil.js");
+const SvgTransformUtil = require("../util/SvgTransformUtil.js");
+const index_esm$1 = require("../../../min-dom/dist/index.esm.js");
+const index_esm = require("../../../tiny-svg/dist/index.esm.js");
+const Elements = require("../util/Elements.js");
+function GraphicsFactory(eventBus, elementRegistry) {
+  this._eventBus = eventBus;
+  this._elementRegistry = elementRegistry;
+}
+GraphicsFactory.$inject = ["eventBus", "elementRegistry"];
+GraphicsFactory.prototype._getChildrenContainer = function(element) {
+  var gfx = this._elementRegistry.getGraphics(element);
+  var childrenGfx;
+  if (!element.parent) {
+    childrenGfx = gfx;
+  } else {
+    childrenGfx = GraphicsUtil.getChildren(gfx);
+    if (!childrenGfx) {
+      childrenGfx = index_esm.create("g");
+      index_esm.classes(childrenGfx).add("djs-children");
+      index_esm.append(gfx.parentNode, childrenGfx);
+    }
+  }
+  return childrenGfx;
+};
+GraphicsFactory.prototype._clear = function(gfx) {
+  var visual = GraphicsUtil.getVisual(gfx);
+  index_esm$1.clear(visual);
+  return visual;
+};
+GraphicsFactory.prototype._createContainer = function(type, childrenGfx, parentIndex, isFrame) {
+  var outerGfx = index_esm.create("g");
+  index_esm.classes(outerGfx).add("djs-group");
+  if (typeof parentIndex !== "undefined") {
+    prependTo(outerGfx, childrenGfx, childrenGfx.childNodes[parentIndex]);
+  } else {
+    index_esm.append(childrenGfx, outerGfx);
+  }
+  var gfx = index_esm.create("g");
+  index_esm.classes(gfx).add("djs-element");
+  index_esm.classes(gfx).add("djs-" + type);
+  if (isFrame) {
+    index_esm.classes(gfx).add("djs-frame");
+  }
+  index_esm.append(outerGfx, gfx);
+  var visual = index_esm.create("g");
+  index_esm.classes(visual).add("djs-visual");
+  index_esm.append(gfx, visual);
+  return gfx;
+};
+GraphicsFactory.prototype.create = function(type, element, parentIndex) {
+  var childrenGfx = this._getChildrenContainer(element.parent);
+  return this._createContainer(type, childrenGfx, parentIndex, Elements.isFrameElement(element));
+};
+GraphicsFactory.prototype.updateContainments = function(elements) {
+  var self = this, elementRegistry = this._elementRegistry, parents;
+  parents = index_esm$2.reduce(elements, function(map, e) {
+    if (e.parent) {
+      map[e.parent.id] = e.parent;
+    }
+    return map;
+  }, {});
+  index_esm$2.forEach(parents, function(parent) {
+    var children = parent.children;
+    if (!children) {
+      return;
+    }
+    var childrenGfx = self._getChildrenContainer(parent);
+    index_esm$2.forEach(children.slice().reverse(), function(child) {
+      var childGfx = elementRegistry.getGraphics(child);
+      prependTo(childGfx.parentNode, childrenGfx);
+    });
+  });
+};
+GraphicsFactory.prototype.drawShape = function(visual, element) {
+  var eventBus = this._eventBus;
+  return eventBus.fire("render.shape", { gfx: visual, element });
+};
+GraphicsFactory.prototype.getShapePath = function(element) {
+  var eventBus = this._eventBus;
+  return eventBus.fire("render.getShapePath", element);
+};
+GraphicsFactory.prototype.drawConnection = function(visual, element) {
+  var eventBus = this._eventBus;
+  return eventBus.fire("render.connection", { gfx: visual, element });
+};
+GraphicsFactory.prototype.getConnectionPath = function(waypoints) {
+  var eventBus = this._eventBus;
+  return eventBus.fire("render.getConnectionPath", waypoints);
+};
+GraphicsFactory.prototype.update = function(type, element, gfx) {
+  if (!element.parent) {
+    return;
+  }
+  var visual = this._clear(gfx);
+  if (type === "shape") {
+    this.drawShape(visual, element);
+    SvgTransformUtil.translate(gfx, element.x, element.y);
+  } else if (type === "connection") {
+    this.drawConnection(visual, element);
+  } else {
+    throw new Error("unknown type: " + type);
+  }
+  if (element.hidden) {
+    index_esm.attr(gfx, "display", "none");
+  } else {
+    index_esm.attr(gfx, "display", "block");
+  }
+};
+GraphicsFactory.prototype.remove = function(element) {
+  var gfx = this._elementRegistry.getGraphics(element);
+  index_esm.remove(gfx.parentNode);
+};
+function prependTo(newNode, parentNode, siblingNode) {
+  var node = siblingNode || parentNode.firstChild;
+  if (newNode === node) {
+    return;
+  }
+  parentNode.insertBefore(newNode, node);
+}
+exports.default = GraphicsFactory;

package/lib/node_modules/diagram-js/lib/core/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../draw/index.js");
+const Canvas = require("./Canvas.js");
+const ElementRegistry = require("./ElementRegistry.js");
+const ElementFactory = require("./ElementFactory.js");
+const EventBus = require("./EventBus.js");
+const GraphicsFactory = require("./GraphicsFactory.js");
+const CoreModule = {
+  __depends__: [index.default],
+  __init__: ["canvas"],
+  canvas: ["type", Canvas.default],
+  elementRegistry: ["type", ElementRegistry.default],
+  elementFactory: ["type", ElementFactory.default],
+  eventBus: ["type", EventBus.default],
+  graphicsFactory: ["type", GraphicsFactory.default]
+};
+exports.default = CoreModule;

package/lib/node_modules/diagram-js/lib/draw/BaseRenderer.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var DEFAULT_RENDER_PRIORITY = 1e3;
+function BaseRenderer(eventBus, renderPriority) {
+  var self = this;
+  renderPriority = renderPriority || DEFAULT_RENDER_PRIORITY;
+  eventBus.on(["render.shape", "render.connection"], renderPriority, function(evt, context) {
+    var type = evt.type, element = context.element, visuals = context.gfx, attrs = context.attrs;
+    if (self.canRender(element)) {
+      if (type === "render.shape") {
+        return self.drawShape(visuals, element, attrs);
+      } else {
+        return self.drawConnection(visuals, element, attrs);
+      }
+    }
+  });
+  eventBus.on(["render.getShapePath", "render.getConnectionPath"], renderPriority, function(evt, element) {
+    if (self.canRender(element)) {
+      if (evt.type === "render.getShapePath") {
+        return self.getShapePath(element);
+      } else {
+        return self.getConnectionPath(element);
+      }
+    }
+  });
+}
+BaseRenderer.prototype.canRender = function() {
+};
+BaseRenderer.prototype.drawShape = function() {
+};
+BaseRenderer.prototype.drawConnection = function() {
+};
+BaseRenderer.prototype.getShapePath = function() {
+};
+BaseRenderer.prototype.getConnectionPath = function() {
+};
+exports.default = BaseRenderer;

package/lib/node_modules/diagram-js/lib/draw/DefaultRenderer.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_es = require("../../../inherits-browser/dist/index.es.js");
+const BaseRenderer = require("./BaseRenderer.js");
+const RenderUtil = require("../util/RenderUtil.js");
+const index_esm = require("../../../tiny-svg/dist/index.esm.js");
+const index_esm$1 = require("../../../min-dash/dist/index.esm.js");
+const Elements = require("../util/Elements.js");
+var DEFAULT_RENDER_PRIORITY = 1;
+function DefaultRenderer(eventBus, styles) {
+  BaseRenderer.default.call(this, eventBus, DEFAULT_RENDER_PRIORITY);
+  this.CONNECTION_STYLE = styles.style(["no-fill"], { strokeWidth: 5, stroke: "fuchsia" });
+  this.SHAPE_STYLE = styles.style({ fill: "white", stroke: "fuchsia", strokeWidth: 2 });
+  this.FRAME_STYLE = styles.style(["no-fill"], { stroke: "fuchsia", strokeDasharray: 4, strokeWidth: 2 });
+}
+index_es.default(DefaultRenderer, BaseRenderer.default);
+DefaultRenderer.prototype.canRender = function() {
+  return true;
+};
+DefaultRenderer.prototype.drawShape = function drawShape(visuals, element, attrs) {
+  var rect = index_esm.create("rect");
+  index_esm.attr(rect, {
+    x: 0,
+    y: 0,
+    width: element.width || 0,
+    height: element.height || 0
+  });
+  if (Elements.isFrameElement(element)) {
+    index_esm.attr(rect, index_esm$1.assign({}, this.FRAME_STYLE, attrs || {}));
+  } else {
+    index_esm.attr(rect, index_esm$1.assign({}, this.SHAPE_STYLE, attrs || {}));
+  }
+  index_esm.append(visuals, rect);
+  return rect;
+};
+DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection, attrs) {
+  var line = RenderUtil.createLine(connection.waypoints, index_esm$1.assign({}, this.CONNECTION_STYLE, attrs || {}));
+  index_esm.append(visuals, line);
+  return line;
+};
+DefaultRenderer.prototype.getShapePath = function getShapePath(shape) {
+  var x = shape.x, y = shape.y, width = shape.width, height = shape.height;
+  var shapePath = [
+    ["M", x, y],
+    ["l", width, 0],
+    ["l", 0, height],
+    ["l", -width, 0],
+    ["z"]
+  ];
+  return RenderUtil.componentsToPath(shapePath);
+};
+DefaultRenderer.prototype.getConnectionPath = function getConnectionPath(connection) {
+  var waypoints = connection.waypoints;
+  var idx, point, connectionPath = [];
+  for (idx = 0; point = waypoints[idx]; idx++) {
+    point = point.original || point;
+    connectionPath.push([idx === 0 ? "M" : "L", point.x, point.y]);
+  }
+  return RenderUtil.componentsToPath(connectionPath);
+};
+DefaultRenderer.$inject = ["eventBus", "styles"];
+exports.default = DefaultRenderer;

package/lib/node_modules/diagram-js/lib/draw/Styles.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../min-dash/dist/index.esm.js");
+function Styles() {
+  var defaultTraits = {
+    "no-fill": {
+      fill: "none"
+    },
+    "no-border": {
+      strokeOpacity: 0
+    },
+    "no-events": {
+      pointerEvents: "none"
+    }
+  };
+  var self = this;
+  this.cls = function(className, traits, additionalAttrs) {
+    var attrs = this.style(traits, additionalAttrs);
+    return index_esm.assign(attrs, { "class": className });
+  };
+  this.style = function(traits, additionalAttrs) {
+    if (!index_esm.isArray(traits) && !additionalAttrs) {
+      additionalAttrs = traits;
+      traits = [];
+    }
+    var attrs = index_esm.reduce(traits, function(attrs2, t) {
+      return index_esm.assign(attrs2, defaultTraits[t] || {});
+    }, {});
+    return additionalAttrs ? index_esm.assign(attrs, additionalAttrs) : attrs;
+  };
+  this.computeStyle = function(custom, traits, defaultStyles) {
+    if (!index_esm.isArray(traits)) {
+      defaultStyles = traits;
+      traits = [];
+    }
+    return self.style(traits || [], index_esm.assign({}, defaultStyles, custom || {}));
+  };
+}
+exports.default = Styles;

package/lib/node_modules/diagram-js/lib/draw/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const DefaultRenderer = require("./DefaultRenderer.js");
+const Styles = require("./Styles.js");
+const DrawModule = {
+  __init__: ["defaultRenderer"],
+  defaultRenderer: ["type", DefaultRenderer.default],
+  styles: ["type", Styles.default]
+};
+exports.default = DrawModule;

package/lib/node_modules/diagram-js/lib/features/change-support/ChangeSupport.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Elements = require("../../util/Elements.js");
+function ChangeSupport(eventBus, canvas, elementRegistry, graphicsFactory) {
+  eventBus.on("element.changed", function(event) {
+    var element = event.element;
+    if (element.parent || element === canvas.getRootElement()) {
+      event.gfx = elementRegistry.getGraphics(element);
+    }
+    if (!event.gfx) {
+      return;
+    }
+    eventBus.fire(Elements.getType(element) + ".changed", event);
+  });
+  eventBus.on("elements.changed", function(event) {
+    var elements = event.elements;
+    elements.forEach(function(e) {
+      eventBus.fire("element.changed", { element: e });
+    });
+    graphicsFactory.updateContainments(elements);
+  });
+  eventBus.on("shape.changed", function(event) {
+    graphicsFactory.update("shape", event.element, event.gfx);
+  });
+  eventBus.on("connection.changed", function(event) {
+    graphicsFactory.update("connection", event.element, event.gfx);
+  });
+}
+ChangeSupport.$inject = [
+  "eventBus",
+  "canvas",
+  "elementRegistry",
+  "graphicsFactory"
+];
+exports.default = ChangeSupport;

package/lib/node_modules/diagram-js/lib/features/change-support/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const ChangeSupport = require("./ChangeSupport.js");
+const ChangeSupportModule = {
+  __init__: ["changeSupport"],
+  changeSupport: ["type", ChangeSupport.default]
+};
+exports.default = ChangeSupportModule;