@a2simcode/ui 0.0.42 → 0.0.43

package/dist/simcode-ui.es261.js

@@ -0,0 +1,71 @@
+import { isArray as x, forEach as y, filter as E, find as b, isUndefined as v, isObject as B, groupBy as S, assign as j } from "min-dash";
+function P(r) {
+  return E(r, function(n) {
+    return !b(r, function(t) {
+      return t !== n && s(n, t);
+    });
+  });
+}
+function s(r, n) {
+  if (n) {
+    if (r === n)
+      return n;
+    if (r.parent)
+      return s(r.parent, n);
+  }
+}
+function w(r, n, t) {
+  t = t || 0, x(r) || (r = [r]), y(r, function(f, d) {
+    var o = n(f, d, t);
+    x(o) && o.length && w(o, n, t + 1);
+  });
+}
+function X(r, n, t) {
+  v(n) && (n = !0), B(n) && (t = n, n = !0), t = t || {};
+  var f = h(t.allShapes), d = h(t.allConnections), o = h(t.enclosedElements), u = h(t.enclosedConnections), a = h(
+    t.topLevel,
+    n && S(r, function(i) {
+      return i.id;
+    })
+  );
+  function c(i) {
+    a[i.source.id] && a[i.target.id] && (a[i.id] = [i]), f[i.source.id] && f[i.target.id] && (u[i.id] = o[i.id] = i), d[i.id] = i;
+  }
+  function g(i) {
+    if (o[i.id] = i, i.waypoints)
+      u[i.id] = d[i.id] = i;
+    else
+      return f[i.id] = i, y(i.incoming, c), y(i.outgoing, c), i.children;
+  }
+  return w(r, g), {
+    allShapes: f,
+    allConnections: d,
+    topLevel: a,
+    enclosedConnections: u,
+    enclosedElements: o
+  };
+}
+function p(r, n) {
+  n = !!n, x(r) || (r = [r]);
+  var t, f, d, o;
+  return y(r, function(u) {
+    var a = u;
+    u.waypoints && !n && (a = p(u.waypoints, !0));
+    var c = a.x, g = a.y, i = a.height || 0, C = a.width || 0;
+    (c < t || t === void 0) && (t = c), (g < f || f === void 0) && (f = g), (c + C > d || d === void 0) && (d = c + C), (g + i > o || o === void 0) && (o = g + i);
+  }), {
+    x: t,
+    y: f,
+    height: o - f,
+    width: d - t
+  };
+}
+function h(r, n) {
+  return j({}, r || {}, n || {});
+}
+export {
+  w as eachElement,
+  p as getBBox,
+  X as getClosure,
+  P as getParents
+};

package/dist/simcode-ui.es262.js

@@ -0,0 +1,11 @@
+import { isObject as t, has as i } from "min-dash";
+function r(n) {
+  return t(n) && i(n, "waypoints");
+}
+function e(n) {
+  return t(n) && i(n, "labelTarget");
+}
+export {
+  r as isConnection,
+  e as isLabel
+};

package/dist/simcode-ui.es263.js

@@ -0,0 +1,6 @@
+function t(e) {
+  return e.childNodes[0];
+}
+export {
+  t as getVisual
+};

package/dist/simcode-ui.es264.js

