@xiping/react-components 1.0.19 → 1.0.20

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js

@@ -0,0 +1,7 @@
+var o = Object.prototype, r = o.toString;
+function e(t) {
+  return r.call(t);
+}
+export {
+  e as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js

@@ -0,0 +1,5 @@
+import e from "./_freeGlobal.js";
+var t = typeof self == "object" && self && self.Object === Object && self, r = e || t || Function("return this")();
+export {
+  r as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_trimmedEndIndex.js

@@ -0,0 +1,9 @@
+var r = /\s/;
+function a(t) {
+  for (var e = t.length; e-- && r.test(t.charAt(e)); )
+    ;
+  return e;
+}
+export {
+  a as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/debounce.js

@@ -0,0 +1,54 @@
+import S from "./isObject.js";
+import h from "./now.js";
+import W from "./toNumber.js";
+var y = "Expected a function", R = Math.max, A = Math.min;
+function _(x, i, u) {
+  var a, d, c, f, n, r, l = 0, E = !1, m = !1, g = !0;
+  if (typeof x != "function")
+    throw new TypeError(y);
+  i = W(i) || 0, S(u) && (E = !!u.leading, m = "maxWait" in u, c = m ? R(W(u.maxWait) || 0, i) : c, g = "trailing" in u ? !!u.trailing : g);
+  function v(e) {
+    var t = a, o = d;
+    return a = d = void 0, l = e, f = x.apply(o, t), f;
+  }
+  function b(e) {
+    return l = e, n = setTimeout(s, i), E ? v(e) : f;
+  }
+  function C(e) {
+    var t = e - r, o = e - l, p = i - t;
+    return m ? A(p, c - o) : p;
+  }
+  function k(e) {
+    var t = e - r, o = e - l;
+    return r === void 0 || t >= i || t < 0 || m && o >= c;
+  }
+  function s() {
+    var e = h();
+    if (k(e))
+      return I(e);
+    n = setTimeout(s, C(e));
+  }
+  function I(e) {
+    return n = void 0, g && a ? v(e) : (a = d = void 0, f);
+  }
+  function L() {
+    n !== void 0 && clearTimeout(n), l = 0, a = r = d = n = void 0;
+  }
+  function M() {
+    return n === void 0 ? f : I(h());
+  }
+  function T() {
+    var e = h(), t = k(e);
+    if (a = arguments, d = this, r = e, t) {
+      if (n === void 0)
+        return b(r);
+      if (m)
+        return clearTimeout(n), n = setTimeout(s, i), v(r);
+    }
+    return n === void 0 && (n = setTimeout(s, i)), f;
+  }
+  return T.cancel = L, T.flush = M, T;
+}
+export {
+  _ as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js

@@ -0,0 +1,7 @@
+function n(t) {
+  var e = typeof t;
+  return t != null && (e == "object" || e == "function");
+}
+export {
+  n as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObjectLike.js

@@ -0,0 +1,6 @@
+function e(t) {
+  return t != null && typeof t == "object";
+}
+export {
+  e as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isSymbol.js

@@ -0,0 +1,9 @@
+import t from "./_baseGetTag.js";
+import m from "./isObjectLike.js";
+var r = "[object Symbol]";
+function i(o) {
+  return typeof o == "symbol" || m(o) && t(o) == r;
+}
+export {
+  i as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/now.js

@@ -0,0 +1,7 @@
+import o from "./_root.js";
+var t = function() {
+  return o.Date.now();
+};
+export {
+  t as default
+};

package/dist/es/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/toNumber.js

@@ -0,0 +1,22 @@
+import n from "./_baseTrim.js";
+import f from "./isObject.js";
+import o from "./isSymbol.js";
+var s = NaN, m = /^[-+]0x[0-9a-f]+$/i, p = /^0b[01]+$/i, e = /^0o[0-7]+$/i, b = parseInt;
+function O(r) {
+  if (typeof r == "number")
+    return r;
+  if (o(r))
+    return s;
+  if (f(r)) {
+    var t = typeof r.valueOf == "function" ? r.valueOf() : r;
+    r = f(t) ? t + "" : t;
+  }
+  if (typeof r != "string")
+    return r === 0 ? r : +r;
+  r = n(r);
+  var i = p.test(r);
+  return i || e.test(r) ? b(r.slice(2), i ? 2 : 8) : m.test(r) ? s : +r;
+}
+export {
+  O as default
+};

package/dist/es/node_modules/.pnpm/ngraph.events@1.2.2/node_modules/ngraph.events/index.js

@@ -0,0 +1,57 @@
+var v, u;
+function p() {
+  if (u) return v;
+  u = 1, v = function(r) {
+    c(r);
+    var e = l(r);
+    return r.on = e.on, r.off = e.off, r.fire = e.fire, r;
+  };
+  function l(n) {
+    var r = /* @__PURE__ */ Object.create(null);
+    return {
+      on: function(e, t, o) {
+        if (typeof t != "function")
+          throw new Error("callback is expected to be a function");
+        var f = r[e];
+        return f || (f = r[e] = []), f.push({ callback: t, ctx: o }), n;
+      },
+      off: function(e, t) {
+        var o = typeof e > "u";
+        if (o)
+          return r = /* @__PURE__ */ Object.create(null), n;
+        if (r[e]) {
+          var f = typeof t != "function";
+          if (f)
+            delete r[e];
+          else
+            for (var a = r[e], i = 0; i < a.length; ++i)
+              a[i].callback === t && a.splice(i, 1);
+        }
+        return n;
+      },
+      fire: function(e) {
+        var t = r[e];
+        if (!t)
+          return n;
+        var o;
+        arguments.length > 1 && (o = Array.prototype.splice.call(arguments, 1));
+        for (var f = 0; f < t.length; ++f) {
+          var a = t[f];
+          a.callback.apply(a.ctx, o);
+        }
+        return n;
+      }
+    };
+  }
+  function c(n) {
+    if (!n)
+      throw new Error("Eventify cannot use falsy object as events subject");
+    for (var r = ["on", "fire", "off"], e = 0; e < r.length; ++e)
+      if (n.hasOwnProperty(r[e]))
+        throw new Error("Subject cannot be eventified, since it already has property '" + r[e] + "'");
+  }
+  return v;
+}
+export {
+  p as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.forcelayout@3.3.1/node_modules/ngraph.forcelayout/index.js

@@ -0,0 +1,239 @@
+import { __module as g } from "../../../../../_virtual/index6.js";
+import { __require as M } from "./lib/createPhysicsSimulator.js";
+import { __require as O } from "../../../ngraph.events@1.2.2/node_modules/ngraph.events/index.js";
+var w;
+function K() {
+  if (w) return g.exports;
+  w = 1, g.exports = x, g.exports.simulator = M();
+  var _ = O();
+  function x(o, f) {
+    if (!o)
+      throw new Error("Graph structure cannot be undefined");
+    var L = f && f.createSimulator || M(), a = L(f);
+    if (Array.isArray(f)) throw new Error("Physics settings is expected to be an object");
+    var m = o.version > 19 ? I : V;
+    f && typeof f.nodeMass == "function" && (m = f.nodeMass);
+    var n = /* @__PURE__ */ new Map(), u = {}, d = 0, q = a.settings.springTransform || E;
+    G(), C();
+    var N = !1, s = {
+      /**
+       * Performs one step of iterative layout algorithm
+       *
+       * @returns {boolean} true if the system should be considered stable; False otherwise.
+       * The system is stable if no further call to `step()` can improve the layout.
+       */
+      step: function() {
+        if (d === 0)
+          return b(!0), !0;
+        var e = a.step();
+        s.lastMove = e, s.fire("step");
+        var r = e / d, t = r <= 0.01;
+        return b(t), t;
+      },
+      /**
+       * For a given `nodeId` returns position
+       */
+      getNodePosition: function(e) {
+        return l(e).pos;
+      },
+      /**
+       * Sets position of a node to a given coordinates
+       * @param {string} nodeId node identifier
+       * @param {number} x position of a node
+       * @param {number} y position of a node
+       * @param {number=} z position of node (only if applicable to body)
+       */
+      setNodePosition: function(e) {
+        var r = l(e);
+        r.setPosition.apply(r, Array.prototype.slice.call(arguments, 1));
+      },
+      /**
+       * @returns {Object} Link position by link id
+       * @returns {Object.from} {x, y} coordinates of link start
+       * @returns {Object.to} {x, y} coordinates of link end
+       */
+      getLinkPosition: function(e) {
+        var r = u[e];
+        if (r)
+          return {
+            from: r.from.pos,
+            to: r.to.pos
+          };
+      },
+      /**
+       * @returns {Object} area required to fit in the graph. Object contains
+       * `x1`, `y1` - top left coordinates
+       * `x2`, `y2` - bottom right coordinates
+       */
+      getGraphRect: function() {
+        return a.getBBox();
+      },
+      /**
+       * Iterates over each body in the layout simulator and performs a callback(body, nodeId)
+       */
+      forEachBody: B,
+      /*
+       * Requests layout algorithm to pin/unpin node to its current position
+       * Pinned nodes should not be affected by layout algorithm and always
+       * remain at their position
+       */
+      pinNode: function(e, r) {
+        var t = l(e.id);
+        t.isPinned = !!r;
+      },
+      /**
+       * Checks whether given graph's node is currently pinned
+       */
+      isNodePinned: function(e) {
+        return l(e.id).isPinned;
+      },
+      /**
+       * Request to release all resources
+       */
+      dispose: function() {
+        o.off("changed", P), s.fire("disposed");
+      },
+      /**
+       * Gets physical body for a given node id. If node is not found undefined
+       * value is returned.
+       */
+      getBody: A,
+      /**
+       * Gets spring for a given edge.
+       *
+       * @param {string} linkId link identifer. If two arguments are passed then
+       * this argument is treated as formNodeId
+       * @param {string=} toId when defined this parameter denotes head of the link
+       * and first argument is treated as tail of the link (fromId)
+       */
+      getSpring: S,
+      /**
+       * Returns length of cumulative force vector. The closer this to zero - the more stable the system is
+       */
+      getForceVectorLength: k,
+      /**
+       * [Read only] Gets current physics simulator
+       */
+      simulator: a,
+      /**
+       * Gets the graph that was used for layout
+       */
+      graph: o,
+      /**
+       * Gets amount of movement performed during last step operation
+       */
+      lastMove: 0
+    };
+    return _(s), s;
+    function b(e) {
+      N !== e && (N = e, T(e));
+    }
+    function B(e) {
+      n.forEach(e);
+    }
+    function k() {
+      var e = 0, r = 0;
+      return B(function(t) {
+        e += Math.abs(t.force.x), r += Math.abs(t.force.y);
+      }), Math.sqrt(e * e + r * r);
+    }
+    function S(e, r) {
+      var t;
+      if (r === void 0)
+        typeof e != "object" ? t = e : t = e.id;
+      else {
+        var i = o.hasLink(e, r);
+        if (!i) return;
+        t = i.id;
+      }
+      return u[t];
+    }
+    function A(e) {
+      return n.get(e);
+    }
+    function C() {
+      o.on("changed", P);
+    }
+    function T(e) {
+      s.fire("stable", e);
+    }
+    function P(e) {
+      for (var r = 0; r < e.length; ++r) {
+        var t = e[r];
+        t.changeType === "add" ? (t.node && p(t.node.id), t.link && h(t.link)) : t.changeType === "remove" && (t.node && j(t.node), t.link && z(t.link));
+      }
+      d = o.getNodesCount();
+    }
+    function G() {
+      d = 0, o.forEachNode(function(e) {
+        p(e.id), d += 1;
+      }), o.forEachLink(h);
+    }
+    function p(e) {
+      var r = n.get(e);
+      if (!r) {
+        var t = o.getNode(e);
+        if (!t)
+          throw new Error("initBody() was called with unknown node id");
+        var i = t.position;
+        if (!i) {
+          var v = F(t);
+          i = a.getBestNewBodyPosition(v);
+        }
+        r = a.addBodyAt(i), r.id = e, n.set(e, r), c(e), R(t) && (r.isPinned = !0);
+      }
+    }
+    function j(e) {
+      var r = e.id, t = n.get(r);
+      t && (n.delete(r), a.removeBody(t));
+    }
+    function h(e) {
+      c(e.fromId), c(e.toId);
+      var r = n.get(e.fromId), t = n.get(e.toId), i = a.addSpring(r, t, e.length);
+      q(e, i), u[e.id] = i;
+    }
+    function z(e) {
+      var r = u[e.id];
+      if (r) {
+        var t = o.getNode(e.fromId), i = o.getNode(e.toId);
+        t && c(t.id), i && c(i.id), delete u[e.id], a.removeSpring(r);
+      }
+    }
+    function F(e) {
+      var r = [];
+      if (!e.links)
+        return r;
+      for (var t = Math.min(e.links.length, 2), i = 0; i < t; ++i) {
+        var v = e.links[i], y = v.fromId !== e.id ? n.get(v.fromId) : n.get(v.toId);
+        y && y.pos && r.push(y);
+      }
+      return r;
+    }
+    function c(e) {
+      var r = n.get(e);
+      if (r.mass = m(e), Number.isNaN(r.mass))
+        throw new Error("Node mass should be a number");
+    }
+    function R(e) {
+      return e && (e.isPinned || e.data && e.data.isPinned);
+    }
+    function l(e) {
+      var r = n.get(e);
+      return r || (p(e), r = n.get(e)), r;
+    }
+    function V(e) {
+      var r = o.getLinks(e);
+      return r ? 1 + r.length / 3 : 1;
+    }
+    function I(e) {
+      var r = o.getLinks(e);
+      return r ? 1 + r.size / 3 : 1;
+    }
+  }
+  function E() {
+  }
+  return g.exports;
+}
+export {
+  K as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.forcelayout@3.3.1/node_modules/ngraph.forcelayout/lib/codeGenerators/createPatternBuilder.js

@@ -0,0 +1,22 @@
+import { __require as q } from "./getVariableName.js";
+var t, a;
+function v() {
+  if (a) return t;
+  a = 1;
+  const i = q();
+  return t = function(u) {
+    return l;
+    function l(d, e) {
+      let o = e && e.indent || 0, f = e && e.join !== void 0 ? e.join : `
+`, p = Array(o + 1).join(" "), n = [];
+      for (let r = 0; r < u; ++r) {
+        let j = i(r), m = r === 0 ? "" : p;
+        n.push(m + d.replace(/{var}/g, j));
+      }
+      return n.join(f);
+    }
+  }, t;
+}
+export {
+  v as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.forcelayout@3.3.1/node_modules/ngraph.forcelayout/lib/codeGenerators/generateBounds.js

@@ -0,0 +1,74 @@
+import { __module as e } from "../../../../../../../_virtual/generateBounds.js";
+import { __require as d } from "./createPatternBuilder.js";
+var i;
+function v() {
+  if (i) return e.exports;
+  i = 1, e.exports = a, e.exports.generateFunctionBody = o;
+  const t = d();
+  function a(r) {
+    let n = o(r);
+    return new Function("bodies", "settings", "random", n);
+  }
+  function o(r) {
+    let n = t(r);
+    return `
+  var boundingBox = {
+    ${n("min_{var}: 0, max_{var}: 0,", { indent: 4 })}
+  };
+
+  return {
+    box: boundingBox,
+
+    update: updateBoundingBox,
+
+    reset: resetBoundingBox,
+
+    getBestNewPosition: function (neighbors) {
+      var ${n("base_{var} = 0", { join: ", " })};
+
+      if (neighbors.length) {
+        for (var i = 0; i < neighbors.length; ++i) {
+          let neighborPos = neighbors[i].pos;
+          ${n("base_{var} += neighborPos.{var};", { indent: 10 })}
+        }
+
+        ${n("base_{var} /= neighbors.length;", { indent: 8 })}
+      } else {
+        ${n("base_{var} = (boundingBox.min_{var} + boundingBox.max_{var}) / 2;", { indent: 8 })}
+      }
+
+      var springLength = settings.springLength;
+      return {
+        ${n("{var}: base_{var} + (random.nextDouble() - 0.5) * springLength,", { indent: 8 })}
+      };
+    }
+  };
+
+  function updateBoundingBox() {
+    var i = bodies.length;
+    if (i === 0) return; // No bodies - no borders.
+
+    ${n("var max_{var} = -Infinity;", { indent: 4 })}
+    ${n("var min_{var} = Infinity;", { indent: 4 })}
+
+    while(i--) {
+      // this is O(n), it could be done faster with quadtree, if we check the root node bounds
+      var bodyPos = bodies[i].pos;
+      ${n("if (bodyPos.{var} < min_{var}) min_{var} = bodyPos.{var};", { indent: 6 })}
+      ${n("if (bodyPos.{var} > max_{var}) max_{var} = bodyPos.{var};", { indent: 6 })}
+    }
+
+    ${n("boundingBox.min_{var} = min_{var};", { indent: 4 })}
+    ${n("boundingBox.max_{var} = max_{var};", { indent: 4 })}
+  }
+
+  function resetBoundingBox() {
+    ${n("boundingBox.min_{var} = boundingBox.max_{var} = 0;", { indent: 4 })}
+  }
+`;
+  }
+  return e.exports;
+}
+export {
+  v as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.forcelayout@3.3.1/node_modules/ngraph.forcelayout/lib/codeGenerators/generateCreateBody.js

@@ -0,0 +1,74 @@
+import { __module as n } from "../../../../../../../_virtual/generateCreateBody.js";
+import { __require as v } from "./createPatternBuilder.js";
+var c;
+function h() {
+  if (c) return n.exports;
+  c = 1;
+  const i = v();
+  n.exports = d, n.exports.generateCreateBodyFunctionBody = a, n.exports.getVectorCode = u, n.exports.getBodyCode = s;
+  function d(t, r) {
+    let e = a(t, r), { Body: o } = new Function(e)();
+    return o;
+  }
+  function a(t, r) {
+    return `
+${u(t, r)}
+${s(t)}
+return {Body: Body, Vector: Vector};
+`;
+  }
+  function s(t) {
+    let r = i(t), e = r("{var}", { join: ", " });
+    return `
+function Body(${e}) {
+  this.isPinned = false;
+  this.pos = new Vector(${e});
+  this.force = new Vector();
+  this.velocity = new Vector();
+  this.mass = 1;
+
+  this.springCount = 0;
+  this.springLength = 0;
+}
+
+Body.prototype.reset = function() {
+  this.force.reset();
+  this.springCount = 0;
+  this.springLength = 0;
+}
+
+Body.prototype.setPosition = function (${e}) {
+  ${r("this.pos.{var} = {var} || 0;", { indent: 2 })}
+};`;
+  }
+  function u(t, r) {
+    let e = i(t), o = "";
+    return r && (o = `${e(`
+	   var v{var};
+	Object.defineProperty(this, '{var}', {
+	  set: function(v) { 
+	    if (!Number.isFinite(v)) throw new Error('Cannot set non-numbers to {var}');
+	    v{var} = v; 
+	  },
+	  get: function() { return v{var}; }
+	});`)}`), `function Vector(${e("{var}", { join: ", " })}) {
+  ${o}
+    if (typeof arguments[0] === 'object') {
+      // could be another vector
+      let v = arguments[0];
+      ${e('if (!Number.isFinite(v.{var})) throw new Error("Expected value is not a finite number at Vector constructor ({var})");', { indent: 4 })}
+      ${e("this.{var} = v.{var};", { indent: 4 })}
+    } else {
+      ${e('this.{var} = typeof {var} === "number" ? {var} : 0;', { indent: 4 })}
+    }
+  }
+  
+  Vector.prototype.reset = function () {
+    ${e("this.{var} = ", { join: "" })}0;
+  };`;
+  }
+  return n.exports;
+}
+export {
+  h as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.forcelayout@3.3.1/node_modules/ngraph.forcelayout/lib/codeGenerators/generateCreateDragForce.js

@@ -0,0 +1,28 @@
+import { __module as e } from "../../../../../../../_virtual/generateCreateDragForce.js";
+import { __require as c } from "./createPatternBuilder.js";
+var n;
+function s() {
+  if (n) return e.exports;
+  n = 1;
+  const a = c();
+  e.exports = i, e.exports.generateCreateDragForceFunctionBody = t;
+  function i(r) {
+    let o = t(r);
+    return new Function("options", o);
+  }
+  function t(r) {
+    return `
+  if (!Number.isFinite(options.dragCoefficient)) throw new Error('dragCoefficient is not a finite number');
+
+  return {
+    update: function(body) {
+      ${a(r)("body.force.{var} -= options.dragCoefficient * body.velocity.{var};", { indent: 6 })}
+    }
+  };
+`;
+  }
+  return e.exports;
+}
+export {
+  s as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.forcelayout@3.3.1/node_modules/ngraph.forcelayout/lib/codeGenerators/generateCreateSpringForce.js

@@ -0,0 +1,53 @@
+import { __module as e } from "../../../../../../../_virtual/generateCreateSpringForce.js";
+import { __require as p } from "./createPatternBuilder.js";
+var i;
+function d() {
+  if (i) return e.exports;
+  i = 1;
+  const o = p();
+  e.exports = a, e.exports.generateCreateSpringForceFunctionBody = t;
+  function a(n) {
+    let r = t(n);
+    return new Function("options", "random", r);
+  }
+  function t(n) {
+    let r = o(n);
+    return `
+  if (!Number.isFinite(options.springCoefficient)) throw new Error('Spring coefficient is not a number');
+  if (!Number.isFinite(options.springLength)) throw new Error('Spring length is not a number');
+
+  return {
+    /**
+     * Updates forces acting on a spring
+     */
+    update: function (spring) {
+      var body1 = spring.from;
+      var body2 = spring.to;
+      var length = spring.length < 0 ? options.springLength : spring.length;
+      ${r("var d{var} = body2.pos.{var} - body1.pos.{var};", { indent: 6 })}
+      var r = Math.sqrt(${r("d{var} * d{var}", { join: " + " })});
+
+      if (r === 0) {
+        ${r("d{var} = (random.nextDouble() - 0.5) / 50;", { indent: 8 })}
+        r = Math.sqrt(${r("d{var} * d{var}", { join: " + " })});
+      }
+
+      var d = r - length;
+      var coefficient = ((spring.coefficient > 0) ? spring.coefficient : options.springCoefficient) * d / r;
+
+      ${r("body1.force.{var} += coefficient * d{var}", { indent: 6 })};
+      body1.springCount += 1;
+      body1.springLength += r;
+
+      ${r("body2.force.{var} -= coefficient * d{var}", { indent: 6 })};
+      body2.springCount += 1;
+      body2.springLength += r;
+    }
+  };
+`;
+  }
+  return e.exports;
+}
+export {
+  d as __require
+};