@fecp/designer 5.5.48 → 5.5.49

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

@@ -0,0 +1,109 @@
+import { attr } from "../../../tiny-svg/dist/index.esm.mjs";
+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);
+  attr(gfx, ELEMENT_ID, id);
+  if (secondaryGfx) {
+    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) {
+    attr(container.gfx, ELEMENT_ID, "");
+    if (container.secondaryGfx) {
+      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) {
+    attr(gfx, ELEMENT_ID, id);
+  }
+  return gfx;
+};
+ElementRegistry.prototype.get = function(filter) {
+  var id;
+  if (typeof filter === "string") {
+    id = filter;
+  } else {
+    id = filter && 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");
+  }
+};
+export {
+  ElementRegistry as default
+};

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

@@ -0,0 +1,202 @@
+import { isArray, isFunction, isNumber, bind, assign } from "../../../min-dash/dist/index.esm.mjs";
+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 = isArray(events) ? events : [events];
+  if (isFunction(priority)) {
+    that = callback;
+    callback = priority;
+    priority = DEFAULT_PRIORITY;
+  }
+  if (!isNumber(priority)) {
+    throw new Error("priority must be a number");
+  }
+  var actualCallback = callback;
+  if (that) {
+    actualCallback = 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 (isFunction(priority)) {
+    that = callback;
+    callback = priority;
+    priority = DEFAULT_PRIORITY;
+  }
+  if (!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 = 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) {
+  assign(this, data || {});
+};
+function invokeFunction(fn, args) {
+  return fn.apply(null, args);
+}
+export {
+  EventBus as default
+};

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

@@ -0,0 +1,124 @@
+import { reduce, forEach } from "../../../min-dash/dist/index.esm.mjs";
+import { getChildren, getVisual } from "../util/GraphicsUtil.mjs";
+import { translate } from "../util/SvgTransformUtil.mjs";
+import { clear } from "../../../min-dom/dist/index.esm.mjs";
+import { create, classes, append, attr, remove } from "../../../tiny-svg/dist/index.esm.mjs";
+import { isFrameElement } from "../util/Elements.mjs";
+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 = getChildren(gfx);
+    if (!childrenGfx) {
+      childrenGfx = create("g");
+      classes(childrenGfx).add("djs-children");
+      append(gfx.parentNode, childrenGfx);
+    }
+  }
+  return childrenGfx;
+};
+GraphicsFactory.prototype._clear = function(gfx) {
+  var visual = getVisual(gfx);
+  clear(visual);
+  return visual;
+};
+GraphicsFactory.prototype._createContainer = function(type, childrenGfx, parentIndex, isFrame) {
+  var outerGfx = create("g");
+  classes(outerGfx).add("djs-group");
+  if (typeof parentIndex !== "undefined") {
+    prependTo(outerGfx, childrenGfx, childrenGfx.childNodes[parentIndex]);
+  } else {
+    append(childrenGfx, outerGfx);
+  }
+  var gfx = create("g");
+  classes(gfx).add("djs-element");
+  classes(gfx).add("djs-" + type);
+  if (isFrame) {
+    classes(gfx).add("djs-frame");
+  }
+  append(outerGfx, gfx);
+  var visual = create("g");
+  classes(visual).add("djs-visual");
+  append(gfx, visual);
+  return gfx;
+};
+GraphicsFactory.prototype.create = function(type, element, parentIndex) {
+  var childrenGfx = this._getChildrenContainer(element.parent);
+  return this._createContainer(type, childrenGfx, parentIndex, isFrameElement(element));
+};
+GraphicsFactory.prototype.updateContainments = function(elements) {
+  var self = this, elementRegistry = this._elementRegistry, parents;
+  parents = reduce(elements, function(map, e) {
+    if (e.parent) {
+      map[e.parent.id] = e.parent;
+    }
+    return map;
+  }, {});
+  forEach(parents, function(parent) {
+    var children = parent.children;
+    if (!children) {
+      return;
+    }
+    var childrenGfx = self._getChildrenContainer(parent);
+    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);
+    translate(gfx, element.x, element.y);
+  } else if (type === "connection") {
+    this.drawConnection(visual, element);
+  } else {
+    throw new Error("unknown type: " + type);
+  }
+  if (element.hidden) {
+    attr(gfx, "display", "none");
+  } else {
+    attr(gfx, "display", "block");
+  }
+};
+GraphicsFactory.prototype.remove = function(element) {
+  var gfx = this._elementRegistry.getGraphics(element);
+  remove(gfx.parentNode);
+};
+function prependTo(newNode, parentNode, siblingNode) {
+  var node = siblingNode || parentNode.firstChild;
+  if (newNode === node) {
+    return;
+  }
+  parentNode.insertBefore(newNode, node);
+}
+export {
+  GraphicsFactory as default
+};

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

