@fecp/designer 5.5.47 → 5.5.49

package/es/node_modules/diagram-js/lib/features/interaction-events/InteractionEvents.mjs

@@ -0,0 +1,215 @@
+import { assign, forEach } from "../../../../min-dash/dist/index.esm.mjs";
+import { queryAll as all, query, delegate } from "../../../../min-dom/dist/index.esm.mjs";
+import { isPrimaryButton, isAuxiliaryButton } from "../../util/Mouse.mjs";
+import { remove, create, attr, append } from "../../../../tiny-svg/dist/index.esm.mjs";
+import { createLine, updateLine } from "../../util/RenderUtil.mjs";
+function allowAll(event) {
+  return true;
+}
+function allowPrimaryAndAuxiliary(event) {
+  return isPrimaryButton(event) || isAuxiliaryButton(event);
+}
+var LOW_PRIORITY = 500;
+function InteractionEvents(eventBus, elementRegistry, styles) {
+  var self = this;
+  function fire(type, event, element) {
+    if (isIgnored(type, event)) {
+      return;
+    }
+    var target, gfx, returnValue;
+    if (!element) {
+      target = event.delegateTarget || event.target;
+      if (target) {
+        gfx = target;
+        element = elementRegistry.get(gfx);
+      }
+    } else {
+      gfx = elementRegistry.getGraphics(element);
+    }
+    if (!gfx || !element) {
+      return;
+    }
+    returnValue = eventBus.fire(type, {
+      element,
+      gfx,
+      originalEvent: event
+    });
+    if (returnValue === false) {
+      event.stopPropagation();
+      event.preventDefault();
+    }
+  }
+  var handlers = {};
+  function mouseHandler(localEventName) {
+    return handlers[localEventName];
+  }
+  function isIgnored(localEventName, event) {
+    var filter = ignoredFilters[localEventName] || isPrimaryButton;
+    return !filter(event);
+  }
+  var bindings = {
+    click: "element.click",
+    contextmenu: "element.contextmenu",
+    dblclick: "element.dblclick",
+    mousedown: "element.mousedown",
+    mousemove: "element.mousemove",
+    mouseover: "element.hover",
+    mouseout: "element.out",
+    mouseup: "element.mouseup"
+  };
+  var ignoredFilters = {
+    "element.contextmenu": allowAll,
+    "element.mousedown": allowPrimaryAndAuxiliary,
+    "element.mouseup": allowPrimaryAndAuxiliary,
+    "element.click": allowPrimaryAndAuxiliary,
+    "element.dblclick": allowPrimaryAndAuxiliary
+  };
+  function triggerMouseEvent(eventName, event, targetElement) {
+    var localEventName = bindings[eventName];
+    if (!localEventName) {
+      throw new Error("unmapped DOM event name <" + eventName + ">");
+    }
+    return fire(localEventName, event, targetElement);
+  }
+  var ELEMENT_SELECTOR = "svg, .djs-element";
+  function registerEvent(node, event, localEvent, ignoredFilter) {
+    var handler = handlers[localEvent] = function(event2) {
+      fire(localEvent, event2);
+    };
+    if (ignoredFilter) {
+      ignoredFilters[localEvent] = ignoredFilter;
+    }
+    handler.$delegate = delegate.bind(node, ELEMENT_SELECTOR, event, handler);
+  }
+  function unregisterEvent(node, event, localEvent) {
+    var handler = mouseHandler(localEvent);
+    if (!handler) {
+      return;
+    }
+    delegate.unbind(node, event, handler.$delegate);
+  }
+  function registerEvents(svg) {
+    forEach(bindings, function(val, key) {
+      registerEvent(svg, key, val);
+    });
+  }
+  function unregisterEvents(svg) {
+    forEach(bindings, function(val, key) {
+      unregisterEvent(svg, key, val);
+    });
+  }
+  eventBus.on("canvas.destroy", function(event) {
+    unregisterEvents(event.svg);
+  });
+  eventBus.on("canvas.init", function(event) {
+    registerEvents(event.svg);
+  });
+  eventBus.on(["shape.added", "connection.added"], function(event) {
+    var element = event.element, gfx = event.gfx;
+    eventBus.fire("interactionEvents.createHit", { element, gfx });
+  });
+  eventBus.on([
+    "shape.changed",
+    "connection.changed"
+  ], LOW_PRIORITY, function(event) {
+    var element = event.element, gfx = event.gfx;
+    eventBus.fire("interactionEvents.updateHit", { element, gfx });
+  });
+  eventBus.on("interactionEvents.createHit", LOW_PRIORITY, function(event) {
+    var element = event.element, gfx = event.gfx;
+    self.createDefaultHit(element, gfx);
+  });
+  eventBus.on("interactionEvents.updateHit", function(event) {
+    var element = event.element, gfx = event.gfx;
+    self.updateDefaultHit(element, gfx);
+  });
+  var STROKE_HIT_STYLE = createHitStyle("djs-hit djs-hit-stroke");
+  var CLICK_STROKE_HIT_STYLE = createHitStyle("djs-hit djs-hit-click-stroke");
+  var ALL_HIT_STYLE = createHitStyle("djs-hit djs-hit-all");
+  var NO_MOVE_HIT_STYLE = createHitStyle("djs-hit djs-hit-no-move");
+  var HIT_TYPES = {
+    "all": ALL_HIT_STYLE,
+    "click-stroke": CLICK_STROKE_HIT_STYLE,
+    "stroke": STROKE_HIT_STYLE,
+    "no-move": NO_MOVE_HIT_STYLE
+  };
+  function createHitStyle(classNames, attrs) {
+    attrs = assign({
+      stroke: "white",
+      strokeWidth: 15
+    }, attrs || {});
+    return styles.cls(classNames, ["no-fill", "no-border"], attrs);
+  }
+  function applyStyle(hit, type) {
+    var attrs = HIT_TYPES[type];
+    if (!attrs) {
+      throw new Error("invalid hit type <" + type + ">");
+    }
+    attr(hit, attrs);
+    return hit;
+  }
+  function appendHit(gfx, hit) {
+    append(gfx, hit);
+  }
+  this.removeHits = function(gfx) {
+    var hits = all(".djs-hit", gfx);
+    forEach(hits, remove);
+  };
+  this.createDefaultHit = function(element, gfx) {
+    var waypoints = element.waypoints, isFrame = element.isFrame, boxType;
+    if (waypoints) {
+      return this.createWaypointsHit(gfx, waypoints);
+    } else {
+      boxType = isFrame ? "stroke" : "all";
+      return this.createBoxHit(gfx, boxType, {
+        width: element.width,
+        height: element.height
+      });
+    }
+  };
+  this.createWaypointsHit = function(gfx, waypoints) {
+    var hit = createLine(waypoints);
+    applyStyle(hit, "stroke");
+    appendHit(gfx, hit);
+    return hit;
+  };
+  this.createBoxHit = function(gfx, type, attrs) {
+    attrs = assign({
+      x: 0,
+      y: 0
+    }, attrs);
+    var hit = create("rect");
+    applyStyle(hit, type);
+    attr(hit, attrs);
+    appendHit(gfx, hit);
+    return hit;
+  };
+  this.updateDefaultHit = function(element, gfx) {
+    var hit = query(".djs-hit", gfx);
+    if (!hit) {
+      return;
+    }
+    if (element.waypoints) {
+      updateLine(hit, element.waypoints);
+    } else {
+      attr(hit, {
+        width: element.width,
+        height: element.height
+      });
+    }
+    return hit;
+  };
+  this.fire = fire;
+  this.triggerMouseEvent = triggerMouseEvent;
+  this.mouseHandler = mouseHandler;
+  this.registerEvent = registerEvent;
+  this.unregisterEvent = unregisterEvent;
+}
+InteractionEvents.$inject = [
+  "eventBus",
+  "elementRegistry",
+  "styles"
+];
+export {
+  InteractionEvents as default
+};

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

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