@@ -0,0 +1,141 @@
+import { uniqueBy as s, isArray as h } from "min-dash";
+function r(t, e) {
+  this._handlerMap = {}, this._stack = [], this._stackIdx = -1, this._currentExecution = {
+    actions: [],
+    dirty: [],
+    trigger: null
+  }, this._injector = e, this._eventBus = t, this._uid = 1, t.on([
+    "diagram.destroy",
+    "diagram.clear"
+  ], function() {
+    this.clear(!1);
+  }, this);
+}
+r.$inject = ["eventBus", "injector"];
+r.prototype.execute = function(t, e) {
+  if (!t)
+    throw new Error("command required");
+  this._currentExecution.trigger = "execute";
+  const i = { command: t, context: e };
+  this._pushAction(i), this._internalExecute(i), this._popAction();
+};
+r.prototype.canExecute = function(t, e) {
+  const i = { command: t, context: e }, n = this._getHandler(t);
+  let o = this._fire(t, "canExecute", i);
+  if (o === void 0) {
+    if (!n)
+      return !1;
+    n.canExecute && (o = n.canExecute(e));
+  }
+  return o;
+};
+r.prototype.clear = function(t) {
+  this._stack.length = 0, this._stackIdx = -1, t !== !1 && this._fire("changed", { trigger: "clear" });
+};
+r.prototype.undo = function() {
+  let t = this._getUndoAction(), e;
+  if (t) {
+    for (this._currentExecution.trigger = "undo", this._pushAction(t); t && (this._internalUndo(t), e = this._getUndoAction(), !(!e || e.id !== t.id)); )
+      t = e;
+    this._popAction();
+  }
+};
+r.prototype.redo = function() {
+  let t = this._getRedoAction(), e;
+  if (t) {
+    for (this._currentExecution.trigger = "redo", this._pushAction(t); t && (this._internalExecute(t, !0), e = this._getRedoAction(), !(!e || e.id !== t.id)); )
+      t = e;
+    this._popAction();
+  }
+};
+r.prototype.register = function(t, e) {
+  this._setHandler(t, e);
+};
+r.prototype.registerHandler = function(t, e) {
+  if (!t || !e)
+    throw new Error("command and handlerCls must be defined");
+  const i = this._injector.instantiate(e);
+  this.register(t, i);
+};
+r.prototype.canUndo = function() {
+  return !!this._getUndoAction();
+};
+r.prototype.canRedo = function() {
+  return !!this._getRedoAction();
+};
+r.prototype._getRedoAction = function() {
+  return this._stack[this._stackIdx + 1];
+};
+r.prototype._getUndoAction = function() {
+  return this._stack[this._stackIdx];
+};
+r.prototype._internalUndo = function(t) {
+  const e = t.command, i = t.context, n = this._getHandler(e);
+  this._atomicDo(() => {
+    this._fire(e, "revert", t), n.revert && this._markDirty(n.revert(i)), this._revertedAction(t), this._fire(e, "reverted", t);
+  });
+};
+r.prototype._fire = function(t, e, i) {
+  arguments.length < 3 && (i = e, e = null);
+  const n = e ? [t + "." + e, e] : [t];
+  let o;
+  i = this._eventBus.createEvent(i);
+  for (const c of n)
+    if (o = this._eventBus.fire("commandStack." + c, i), i.cancelBubble)
+      break;
+  return o;
+};
+r.prototype._createId = function() {
+  return this._uid++;
+};
+r.prototype._atomicDo = function(t) {
+  const e = this._currentExecution;
+  e.atomic = !0;
+  try {
+    t();
+  } finally {
+    e.atomic = !1;
+  }
+};
+r.prototype._internalExecute = function(t, e) {
+  const i = t.command, n = t.context, o = this._getHandler(i);
+  if (!o)
+    throw new Error("no command handler registered for <" + i + ">");
+  this._pushAction(t), e || (this._fire(i, "preExecute", t), o.preExecute && o.preExecute(n), this._fire(i, "preExecuted", t)), this._atomicDo(() => {
+    this._fire(i, "execute", t), o.execute && this._markDirty(o.execute(n)), this._executedAction(t, e), this._fire(i, "executed", t);
+  }), e || (this._fire(i, "postExecute", t), o.postExecute && o.postExecute(n), this._fire(i, "postExecuted", t)), this._popAction();
+};
+r.prototype._pushAction = function(t) {
+  const e = this._currentExecution, i = e.actions, n = i[0];
+  if (e.atomic)
+    throw new Error("illegal invocation in <execute> or <revert> phase (action: " + t.command + ")");
+  t.id || (t.id = n && n.id || this._createId()), i.push(t);
+};
+r.prototype._popAction = function() {
+  const t = this._currentExecution, e = t.trigger, i = t.actions, n = t.dirty;
+  i.pop(), i.length || (this._eventBus.fire("elements.changed", { elements: s("id", n.reverse()) }), n.length = 0, this._fire("changed", { trigger: e }), t.trigger = null);
+};
+r.prototype._markDirty = function(t) {
+  const e = this._currentExecution;
+  t && (t = h(t) ? t : [t], e.dirty = e.dirty.concat(t));
+};
+r.prototype._executedAction = function(t, e) {
+  const i = ++this._stackIdx;
+  e || this._stack.splice(i, this._stack.length, t);
+};
+r.prototype._revertedAction = function(t) {
+  this._stackIdx--;
+};
+r.prototype._getHandler = function(t) {
+  return this._handlerMap[t];
+};
+r.prototype._setHandler = function(t, e) {
+  if (!t || !e)
+    throw new Error("command and handler required");
+  if (this._handlerMap[t])
+    throw new Error("overriding handler for command <" + t + ">");
+  this._handlerMap[t] = e;
+};
+export {
+  r as default
+};