@@ -0,0 +1,18 @@
+import DrawModule from "../draw/index.mjs";
+import Canvas from "./Canvas.mjs";
+import ElementRegistry from "./ElementRegistry.mjs";
+import ElementFactory from "./ElementFactory.mjs";
+import EventBus from "./EventBus.mjs";
+import GraphicsFactory from "./GraphicsFactory.mjs";
+const CoreModule = {
+  __depends__: [DrawModule],
+  __init__: ["canvas"],
+  canvas: ["type", Canvas],
+  elementRegistry: ["type", ElementRegistry],
+  elementFactory: ["type", ElementFactory],
+  eventBus: ["type", EventBus],
+  graphicsFactory: ["type", GraphicsFactory]
+};
+export {
+  CoreModule as default
+};

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

@@ -0,0 +1,37 @@
+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() {
+};
+export {
+  BaseRenderer as default
+};

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

@@ -0,0 +1,62 @@
+import e from "../../../inherits-browser/dist/index.es.mjs";
+import BaseRenderer from "./BaseRenderer.mjs";
+import { createLine, componentsToPath } from "../util/RenderUtil.mjs";
+import { create, attr, append } from "../../../tiny-svg/dist/index.esm.mjs";
+import { assign } from "../../../min-dash/dist/index.esm.mjs";
+import { isFrameElement } from "../util/Elements.mjs";
+var DEFAULT_RENDER_PRIORITY = 1;
+function DefaultRenderer(eventBus, styles) {
+  BaseRenderer.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 });
+}
+e(DefaultRenderer, BaseRenderer);
+DefaultRenderer.prototype.canRender = function() {
+  return true;
+};
+DefaultRenderer.prototype.drawShape = function drawShape(visuals, element, attrs) {
+  var rect = create("rect");
+  attr(rect, {
+    x: 0,
+    y: 0,
+    width: element.width || 0,
+    height: element.height || 0
+  });
+  if (isFrameElement(element)) {
+    attr(rect, assign({}, this.FRAME_STYLE, attrs || {}));
+  } else {
+    attr(rect, assign({}, this.SHAPE_STYLE, attrs || {}));
+  }
+  append(visuals, rect);
+  return rect;
+};
+DefaultRenderer.prototype.drawConnection = function drawConnection(visuals, connection, attrs) {
+  var line = createLine(connection.waypoints, assign({}, this.CONNECTION_STYLE, attrs || {}));
+  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 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 componentsToPath(connectionPath);
+};
+DefaultRenderer.$inject = ["eventBus", "styles"];
+export {
+  DefaultRenderer as default
+};

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

@@ -0,0 +1,39 @@
+import { assign, isArray, reduce } from "../../../min-dash/dist/index.esm.mjs";
+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 assign(attrs, { "class": className });
+  };
+  this.style = function(traits, additionalAttrs) {
+    if (!isArray(traits) && !additionalAttrs) {
+      additionalAttrs = traits;
+      traits = [];
+    }
+    var attrs = reduce(traits, function(attrs2, t) {
+      return assign(attrs2, defaultTraits[t] || {});
+    }, {});
+    return additionalAttrs ? assign(attrs, additionalAttrs) : attrs;
+  };
+  this.computeStyle = function(custom, traits, defaultStyles) {
+    if (!isArray(traits)) {
+      defaultStyles = traits;
+      traits = [];
+    }
+    return self.style(traits || [], assign({}, defaultStyles, custom || {}));
+  };
+}
+export {
+  Styles as default
+};

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

@@ -0,0 +1,10 @@
+import DefaultRenderer from "./DefaultRenderer.mjs";
+import Styles from "./Styles.mjs";
+const DrawModule = {
+  __init__: ["defaultRenderer"],
+  defaultRenderer: ["type", DefaultRenderer],
+  styles: ["type", Styles]
+};
+export {
+  DrawModule as default
+};

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

@@ -0,0 +1,35 @@
+import { getType } from "../../util/Elements.mjs";
+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(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"
+];
+export {
+  ChangeSupport as default
+};

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

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