package/es/node_modules/diagram-js/lib/features/keyboard/Keyboard.mjs

@@ -0,0 +1,111 @@
+import { isFunction } from "../../../../min-dash/dist/index.esm.mjs";
+import { closest, event, matches } from "../../../../min-dom/dist/index.esm.mjs";
+import { isCmd, hasModifier, isShift, isKey } from "./KeyboardUtil.mjs";
+var KEYDOWN_EVENT = "keyboard.keydown", KEYUP_EVENT = "keyboard.keyup";
+var HANDLE_MODIFIER_ATTRIBUTE = "input-handle-modified-keys";
+var DEFAULT_PRIORITY = 1e3;
+function Keyboard(config, eventBus) {
+  var self = this;
+  this._config = config || {};
+  this._eventBus = eventBus;
+  this._keydownHandler = this._keydownHandler.bind(this);
+  this._keyupHandler = this._keyupHandler.bind(this);
+  eventBus.on("diagram.destroy", function() {
+    self._fire("destroy");
+    self.unbind();
+  });
+  eventBus.on("diagram.init", function() {
+    self._fire("init");
+  });
+  eventBus.on("attach", function() {
+    if (config && config.bindTo) {
+      self.bind(config.bindTo);
+    }
+  });
+  eventBus.on("detach", function() {
+    self.unbind();
+  });
+}
+Keyboard.$inject = [
+  "config.keyboard",
+  "eventBus"
+];
+Keyboard.prototype._keydownHandler = function(event2) {
+  this._keyHandler(event2, KEYDOWN_EVENT);
+};
+Keyboard.prototype._keyupHandler = function(event2) {
+  this._keyHandler(event2, KEYUP_EVENT);
+};
+Keyboard.prototype._keyHandler = function(event2, type) {
+  var eventBusResult;
+  if (this._isEventIgnored(event2)) {
+    return;
+  }
+  var context = {
+    keyEvent: event2
+  };
+  eventBusResult = this._eventBus.fire(type || KEYDOWN_EVENT, context);
+  if (eventBusResult) {
+    event2.preventDefault();
+  }
+};
+Keyboard.prototype._isEventIgnored = function(event2) {
+  return isInput(event2.target) && this._isModifiedKeyIgnored(event2);
+};
+Keyboard.prototype._isModifiedKeyIgnored = function(event2) {
+  if (!isCmd(event2)) {
+    return true;
+  }
+  var allowedModifiers = this._getAllowedModifiers(event2.target);
+  return allowedModifiers.indexOf(event2.key) === -1;
+};
+Keyboard.prototype._getAllowedModifiers = function(element) {
+  var modifierContainer = closest(element, "[" + HANDLE_MODIFIER_ATTRIBUTE + "]", true);
+  if (!modifierContainer || this._node && !this._node.contains(modifierContainer)) {
+    return [];
+  }
+  return modifierContainer.getAttribute(HANDLE_MODIFIER_ATTRIBUTE).split(",");
+};
+Keyboard.prototype.bind = function(node) {
+  this.unbind();
+  this._node = node;
+  event.bind(node, "keydown", this._keydownHandler, true);
+  event.bind(node, "keyup", this._keyupHandler, true);
+  this._fire("bind");
+};
+Keyboard.prototype.getBinding = function() {
+  return this._node;
+};
+Keyboard.prototype.unbind = function() {
+  var node = this._node;
+  if (node) {
+    this._fire("unbind");
+    event.unbind(node, "keydown", this._keydownHandler, true);
+    event.unbind(node, "keyup", this._keyupHandler, true);
+  }
+  this._node = null;
+};
+Keyboard.prototype._fire = function(event2) {
+  this._eventBus.fire("keyboard." + event2, { node: this._node });
+};
+Keyboard.prototype.addListener = function(priority, listener, type) {
+  if (isFunction(priority)) {
+    type = listener;
+    listener = priority;
+    priority = DEFAULT_PRIORITY;
+  }
+  this._eventBus.on(type || KEYDOWN_EVENT, priority, listener);
+};
+Keyboard.prototype.removeListener = function(listener, type) {
+  this._eventBus.off(type || KEYDOWN_EVENT, listener);
+};
+Keyboard.prototype.hasModifier = hasModifier;
+Keyboard.prototype.isCmd = isCmd;
+Keyboard.prototype.isShift = isShift;
+Keyboard.prototype.isKey = isKey;
+function isInput(target) {
+  return target && (matches(target, "input, textarea") || target.contentEditable === "true");
+}
+export {
+  Keyboard as default
+};