package/dist/simcode-ui.es265.js

@@ -0,0 +1,58 @@
+import { forEach as s, filter as m } from "min-dash";
+import x from "./simcode-ui.es283.js";
+import { indexOf as b, add as g } from "./simcode-ui.es284.js";
+import { saveClear as T } from "./simcode-ui.es285.js";
+import h from "./simcode-ui.es270.js";
+var I = 250, f = 1400;
+function u(i, r, v) {
+  h.call(this, r);
+  var c = i.get("movePreview", !1);
+  r.on("shape.move.start", f, function(n) {
+    var e = n.context, a = e.shapes, t = e.validatedShapes;
+    e.shapes = d(a), e.validatedShapes = d(t);
+  }), c && r.on("shape.move.start", I, function(n) {
+    var e = n.context, a = e.shapes, t = [];
+    s(a, function(o) {
+      s(o.labels, function(l) {
+        !l.hidden && e.shapes.indexOf(l) === -1 && t.push(l), o.labelTarget && t.push(o);
+      });
+    }), s(t, function(o) {
+      c.makeDraggable(e, o, !0);
+    });
+  }), this.preExecuted("elements.move", f, function(n) {
+    var e = n.context, a = e.closure, t = a.enclosedElements, o = [];
+    s(t, function(l) {
+      s(l.labels, function(p) {
+        t[p.id] || o.push(p);
+      });
+    }), a.addAll(o);
+  }), this.preExecute([
+    "connection.delete",
+    "shape.delete"
+  ], function(n) {
+    var e = n.context, a = e.connection || e.shape;
+    T(a.labels, function(t) {
+      v.removeShape(t, { nested: !0 });
+    });
+  }), this.execute("shape.delete", function(n) {
+    var e = n.context, a = e.shape, t = a.labelTarget;
+    t && (e.labelTargetIndex = b(t.labels, a), e.labelTarget = t, a.labelTarget = null);
+  }), this.revert("shape.delete", function(n) {
+    var e = n.context, a = e.shape, t = e.labelTarget, o = e.labelTargetIndex;
+    t && (g(t.labels, a, o), a.labelTarget = t);
+  });
+}
+x(u, h);
+u.$inject = [
+  "injector",
+  "eventBus",
+  "modeling"
+];
+function d(i) {
+  return m(i, function(r) {
+    return i.indexOf(r.labelTarget) === -1;
+  });
+}
+export {
+  u as default
+};

package/dist/simcode-ui.es266.js

@@ -0,0 +1,23 @@
+import { create as r } from "./simcode-ui.es286.js";
+import { assign as n } from "min-dash";
+function o() {
+  this._uid = 12;
+}
+o.prototype.createRoot = function(e) {
+  return this.create("root", e);
+};
+o.prototype.createLabel = function(e) {
+  return this.create("label", e);
+};
+o.prototype.createShape = function(e) {
+  return this.create("shape", e);
+};
+o.prototype.createConnection = function(e) {
+  return this.create("connection", e);
+};
+o.prototype.create = function(e, t) {
+  return t = n({}, t || {}), t.id || (t.id = e + "_" + this._uid++), r(e, t);
+};
+export {
+  o as default
+};

package/dist/simcode-ui.es267.js

@@ -0,0 +1,7 @@
+const t = {
+  width: 90,
+  height: 20
+};
+export {
+  t as DEFAULT_LABEL_SIZE
+};

package/dist/simcode-ui.es268.js

