@xiping/react-components 1.0.19 → 1.0.20

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

@@ -0,0 +1,273 @@
+import { __require as X } from "./codeGenerators/generateCreateBody.js";
+import { __require as Y } from "./codeGenerators/generateQuadTree.js";
+import { __require as Z } from "./codeGenerators/generateBounds.js";
+import { __require as $ } from "./codeGenerators/generateCreateDragForce.js";
+import { __require as L } from "./codeGenerators/generateCreateSpringForce.js";
+import { __require as k } from "./codeGenerators/generateIntegrator.js";
+import { __require as rr } from "./spring.js";
+import { __require as er } from "../../../../ngraph.merge@1.0.0/node_modules/ngraph.merge/index.js";
+import { __require as nr } from "../../../../ngraph.events@1.2.2/node_modules/ngraph.events/index.js";
+import { __require as ir } from "../../../../ngraph.random@1.2.0/node_modules/ngraph.random/index.js";
+var l, C;
+function gr() {
+  if (C) return l;
+  C = 1, l = G;
+  var x = X(), y = Y(), b = Z(), T = $(), P = L(), E = k(), F = {};
+  function G(e) {
+    var o = rr(), a = er(), g = nr();
+    if (e) {
+      if (e.springCoeff !== void 0) throw new Error("springCoeff was renamed to springCoefficient");
+      if (e.dragCoeff !== void 0) throw new Error("dragCoeff was renamed to dragCoefficient");
+    }
+    e = a(e, {
+      /**
+       * Ideal length for links (springs in physical model).
+       */
+      springLength: 10,
+      /**
+       * Hook's law coefficient. 1 - solid spring.
+       */
+      springCoefficient: 0.8,
+      /**
+       * Coulomb's law coefficient. It's used to repel nodes thus should be negative
+       * if you make it positive nodes start attract each other :).
+       */
+      gravity: -12,
+      /**
+       * Theta coefficient from Barnes Hut simulation. Ranged between (0, 1).
+       * The closer it's to 1 the more nodes algorithm will have to go through.
+       * Setting it to one makes Barnes Hut simulation no different from
+       * brute-force forces calculation (each node is considered).
+       */
+      theta: 0.8,
+      /**
+       * Drag force coefficient. Used to slow down system, thus should be less than 1.
+       * The closer it is to 0 the less tight system will be.
+       */
+      dragCoefficient: 0.9,
+      // TODO: Need to rename this to something better. E.g. `dragCoefficient`
+      /**
+       * Default time step (dt) for forces integration
+       */
+      timeStep: 0.5,
+      /**
+       * Adaptive time step uses average spring length to compute actual time step:
+       * See: https://twitter.com/anvaka/status/1293067160755957760
+       */
+      adaptiveTimeStepWeight: 0,
+      /**
+       * This parameter defines number of dimensions of the space where simulation
+       * is performed. 
+       */
+      dimensions: 2,
+      /**
+       * In debug mode more checks are performed, this will help you catch errors
+       * quickly, however for production build it is recommended to turn off this flag
+       * to speed up computation.
+       */
+      debug: !1
+    });
+    var i = F[e.dimensions];
+    if (!i) {
+      var u = e.dimensions;
+      i = {
+        Body: x(u, e.debug),
+        createQuadTree: y(u),
+        createBounds: b(u),
+        createDragForce: T(u),
+        createSpringForce: P(u),
+        integrate: E(u)
+      }, F[u] = i;
+    }
+    var Q = i.Body, I = i.createQuadTree, M = i.createBounds, O = i.createDragForce, A = i.createSpringForce, W = i.integrate, R = (r) => new Q(r), v = ir().random(42), t = [], d = [], f = I(e, v), m = M(t, e, v), V = A(e, v), j = O(e), z = 0, c = [], p = /* @__PURE__ */ new Map(), q = 0;
+    s("nbody", K), s("spring", U);
+    var h = {
+      /**
+       * Array of bodies, registered with current simulator
+       *
+       * Note: To add new body, use addBody() method. This property is only
+       * exposed for testing/performance purposes.
+       */
+      bodies: t,
+      quadTree: f,
+      /**
+       * Array of springs, registered with current simulator
+       *
+       * Note: To add new spring, use addSpring() method. This property is only
+       * exposed for testing/performance purposes.
+       */
+      springs: d,
+      /**
+       * Returns settings with which current simulator was initialized
+       */
+      settings: e,
+      /**
+       * Adds a new force to simulation
+       */
+      addForce: s,
+      /**
+       * Removes a force from the simulation.
+       */
+      removeForce: H,
+      /**
+       * Returns a map of all registered forces.
+       */
+      getForces: J,
+      /**
+       * Performs one step of force simulation.
+       *
+       * @returns {boolean} true if system is considered stable; False otherwise.
+       */
+      step: function() {
+        for (var r = 0; r < c.length; ++r)
+          c[r](q);
+        var n = W(t, e.timeStep, e.adaptiveTimeStepWeight);
+        return q += 1, n;
+      },
+      /**
+       * Adds body to the system
+       *
+       * @param {ngraph.physics.primitives.Body} body physical body
+       *
+       * @returns {ngraph.physics.primitives.Body} added body
+       */
+      addBody: function(r) {
+        if (!r)
+          throw new Error("Body is required");
+        return t.push(r), r;
+      },
+      /**
+       * Adds body to the system at given position
+       *
+       * @param {Object} pos position of a body
+       *
+       * @returns {ngraph.physics.primitives.Body} added body
+       */
+      addBodyAt: function(r) {
+        if (!r)
+          throw new Error("Body position is required");
+        var n = R(r);
+        return t.push(n), n;
+      },
+      /**
+       * Removes body from the system
+       *
+       * @param {ngraph.physics.primitives.Body} body to remove
+       *
+       * @returns {Boolean} true if body found and removed. falsy otherwise;
+       */
+      removeBody: function(r) {
+        if (r) {
+          var n = t.indexOf(r);
+          if (!(n < 0))
+            return t.splice(n, 1), t.length === 0 && m.reset(), !0;
+        }
+      },
+      /**
+       * Adds a spring to this simulation.
+       *
+       * @returns {Object} - a handle for a spring. If you want to later remove
+       * spring pass it to removeSpring() method.
+       */
+      addSpring: function(r, n, B, _) {
+        if (!r || !n)
+          throw new Error("Cannot add null spring to force simulator");
+        typeof B != "number" && (B = -1);
+        var S = new o(r, n, B, _ >= 0 ? _ : -1);
+        return d.push(S), S;
+      },
+      /**
+       * Returns amount of movement performed on last step() call
+       */
+      getTotalMovement: function() {
+        return z;
+      },
+      /**
+       * Removes spring from the system
+       *
+       * @param {Object} spring to remove. Spring is an object returned by addSpring
+       *
+       * @returns {Boolean} true if spring found and removed. falsy otherwise;
+       */
+      removeSpring: function(r) {
+        if (r) {
+          var n = d.indexOf(r);
+          if (n > -1)
+            return d.splice(n, 1), !0;
+        }
+      },
+      getBestNewBodyPosition: function(r) {
+        return m.getBestNewPosition(r);
+      },
+      /**
+       * Returns bounding box which covers all bodies
+       */
+      getBBox: w,
+      getBoundingBox: w,
+      invalidateBBox: function() {
+        console.warn("invalidateBBox() is deprecated, bounds always recomputed on `getBBox()` call");
+      },
+      // TODO: Move the force specific stuff to force
+      gravity: function(r) {
+        return r !== void 0 ? (e.gravity = r, f.options({ gravity: r }), this) : e.gravity;
+      },
+      theta: function(r) {
+        return r !== void 0 ? (e.theta = r, f.options({ theta: r }), this) : e.theta;
+      },
+      /**
+       * Returns pseudo-random number generator instance.
+       */
+      random: v
+    };
+    return N(e, h), g(h), h;
+    function w() {
+      return m.update(), m.box;
+    }
+    function s(r, n) {
+      if (p.has(r)) throw new Error("Force " + r + " is already added");
+      p.set(r, n), c.push(n);
+    }
+    function H(r) {
+      var n = c.indexOf(p.get(r));
+      n < 0 || (c.splice(n, 1), p.delete(r));
+    }
+    function J() {
+      return p;
+    }
+    function K() {
+      if (t.length !== 0) {
+        f.insertBodies(t);
+        for (var r = t.length; r--; ) {
+          var n = t[r];
+          n.isPinned || (n.reset(), f.updateBodyForce(n), j.update(n));
+        }
+      }
+    }
+    function U() {
+      for (var r = d.length; r--; )
+        V.update(d[r]);
+    }
+  }
+  function N(e, o) {
+    for (var a in e)
+      D(e, o, a);
+  }
+  function D(e, o, a) {
+    if (e.hasOwnProperty(a) && typeof o[a] != "function") {
+      var g = Number.isFinite(e[a]);
+      g ? o[a] = function(i) {
+        if (i !== void 0) {
+          if (!Number.isFinite(i)) throw new Error("Value of " + a + " should be a valid number.");
+          return e[a] = i, o;
+        }
+        return e[a];
+      } : o[a] = function(i) {
+        return i !== void 0 ? (e[a] = i, o) : e[a];
+      };
+    }
+  }
+  return l;
+}
+export {
+  gr as __require
+};

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