package/es/node_modules/diagram-js/lib/features/keyboard/KeyboardBindings.mjs

@@ -0,0 +1,79 @@
+import { isUndo, isRedo, isCopy, isPaste, isKey, isCmd } from "./KeyboardUtil.mjs";
+var LOW_PRIORITY = 500;
+function KeyboardBindings(eventBus, keyboard) {
+  var self = this;
+  eventBus.on("editorActions.init", LOW_PRIORITY, function(event) {
+    var editorActions = event.editorActions;
+    self.registerBindings(keyboard, editorActions);
+  });
+}
+KeyboardBindings.$inject = [
+  "eventBus",
+  "keyboard"
+];
+KeyboardBindings.prototype.registerBindings = function(keyboard, editorActions) {
+  function addListener(action, fn) {
+    if (editorActions.isRegistered(action)) {
+      keyboard.addListener(fn);
+    }
+  }
+  addListener("undo", function(context) {
+    var event = context.keyEvent;
+    if (isUndo(event)) {
+      editorActions.trigger("undo");
+      return true;
+    }
+  });
+  addListener("redo", function(context) {
+    var event = context.keyEvent;
+    if (isRedo(event)) {
+      editorActions.trigger("redo");
+      return true;
+    }
+  });
+  addListener("copy", function(context) {
+    var event = context.keyEvent;
+    if (isCopy(event)) {
+      editorActions.trigger("copy");
+      return true;
+    }
+  });
+  addListener("paste", function(context) {
+    var event = context.keyEvent;
+    if (isPaste(event)) {
+      editorActions.trigger("paste");
+      return true;
+    }
+  });
+  addListener("stepZoom", function(context) {
+    var event = context.keyEvent;
+    if (isKey(["+", "Add", "="], event) && isCmd(event)) {
+      editorActions.trigger("stepZoom", { value: 1 });
+      return true;
+    }
+  });
+  addListener("stepZoom", function(context) {
+    var event = context.keyEvent;
+    if (isKey(["-", "Subtract"], event) && isCmd(event)) {
+      editorActions.trigger("stepZoom", { value: -1 });
+      return true;
+    }
+  });
+  addListener("zoom", function(context) {
+    var event = context.keyEvent;
+    if (isKey("0", event) && isCmd(event)) {
+      editorActions.trigger("zoom", { value: 1 });
+      return true;
+    }
+  });
+  addListener("removeSelection", function(context) {
+    var event = context.keyEvent;
+    if (isKey(["Backspace", "Delete", "Del"], event)) {
+      editorActions.trigger("removeSelection");
+      return true;
+    }
+  });
+};
+export {
+  KeyboardBindings as default
+};