@@ -0,0 +1,276 @@
+import { forEach as l, isArray as u, assign as s } from "min-dash";
+import d from "./simcode-ui.es287.js";
+import h from "./simcode-ui.es288.js";
+import f from "./simcode-ui.es289.js";
+import y from "./simcode-ui.es290.js";
+import S from "./simcode-ui.es291.js";
+import v from "./simcode-ui.es292.js";
+import x from "./simcode-ui.es293.js";
+import _ from "./simcode-ui.es294.js";
+import g from "./simcode-ui.es295.js";
+import H from "./simcode-ui.es296.js";
+import k from "./simcode-ui.es297.js";
+import C from "./simcode-ui.es298.js";
+import E from "./simcode-ui.es299.js";
+import b from "./simcode-ui.es300.js";
+import w from "./simcode-ui.es301.js";
+import A from "./simcode-ui.es302.js";
+import z from "./simcode-ui.es303.js";
+import D from "./simcode-ui.es304.js";
+import M from "./simcode-ui.es305.js";
+import T from "./simcode-ui.es306.js";
+import W from "./simcode-ui.es307.js";
+import { isModelElement as j } from "./simcode-ui.es286.js";
+function a(e, n, t) {
+  this._eventBus = e, this._elementFactory = n, this._commandStack = t;
+  var o = this;
+  e.on("diagram.init", function() {
+    o.registerHandlers(t);
+  });
+}
+a.$inject = ["eventBus", "elementFactory", "commandStack"];
+a.prototype.getHandlers = function() {
+  return {
+    "shape.append": h,
+    "shape.create": v,
+    "shape.delete": g,
+    "shape.move": b,
+    "shape.resize": z,
+    "shape.replace": A,
+    "shape.toggleCollapse": M,
+    spaceTool: D,
+    "label.create": S,
+    "connection.create": f,
+    "connection.delete": x,
+    "connection.move": C,
+    "connection.layout": k,
+    "connection.updateWaypoints": W,
+    "connection.reconnect": w,
+    "elements.create": y,
+    "elements.move": E,
+    "elements.delete": _,
+    "elements.distribute": H,
+    "elements.align": d,
+    "element.updateAttachment": T
+  };
+};
+a.prototype.registerHandlers = function(e) {
+  l(this.getHandlers(), function(n, t) {
+    e.registerHandler(t, n);
+  });
+};
+a.prototype.moveShape = function(e, n, t, o, c) {
+  typeof o == "object" && (c = o, o = null);
+  var r = {
+    shape: e,
+    delta: n,
+    newParent: t,
+    newParentIndex: o,
+    hints: c || {}
+  };
+  this._commandStack.execute("shape.move", r);
+};
+a.prototype.updateAttachment = function(e, n) {
+  var t = {
+    shape: e,
+    newHost: n
+  };
+  this._commandStack.execute("element.updateAttachment", t);
+};
+a.prototype.moveElements = function(e, n, t, o) {
+  o = o || {};
+  var c = o.attach, r = t, i;
+  c === !0 ? (i = t, r = t.parent) : c === !1 && (i = null);
+  var p = {
+    shapes: e,
+    delta: n,
+    newParent: r,
+    newHost: i,
+    hints: o
+  };
+  this._commandStack.execute("elements.move", p);
+};
+a.prototype.moveConnection = function(e, n, t, o, c) {
+  typeof o == "object" && (c = o, o = void 0);
+  var r = {
+    connection: e,
+    delta: n,
+    newParent: t,
+    newParentIndex: o,
+    hints: c || {}
+  };
+  this._commandStack.execute("connection.move", r);
+};
+a.prototype.layoutConnection = function(e, n) {
+  var t = {
+    connection: e,
+    hints: n || {}
+  };
+  this._commandStack.execute("connection.layout", t);
+};
+a.prototype.createConnection = function(e, n, t, o, c, r) {
+  typeof t == "object" && (r = c, c = o, o = t, t = void 0), o = this._create("connection", o);
+  var i = {
+    source: e,
+    target: n,
+    parent: c,
+    parentIndex: t,
+    connection: o,
+    hints: r
+  };
+  return this._commandStack.execute("connection.create", i), i.connection;
+};
+a.prototype.createShape = function(e, n, t, o, c) {
+  typeof o != "number" && (c = o, o = void 0), c = c || {};
+  var r = c.attach, i, p;
+  e = this._create("shape", e), r ? (i = t.parent, p = t) : i = t;
+  var m = {
+    position: n,
+    shape: e,
+    parent: i,
+    parentIndex: o,
+    host: p,
+    hints: c
+  };
+  return this._commandStack.execute("shape.create", m), m.shape;
+};
+a.prototype.createElements = function(e, n, t, o, c) {
+  u(e) || (e = [e]), typeof o != "number" && (c = o, o = void 0), c = c || {};
+  var r = {
+    position: n,
+    elements: e,
+    parent: t,
+    parentIndex: o,
+    hints: c
+  };
+  return this._commandStack.execute("elements.create", r), r.elements;
+};
+a.prototype.createLabel = function(e, n, t, o) {
+  t = this._create("label", t);
+  var c = {
+    labelTarget: e,
+    position: n,
+    parent: o || e.parent,
+    shape: t
+  };
+  return this._commandStack.execute("label.create", c), c.shape;
+};
+a.prototype.appendShape = function(e, n, t, o, c) {
+  c = c || {}, n = this._create("shape", n);
+  var r = {
+    source: e,
+    position: t,
+    target: o,
+    shape: n,
+    connection: c.connection,
+    connectionParent: c.connectionParent,
+    hints: c
+  };
+  return this._commandStack.execute("shape.append", r), r.shape;
+};
+a.prototype.removeElements = function(e) {
+  var n = {
+    elements: e
+  };
+  this._commandStack.execute("elements.delete", n);
+};
+a.prototype.distributeElements = function(e, n, t) {
+  var o = {
+    groups: e,
+    axis: n,
+    dimension: t
+  };
+  this._commandStack.execute("elements.distribute", o);
+};
+a.prototype.removeShape = function(e, n) {
+  var t = {
+    shape: e,
+    hints: n || {}
+  };
+  this._commandStack.execute("shape.delete", t);
+};
+a.prototype.removeConnection = function(e, n) {
+  var t = {
+    connection: e,
+    hints: n || {}
+  };
+  this._commandStack.execute("connection.delete", t);
+};
+a.prototype.replaceShape = function(e, n, t) {
+  var o = {
+    oldShape: e,
+    newData: n,
+    hints: t || {}
+  };
+  return this._commandStack.execute("shape.replace", o), o.newShape;
+};
+a.prototype.alignElements = function(e, n) {
+  var t = {
+    elements: e,
+    alignment: n
+  };
+  this._commandStack.execute("elements.align", t);
+};
+a.prototype.resizeShape = function(e, n, t, o) {
+  var c = {
+    shape: e,
+    newBounds: n,
+    minBounds: t,
+    hints: o
+  };
+  this._commandStack.execute("shape.resize", c);
+};
+a.prototype.createSpace = function(e, n, t, o, c) {
+  var r = {
+    delta: t,
+    direction: o,
+    movingShapes: e,
+    resizingShapes: n,
+    start: c
+  };
+  this._commandStack.execute("spaceTool", r);
+};
+a.prototype.updateWaypoints = function(e, n, t) {
+  var o = {
+    connection: e,
+    newWaypoints: n,
+    hints: t || {}
+  };
+  this._commandStack.execute("connection.updateWaypoints", o);
+};
+a.prototype.reconnect = function(e, n, t, o, c) {
+  var r = {
+    connection: e,
+    newSource: n,
+    newTarget: t,
+    dockingOrPoints: o,
+    hints: c || {}
+  };
+  this._commandStack.execute("connection.reconnect", r);
+};
+a.prototype.reconnectStart = function(e, n, t, o) {
+  o || (o = {}), this.reconnect(e, n, e.target, t, s(o, {
+    docking: "source"
+  }));
+};
+a.prototype.reconnectEnd = function(e, n, t, o) {
+  o || (o = {}), this.reconnect(e, e.source, n, t, s(o, {
+    docking: "target"
+  }));
+};
+a.prototype.connect = function(e, n, t, o) {
+  return this.createConnection(e, n, t || {}, e.parent, o);
+};
+a.prototype._create = function(e, n) {
+  return j(n) ? n : this._elementFactory.create(e, n);
+};
+a.prototype.toggleCollapse = function(e, n) {
+  var t = {
+    shape: e,
+    hints: n || {}
+  };
+  this._commandStack.execute("shape.toggleCollapse", t);
+};
+export {
+  a as default
+};

