@xiping/react-components 1.0.29 → 1.0.31

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

@@ -1,403 +0,0 @@
-import { __module as s } from "../../../../../../../_virtual/generateQuadTree.js";
-import { __require as w } from "./createPatternBuilder.js";
-import { __require as q } from "./getVariableName.js";
-var $;
-function B() {
-  if ($) return s.exports;
-  $ = 1;
-  const p = w(), u = q();
-  s.exports = g, s.exports.generateQuadTreeFunctionBody = l, s.exports.getInsertStackCode = x, s.exports.getQuadNodeCode = b, s.exports.isSamePosition = f, s.exports.getChildBodyCode = m, s.exports.setChildBodyCode = y;
-  function g(t) {
-    let e = l(t);
-    return new Function(e)();
-  }
-  function l(t) {
-    let e = p(t), a = Math.pow(2, t);
-    return `
-${x()}
-${b(t)}
-${f(t)}
-${m(t)}
-${y(t)}
-
-function createQuadTree(options, random) {
-  options = options || {};
-  options.gravity = typeof options.gravity === 'number' ? options.gravity : -1;
-  options.theta = typeof options.theta === 'number' ? options.theta : 0.8;
-
-  var gravity = options.gravity;
-  var updateQueue = [];
-  var insertStack = new InsertStack();
-  var theta = options.theta;
-
-  var nodesCache = [];
-  var currentInCache = 0;
-  var root = newNode();
-
-  return {
-    insertBodies: insertBodies,
-
-    /**
-     * Gets root node if it is present
-     */
-    getRoot: function() {
-      return root;
-    },
-
-    updateBodyForce: update,
-
-    options: function(newOptions) {
-      if (newOptions) {
-        if (typeof newOptions.gravity === 'number') {
-          gravity = newOptions.gravity;
-        }
-        if (typeof newOptions.theta === 'number') {
-          theta = newOptions.theta;
-        }
-
-        return this;
-      }
-
-      return {
-        gravity: gravity,
-        theta: theta
-      };
-    }
-  };
-
-  function newNode() {
-    // To avoid pressure on GC we reuse nodes.
-    var node = nodesCache[currentInCache];
-    if (node) {
-${v("      node.")}
-      node.body = null;
-      node.mass = ${e("node.mass_{var} = ", { join: "" })}0;
-      ${e("node.min_{var} = node.max_{var} = ", { join: "" })}0;
-    } else {
-      node = new QuadNode();
-      nodesCache[currentInCache] = node;
-    }
-
-    ++currentInCache;
-    return node;
-  }
-
-  function update(sourceBody) {
-    var queue = updateQueue;
-    var v;
-    ${e("var d{var};", { indent: 4 })}
-    var r; 
-    ${e("var f{var} = 0;", { indent: 4 })}
-    var queueLength = 1;
-    var shiftIdx = 0;
-    var pushIdx = 1;
-
-    queue[0] = root;
-
-    while (queueLength) {
-      var node = queue[shiftIdx];
-      var body = node.body;
-
-      queueLength -= 1;
-      shiftIdx += 1;
-      var differentBody = (body !== sourceBody);
-      if (body && differentBody) {
-        // If the current node is a leaf node (and it is not source body),
-        // calculate the force exerted by the current node on body, and add this
-        // amount to body's net force.
-        ${e("d{var} = body.pos.{var} - sourceBody.pos.{var};", { indent: 8 })}
-        r = Math.sqrt(${e("d{var} * d{var}", { join: " + " })});
-
-        if (r === 0) {
-          // Poor man's protection against zero distance.
-          ${e("d{var} = (random.nextDouble() - 0.5) / 50;", { indent: 10 })}
-          r = Math.sqrt(${e("d{var} * d{var}", { join: " + " })});
-        }
-
-        // This is standard gravitation force calculation but we divide
-        // by r^3 to save two operations when normalizing force vector.
-        v = gravity * body.mass * sourceBody.mass / (r * r * r);
-        ${e("f{var} += v * d{var};", { indent: 8 })}
-      } else if (differentBody) {
-        // Otherwise, calculate the ratio s / r,  where s is the width of the region
-        // represented by the internal node, and r is the distance between the body
-        // and the node's center-of-mass
-        ${e("d{var} = node.mass_{var} / node.mass - sourceBody.pos.{var};", { indent: 8 })}
-        r = Math.sqrt(${e("d{var} * d{var}", { join: " + " })});
-
-        if (r === 0) {
-          // Sorry about code duplication. I don't want to create many functions
-          // right away. Just want to see performance first.
-          ${e("d{var} = (random.nextDouble() - 0.5) / 50;", { indent: 10 })}
-          r = Math.sqrt(${e("d{var} * d{var}", { join: " + " })});
-        }
-        // If s / r < θ, treat this internal node as a single body, and calculate the
-        // force it exerts on sourceBody, and add this amount to sourceBody's net force.
-        if ((node.max_${u(0)} - node.min_${u(0)}) / r < theta) {
-          // in the if statement above we consider node's width only
-          // because the region was made into square during tree creation.
-          // Thus there is no difference between using width or height.
-          v = gravity * node.mass * sourceBody.mass / (r * r * r);
-          ${e("f{var} += v * d{var};", { indent: 10 })}
-        } else {
-          // Otherwise, run the procedure recursively on each of the current node's children.
-
-          // I intentionally unfolded this loop, to save several CPU cycles.
-${c()}
-        }
-      }
-    }
-
-    ${e("sourceBody.force.{var} += f{var};", { indent: 4 })}
-  }
-
-  function insertBodies(bodies) {
-    ${e("var {var}min = Number.MAX_VALUE;", { indent: 4 })}
-    ${e("var {var}max = Number.MIN_VALUE;", { indent: 4 })}
-    var i = bodies.length;
-
-    // To reduce quad tree depth we are looking for exact bounding box of all particles.
-    while (i--) {
-      var pos = bodies[i].pos;
-      ${e("if (pos.{var} < {var}min) {var}min = pos.{var};", { indent: 6 })}
-      ${e("if (pos.{var} > {var}max) {var}max = pos.{var};", { indent: 6 })}
-    }
-
-    // Makes the bounds square.
-    var maxSideLength = -Infinity;
-    ${e("if ({var}max - {var}min > maxSideLength) maxSideLength = {var}max - {var}min ;", { indent: 4 })}
-
-    currentInCache = 0;
-    root = newNode();
-    ${e("root.min_{var} = {var}min;", { indent: 4 })}
-    ${e("root.max_{var} = {var}min + maxSideLength;", { indent: 4 })}
-
-    i = bodies.length - 1;
-    if (i >= 0) {
-      root.body = bodies[i];
-    }
-    while (i--) {
-      insert(bodies[i], root);
-    }
-  }
-
-  function insert(newBody) {
-    insertStack.reset();
-    insertStack.push(root, newBody);
-
-    while (!insertStack.isEmpty()) {
-      var stackItem = insertStack.pop();
-      var node = stackItem.node;
-      var body = stackItem.body;
-
-      if (!node.body) {
-        // This is internal node. Update the total mass of the node and center-of-mass.
-        ${e("var {var} = body.pos.{var};", { indent: 8 })}
-        node.mass += body.mass;
-        ${e("node.mass_{var} += body.mass * {var};", { indent: 8 })}
-
-        // Recursively insert the body in the appropriate quadrant.
-        // But first find the appropriate quadrant.
-        var quadIdx = 0; // Assume we are in the 0's quad.
-        ${e("var min_{var} = node.min_{var};", { indent: 8 })}
-        ${e("var max_{var} = (min_{var} + node.max_{var}) / 2;", { indent: 8 })}
-
-${o(8)}
-
-        var child = getChild(node, quadIdx);
-
-        if (!child) {
-          // The node is internal but this quadrant is not taken. Add
-          // subnode to it.
-          child = newNode();
-          ${e("child.min_{var} = min_{var};", { indent: 10 })}
-          ${e("child.max_{var} = max_{var};", { indent: 10 })}
-          child.body = body;
-
-          setChild(node, quadIdx, child);
-        } else {
-          // continue searching in this quadrant.
-          insertStack.push(child, body);
-        }
-      } else {
-        // We are trying to add to the leaf node.
-        // We have to convert current leaf into internal node
-        // and continue adding two nodes.
-        var oldBody = node.body;
-        node.body = null; // internal nodes do not cary bodies
-
-        if (isSamePosition(oldBody.pos, body.pos)) {
-          // Prevent infinite subdivision by bumping one node
-          // anywhere in this quadrant
-          var retriesCount = 3;
-          do {
-            var offset = random.nextDouble();
-            ${e("var d{var} = (node.max_{var} - node.min_{var}) * offset;", { indent: 12 })}
-
-            ${e("oldBody.pos.{var} = node.min_{var} + d{var};", { indent: 12 })}
-            retriesCount -= 1;
-            // Make sure we don't bump it out of the box. If we do, next iteration should fix it
-          } while (retriesCount > 0 && isSamePosition(oldBody.pos, body.pos));
-
-          if (retriesCount === 0 && isSamePosition(oldBody.pos, body.pos)) {
-            // This is very bad, we ran out of precision.
-            // if we do not return from the method we'll get into
-            // infinite loop here. So we sacrifice correctness of layout, and keep the app running
-            // Next layout iteration should get larger bounding box in the first step and fix this
-            return;
-          }
-        }
-        // Next iteration should subdivide node further.
-        insertStack.push(node, oldBody);
-        insertStack.push(node, body);
-      }
-    }
-  }
-}
-return createQuadTree;
-
-`;
-    function o(i) {
-      let n = [], r = Array(i + 1).join(" ");
-      for (let d = 0; d < t; ++d)
-        n.push(r + `if (${u(d)} > max_${u(d)}) {`), n.push(r + `  quadIdx = quadIdx + ${Math.pow(2, d)};`), n.push(r + `  min_${u(d)} = max_${u(d)};`), n.push(r + `  max_${u(d)} = node.max_${u(d)};`), n.push(r + "}");
-      return n.join(`
-`);
-    }
-    function c() {
-      let i = Array(11).join(" "), n = [];
-      for (let r = 0; r < a; ++r)
-        n.push(i + `if (node.quad${r}) {`), n.push(i + `  queue[pushIdx] = node.quad${r};`), n.push(i + "  queueLength += 1;"), n.push(i + "  pushIdx += 1;"), n.push(i + "}");
-      return n.join(`
-`);
-    }
-    function v(i) {
-      let n = [];
-      for (let r = 0; r < a; ++r)
-        n.push(`${i}quad${r} = null;`);
-      return n.join(`
-`);
-    }
-  }
-  function f(t) {
-    let e = p(t);
-    return `
-  function isSamePosition(point1, point2) {
-    ${e("var d{var} = Math.abs(point1.{var} - point2.{var});", { indent: 2 })}
-  
-    return ${e("d{var} < 1e-8", { join: " && " })};
-  }  
-`;
-  }
-  function y(t) {
-    var e = Math.pow(2, t);
-    return `
-function setChild(node, idx, child) {
-  ${a()}
-}`;
-    function a() {
-      let h = [];
-      for (let o = 0; o < e; ++o) {
-        let c = o === 0 ? "  " : "  else ";
-        h.push(`${c}if (idx === ${o}) node.quad${o} = child;`);
-      }
-      return h.join(`
-`);
-    }
-  }
-  function m(t) {
-    return `function getChild(node, idx) {
-${e()}
-  return null;
-}`;
-    function e() {
-      let a = [], h = Math.pow(2, t);
-      for (let o = 0; o < h; ++o)
-        a.push(`  if (idx === ${o}) return node.quad${o};`);
-      return a.join(`
-`);
-    }
-  }
-  function b(t) {
-    let e = p(t), a = Math.pow(2, t);
-    var h = `
-function QuadNode() {
-  // body stored inside this node. In quad tree only leaf nodes (by construction)
-  // contain bodies:
-  this.body = null;
-
-  // Child nodes are stored in quads. Each quad is presented by number:
-  // 0 | 1
-  // -----
-  // 2 | 3
-${o("  this.")}
-
-  // Total mass of current node
-  this.mass = 0;
-
-  // Center of mass coordinates
-  ${e("this.mass_{var} = 0;", { indent: 2 })}
-
-  // bounding box coordinates
-  ${e("this.min_{var} = 0;", { indent: 2 })}
-  ${e("this.max_{var} = 0;", { indent: 2 })}
-}
-`;
-    return h;
-    function o(c) {
-      let v = [];
-      for (let i = 0; i < a; ++i)
-        v.push(`${c}quad${i} = null;`);
-      return v.join(`
-`);
-    }
-  }
-  function x() {
-    return `
-/**
- * Our implementation of QuadTree is non-recursive to avoid GC hit
- * This data structure represent stack of elements
- * which we are trying to insert into quad tree.
- */
-function InsertStack () {
-    this.stack = [];
-    this.popIdx = 0;
-}
-
-InsertStack.prototype = {
-    isEmpty: function() {
-        return this.popIdx === 0;
-    },
-    push: function (node, body) {
-        var item = this.stack[this.popIdx];
-        if (!item) {
-            // we are trying to avoid memory pressure: create new element
-            // only when absolutely necessary
-            this.stack[this.popIdx] = new InsertStackElement(node, body);
-        } else {
-            item.node = node;
-            item.body = body;
-        }
-        ++this.popIdx;
-    },
-    pop: function () {
-        if (this.popIdx > 0) {
-            return this.stack[--this.popIdx];
-        }
-    },
-    reset: function () {
-        this.popIdx = 0;
-    }
-};
-
-function InsertStackElement(node, body) {
-    this.node = node; // QuadTree node
-    this.body = body; // physical body which needs to be inserted to node
-}
-`;
-  }
-  return s.exports;
-}
-export {
-  B as __require
-};

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

@@ -1,9 +0,0 @@
-var e, a;
-function u() {
-  return a || (a = 1, e = function(r) {
-    return r === 0 ? "x" : r === 1 ? "y" : r === 2 ? "z" : "c" + (r + 1);
-  }), e;
-}
-export {
-  u as __require
-};

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

@@ -1,273 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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
-};