package/es/node_modules/diagram-js/lib/features/keyboard/KeyboardUtil.mjs

@@ -0,0 +1,47 @@
+import { isArray } from "../../../../min-dash/dist/index.esm.mjs";
+var KEYCODE_C = 67;
+var KEYCODE_V = 86;
+var KEYCODE_Y = 89;
+var KEYCODE_Z = 90;
+var KEYS_COPY = ["c", "C", KEYCODE_C];
+var KEYS_PASTE = ["v", "V", KEYCODE_V];
+var KEYS_REDO = ["y", "Y", KEYCODE_Y];
+var KEYS_UNDO = ["z", "Z", KEYCODE_Z];
+function hasModifier(event) {
+  return event.ctrlKey || event.metaKey || event.shiftKey || event.altKey;
+}
+function isCmd(event) {
+  if (event.altKey) {
+    return false;
+  }
+  return event.ctrlKey || event.metaKey;
+}
+function isKey(keys, event) {
+  keys = isArray(keys) ? keys : [keys];
+  return keys.indexOf(event.key) !== -1 || keys.indexOf(event.keyCode) !== -1;
+}
+function isShift(event) {
+  return event.shiftKey;
+}
+function isCopy(event) {
+  return isCmd(event) && isKey(KEYS_COPY, event);
+}
+function isPaste(event) {
+  return isCmd(event) && isKey(KEYS_PASTE, event);
+}
+function isUndo(event) {
+  return isCmd(event) && !isShift(event) && isKey(KEYS_UNDO, event);
+}
+function isRedo(event) {
+  return isCmd(event) && (isKey(KEYS_REDO, event) || isKey(KEYS_UNDO, event) && isShift(event));
+}
+export {
+  hasModifier,
+  isCmd,
+  isCopy,
+  isKey,
+  isPaste,
+  isRedo,
+  isShift,
+  isUndo
+};

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