package/dist/simcode-ui.es269.js

@@ -0,0 +1,50 @@
+import { isLabel as i, isLabelExternal as x, hasExternalLabel as E, getExternalLabelMid as g, getLabel as u, setLabel as m } from "./simcode-ui.es246.js";
+const T = {
+  width: 0,
+  height: 0
+};
+function w(a, c) {
+  function s(e, t) {
+    const r = e.label || e, n = e.labelTarget || e;
+    return m(r, t), [r, n];
+  }
+  function f(e) {
+    const { element: t, newLabel: r } = e, { businessObject: n } = t;
+    if (!i(t) && x(t) && !E(t) && !b(r)) {
+      let l = g(t);
+      l = {
+        x: l.x,
+        y: l.y + 7
+      }, a.createLabel(t, l, {
+        id: n.id + "_label",
+        businessObject: n
+      });
+    }
+  }
+  function d(e) {
+    return e.oldLabel = u(e.element), s(e.element, e.newLabel);
+  }
+  function L(e) {
+    return s(e.element, e.oldLabel);
+  }
+  function p(e) {
+    const { element: t, newLabel: r } = e, n = t.label || t, o = e.hints || {};
+    let { newBounds: l } = e;
+    if (!i(n))
+      return;
+    if (i(n) && b(r)) {
+      o.removeShape !== !1 && a.removeShape(n, { unsetLabel: !1 });
+      return;
+    }
+    const h = u(n);
+    typeof l > "u" && (l = c.getExternalLabelBounds(n, h)), l && a.resizeShape(n, l, T);
+  }
+  this.preExecute = f, this.execute = d, this.revert = L, this.postExecute = p;
+}
+w.$inject = ["modeling", "textRenderer"];
+function b(a) {
+  return !a || !a.trim();
+}
+export {
+  w as default
+};