@@ -0,0 +1,12 @@
+var r, i;
+function f() {
+  if (i) return r;
+  i = 1, r = e;
+  function e(n, t, s, u) {
+    this.from = n, this.to = t, this.length = s, this.coefficient = u;
+  }
+  return r;
+}
+export {
+  f as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.graph@20.0.1/node_modules/ngraph.graph/index.js

@@ -0,0 +1,319 @@
+import { __require as $ } from "../../../ngraph.events@1.2.2/node_modules/ngraph.events/index.js";
+var x, R;
+function ee() {
+  if (R) return x;
+  R = 1, x = F;
+  var b = $();
+  function F(t) {
+    if (t = t || {}, "uniqueLinkId" in t && (console.warn(
+      "ngraph.graph: Starting from version 0.14 `uniqueLinkId` is deprecated.\nUse `multigraph` option instead\n",
+      `
+`,
+      `Note: there is also change in default behavior: From now on each graph
+is considered to be not a multigraph by default (each edge is unique).`
+    ), t.multigraph = t.uniqueLinkId), t.multigraph === void 0 && (t.multigraph = !1), typeof Map != "function")
+      throw new Error("ngraph.graph requires `Map` to be defined. Please polyfill it before using ngraph");
+    var u = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map(), g = {}, m = 0, P = t.multigraph ? j : Y, l = [], w = N, L = N, v = N, c = N, h = {
+      /**
+       * Sometimes duck typing could be slow. Giving clients a hint about data structure
+       * via explicit version number here:
+       */
+      version: 20,
+      /**
+       * Adds node to the graph. If node with given id already exists in the graph
+       * its data is extended with whatever comes in 'data' argument.
+       *
+       * @param nodeId the node's identifier. A string or number is preferred.
+       * @param [data] additional data for the node being added. If node already
+       *   exists its data object is augmented with the new one.
+       *
+       * @return {node} The newly added node or node with given id if it already exists.
+       */
+      addNode: E,
+      /**
+       * Adds a link to the graph. The function always create a new
+       * link between two nodes. If one of the nodes does not exists
+       * a new node is created.
+       *
+       * @param fromId link start node id;
+       * @param toId link end node id;
+       * @param [data] additional data to be set on the new link;
+       *
+       * @return {link} The newly created link
+       */
+      addLink: V,
+      /**
+       * Removes link from the graph. If link does not exist does nothing.
+       *
+       * @param link - object returned by addLink() or getLinks() methods.
+       *
+       * @returns true if link was removed; false otherwise.
+       */
+      removeLink: B,
+      /**
+       * Removes node with given id from the graph. If node does not exist in the graph
+       * does nothing.
+       *
+       * @param nodeId node's identifier passed to addNode() function.
+       *
+       * @returns true if node was removed; false otherwise.
+       */
+      removeNode: M,
+      /**
+       * Gets node with given identifier. If node does not exist undefined value is returned.
+       *
+       * @param nodeId requested node identifier;
+       *
+       * @return {node} in with requested identifier or undefined if no such node exists.
+       */
+      getNode: d,
+      /**
+       * Gets number of nodes in this graph.
+       *
+       * @return number of nodes in the graph.
+       */
+      getNodeCount: _,
+      /**
+       * Gets total number of links in the graph.
+       */
+      getLinkCount: q,
+      /**
+       * Gets total number of links in the graph.
+       */
+      getEdgeCount: q,
+      /**
+       * Synonym for `getLinkCount()`
+       */
+      getLinksCount: q,
+      /**
+       * Synonym for `getNodeCount()`
+       */
+      getNodesCount: _,
+      /**
+       * Gets all links (inbound and outbound) from the node with given id.
+       * If node with given id is not found null is returned.
+       *
+       * @param nodeId requested node identifier.
+       *
+       * @return Set of links from and to requested node if such node exists;
+       *   otherwise null is returned.
+       */
+      getLinks: A,
+      /**
+       * Invokes callback on each node of the graph.
+       *
+       * @param {Function(node)} callback Function to be invoked. The function
+       *   is passed one argument: visited node.
+       */
+      forEachNode: S,
+      /**
+       * Invokes callback on every linked (adjacent) node to the given one.
+       *
+       * @param nodeId Identifier of the requested node.
+       * @param {Function(node, link)} callback Function to be called on all linked nodes.
+       *   The function is passed two parameters: adjacent node and link object itself.
+       * @param oriented if true graph treated as oriented.
+       */
+      forEachLinkedNode: J,
+      /**
+       * Enumerates all links in the graph
+       *
+       * @param {Function(link)} callback Function to be called on all links in the graph.
+       *   The function is passed one parameter: graph's link object.
+       *
+       * Link object contains at least the following fields:
+       *  fromId - node id where link starts;
+       *  toId - node id where link ends,
+       *  data - additional data passed to graph.addLink() method.
+       */
+      forEachLink: H,
+      /**
+       * Suspend all notifications about graph changes until
+       * endUpdate is called.
+       */
+      beginUpdate: v,
+      /**
+       * Resumes all notifications about graph changes and fires
+       * graph 'changed' event in case there are any pending changes.
+       */
+      endUpdate: c,
+      /**
+       * Removes all nodes and links from the graph.
+       */
+      clear: D,
+      /**
+       * Detects whether there is a link between two nodes.
+       * Operation complexity is O(n) where n - number of links of a node.
+       * NOTE: this function is synonym for getLink()
+       *
+       * @returns link if there is one. null otherwise.
+       */
+      hasLink: k,
+      /**
+       * Detects whether there is a node with given id
+       * 
+       * Operation complexity is O(1)
+       * NOTE: this function is synonym for getNode()
+       *
+       * @returns node if there is one; Falsy value otherwise.
+       */
+      hasNode: d,
+      /**
+       * Gets an edge between two nodes.
+       * Operation complexity is O(n) where n - number of links of a node.
+       *
+       * @param {string} fromId link start identifier
+       * @param {string} toId link end identifier
+       *
+       * @returns link if there is one; undefined otherwise.
+       */
+      getLink: k
+    };
+    return b(h), T(), h;
+    function T() {
+      var e = h.on;
+      h.on = n;
+      function n() {
+        return h.beginUpdate = v = W, h.endUpdate = c = X, w = z, L = G, h.on = e, e.apply(h, arguments);
+      }
+    }
+    function z(e, n) {
+      l.push({
+        link: e,
+        changeType: n
+      });
+    }
+    function G(e, n) {
+      l.push({
+        node: e,
+        changeType: n
+      });
+    }
+    function E(e, n) {
+      if (e === void 0)
+        throw new Error("Invalid node identifier");
+      v();
+      var r = d(e);
+      return r ? (r.data = n, L(r, "update")) : (r = new O(e, n), L(r, "add")), u.set(e, r), c(), r;
+    }
+    function d(e) {
+      return u.get(e);
+    }
+    function M(e) {
+      var n = d(e);
+      if (!n)
+        return !1;
+      v();
+      var r = n.links;
+      return r && (r.forEach(U), n.links = null), u.delete(e), L(n, "remove"), c(), !0;
+    }
+    function V(e, n, r) {
+      v();
+      var i = d(e) || E(e), o = d(n) || E(n), a = P(e, n, r), s = f.has(a.id);
+      return f.set(a.id, a), y(i, a), e !== n && y(o, a), w(a, s ? "update" : "add"), c(), a;
+    }
+    function Y(e, n, r) {
+      var i = p(e, n), o = f.get(i);
+      return o ? (o.data = r, o) : new C(e, n, r, i);
+    }
+    function j(e, n, r) {
+      var i = p(e, n), o = g.hasOwnProperty(i);
+      if (o || k(e, n)) {
+        o || (g[i] = 0);
+        var a = "@" + ++g[i];
+        i = p(e + a, n + a);
+      }
+      return new C(e, n, r, i);
+    }
+    function _() {
+      return u.size;
+    }
+    function q() {
+      return f.size;
+    }
+    function A(e) {
+      var n = d(e);
+      return n ? n.links : null;
+    }
+    function B(e, n) {
+      return n !== void 0 && (e = k(e, n)), U(e);
+    }
+    function U(e) {
+      if (!e || !f.get(e.id)) return !1;
+      v(), f.delete(e.id);
+      var n = d(e.fromId), r = d(e.toId);
+      return n && n.links.delete(e), r && r.links.delete(e), w(e, "remove"), c(), !0;
+    }
+    function k(e, n) {
+      if (!(e === void 0 || n === void 0))
+        return f.get(p(e, n));
+    }
+    function D() {
+      v(), S(function(e) {
+        M(e.id);
+      }), c();
+    }
+    function H(e) {
+      if (typeof e == "function")
+        for (var n = f.values(), r = n.next(); !r.done; ) {
+          if (e(r.value))
+            return !0;
+          r = n.next();
+        }
+    }
+    function J(e, n, r) {
+      var i = d(e);
+      if (i && i.links && typeof n == "function")
+        return r ? Q(i.links, e, n) : K(i.links, e, n);
+    }
+    function K(e, n, r) {
+      for (var i, o = e.values(), a = o.next(); !a.done; ) {
+        var s = a.value, Z = s.fromId === n ? s.toId : s.fromId;
+        if (i = r(u.get(Z), s), i)
+          return !0;
+        a = o.next();
+      }
+    }
+    function Q(e, n, r) {
+      for (var i, o = e.values(), a = o.next(); !a.done; ) {
+        var s = a.value;
+        if (s.fromId === n && (i = r(u.get(s.toId), s), i))
+          return !0;
+        a = o.next();
+      }
+    }
+    function N() {
+    }
+    function W() {
+      m += 1;
+    }
+    function X() {
+      m -= 1, m === 0 && l.length > 0 && (h.fire("changed", l), l.length = 0);
+    }
+    function S(e) {
+      if (typeof e != "function")
+        throw new Error("Function is expected to iterate over graph nodes. You passed " + e);
+      for (var n = u.values(), r = n.next(); !r.done; ) {
+        if (e(r.value))
+          return !0;
+        r = n.next();
+      }
+    }
+  }
+  function O(t, u) {
+    this.id = t, this.links = null, this.data = u;
+  }
+  function y(t, u) {
+    t.links ? t.links.add(u) : t.links = /* @__PURE__ */ new Set([u]);
+  }
+  function C(t, u, f, g) {
+    this.fromId = t, this.toId = u, this.data = f, this.id = g;
+  }
+  function p(t, u) {
+    return t.toString() + "👉 " + u.toString();
+  }
+  return x;
+}
+export {
+  ee as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.merge@1.0.0/node_modules/ngraph.merge/index.js

@@ -0,0 +1,20 @@
+var u, n;
+function v() {
+  if (n) return u;
+  n = 1, u = h;
+  function h(e, f) {
+    var r;
+    if (e || (e = {}), f) {
+      for (r in f)
+        if (f.hasOwnProperty(r)) {
+          var _ = e.hasOwnProperty(r), i = typeof f[r], m = !_ || typeof e[r] !== i;
+          m ? e[r] = f[r] : i === "object" && (e[r] = h(e[r], f[r]));
+        }
+    }
+    return e;
+  }
+  return u;
+}
+export {
+  v as __require
+};

package/dist/es/node_modules/.pnpm/ngraph.random@1.2.0/node_modules/ngraph.random/index.js

@@ -0,0 +1,71 @@
+import { __module as i } from "../../../../../_virtual/index7.js";
+var p;
+function b() {
+  if (p) return i.exports;
+  p = 1, i.exports = u, i.exports.random = u, i.exports.randomIterator = l;
+  function u(t) {
+    var f = typeof t == "number" ? t : +/* @__PURE__ */ new Date();
+    return new o(f);
+  }
+  function o(t) {
+    this.seed = t;
+  }
+  o.prototype.next = m, o.prototype.nextDouble = a, o.prototype.uniform = a, o.prototype.gaussian = d, o.prototype.random = a;
+  function d() {
+    var t, f, r;
+    do
+      f = this.nextDouble() * 2 - 1, r = this.nextDouble() * 2 - 1, t = f * f + r * r;
+    while (t >= 1 || t === 0);
+    return f * Math.sqrt(-2 * Math.log(t) / t);
+  }
+  o.prototype.levy = c;
+  function c() {
+    var t = 1.5, f = Math.pow(
+      x(1 + t) * Math.sin(Math.PI * t / 2) / (x((1 + t) / 2) * t * Math.pow(2, (t - 1) / 2)),
+      1 / t
+    );
+    return this.gaussian() * f / Math.pow(Math.abs(this.gaussian()), 1 / t);
+  }
+  function x(t) {
+    return Math.sqrt(2 * Math.PI / t) * Math.pow(1 / Math.E * (t + 1 / (12 * t - 1 / (10 * t))), t);
+  }
+  function a() {
+    var t = this.seed;
+    return t = t + 2127912214 + (t << 12) & 4294967295, t = (t ^ 3345072700 ^ t >>> 19) & 4294967295, t = t + 374761393 + (t << 5) & 4294967295, t = (t + 3550635116 ^ t << 9) & 4294967295, t = t + 4251993797 + (t << 3) & 4294967295, t = (t ^ 3042594569 ^ t >>> 16) & 4294967295, this.seed = t, (t & 268435455) / 268435456;
+  }
+  function m(t) {
+    return Math.floor(this.nextDouble() * t);
+  }
+  function l(t, f) {
+    var r = f || u();
+    if (typeof r.next != "function")
+      throw new Error("customRandom does not match expected API: next() function is missing");
+    return {
+      /**
+       * Visits every single element of a collection once, in a random order.
+       * Note: collection is modified in place.
+       */
+      forEach: M,
+      /**
+       * Shuffles array randomly, in place.
+       */
+      shuffle: g
+    };
+    function g() {
+      var n, e, s;
+      for (n = t.length - 1; n > 0; --n)
+        e = r.next(n + 1), s = t[e], t[e] = t[n], t[n] = s;
+      return t;
+    }
+    function M(n) {
+      var e, s, h;
+      for (e = t.length - 1; e > 0; --e)
+        s = r.next(e + 1), h = t[s], t[s] = t[e], t[e] = h, n(h);
+      t.length && n(t[0]);
+    }
+  }
+  return i.exports;
+}
+export {
+  b as __require
+};