@@ -0,0 +1,10 @@
+import Keyboard from "./Keyboard.mjs";
+import KeyboardBindings from "./KeyboardBindings.mjs";
+const KeyboardModule = {
+  __init__: ["keyboard", "keyboardBindings"],
+  keyboard: ["type", Keyboard],
+  keyboardBindings: ["type", KeyboardBindings]
+};
+export {
+  KeyboardModule as default
+};

package/es/node_modules/diagram-js/lib/features/outline/Outline.mjs

@@ -0,0 +1,59 @@
+import { getBBox } from "../../util/Elements.mjs";
+import { create, attr, append } from "../../../../tiny-svg/dist/index.esm.mjs";
+import { query } from "../../../../min-dom/dist/index.esm.mjs";
+import { assign } from "../../../../min-dash/dist/index.esm.mjs";
+var LOW_PRIORITY = 500;
+function Outline(eventBus, styles, elementRegistry) {
+  this.offset = 6;
+  var OUTLINE_STYLE = styles.cls("djs-outline", ["no-fill"]);
+  var self = this;
+  function createOutline(gfx, bounds) {
+    var outline = create("rect");
+    attr(outline, assign({
+      x: 10,
+      y: 10,
+      rx: 3,
+      width: 100,
+      height: 100
+    }, OUTLINE_STYLE));
+    append(gfx, outline);
+    return outline;
+  }
+  eventBus.on(["shape.added", "shape.changed"], LOW_PRIORITY, function(event) {
+    var element = event.element, gfx = event.gfx;
+    var outline = query(".djs-outline", gfx);
+    if (!outline) {
+      outline = createOutline(gfx);
+    }
+    self.updateShapeOutline(outline, element);
+  });
+  eventBus.on(["connection.added", "connection.changed"], function(event) {
+    var element = event.element, gfx = event.gfx;
+    var outline = query(".djs-outline", gfx);
+    if (!outline) {
+      outline = createOutline(gfx);
+    }
+    self.updateConnectionOutline(outline, element);
+  });
+}
+Outline.prototype.updateShapeOutline = function(outline, element) {
+  attr(outline, {
+    x: -this.offset,
+    y: -this.offset,
+    width: element.width + this.offset * 2,
+    height: element.height + this.offset * 2
+  });
+};
+Outline.prototype.updateConnectionOutline = function(outline, connection) {
+  var bbox = getBBox(connection);
+  attr(outline, {
+    x: bbox.x - this.offset,
+    y: bbox.y - this.offset,
+    width: bbox.width + this.offset * 2,
+    height: bbox.height + this.offset * 2
+  });
+};
+Outline.$inject = ["eventBus", "styles", "elementRegistry"];
+export {
+  Outline as default
+};

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

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