package/dist/simcode-ui.es27.js

@@ -0,0 +1,6 @@
+import { withInstall as t } from "./simcode-ui.es66.js";
+import a from "./simcode-ui.es92.js";
+const r = t(a);
+export {
+  r as default
+};

package/dist/simcode-ui.es270.js

@@ -0,0 +1,40 @@
+import { isFunction as x, isNumber as E, isObject as l, isArray as d, forEach as v } from "min-dash";
+var y = 1e3;
+function c(u) {
+  this._eventBus = u;
+}
+c.$inject = ["eventBus"];
+function B(u, n) {
+  return function(e) {
+    return u.call(n || null, e.context, e.command, e);
+  };
+}
+c.prototype.on = function(u, n, e, o, t, f) {
+  if ((x(n) || E(n)) && (f = t, t = o, o = e, e = n, n = null), x(e) && (f = t, t = o, o = e, e = y), l(t) && (f = t, t = !1), !x(o))
+    throw new Error("handlerFn must be a function");
+  d(u) || (u = [u]);
+  var p = this._eventBus;
+  v(u, function(i) {
+    var s = ["commandStack", i, n].filter(function(m) {
+      return m;
+    }).join(".");
+    p.on(s, e, t ? B(o, f) : o, f);
+  });
+};
+c.prototype.canExecute = r("canExecute");
+c.prototype.preExecute = r("preExecute");
+c.prototype.preExecuted = r("preExecuted");
+c.prototype.execute = r("execute");
+c.prototype.executed = r("executed");
+c.prototype.postExecute = r("postExecute");
+c.prototype.postExecuted = r("postExecuted");
+c.prototype.revert = r("revert");
+c.prototype.reverted = r("reverted");
+function r(u) {
+  return function(e, o, t, f, p) {
+    (x(e) || E(e)) && (p = f, f = t, t = o, o = e, e = null), this.on(e, u, o, t, f, p);
+  };
+}
+export {
+  c as default
+};