@xiping/react-components 1.0.19 → 1.0.21

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
+};

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

@@ -0,0 +1,55 @@
+import { __module as t } from "../../../../../../../_virtual/generateIntegrator.js";
+import { __require as v } from "./createPatternBuilder.js";
+var i;
+function p() {
+  if (i) return t.exports;
+  i = 1;
+  const o = v();
+  t.exports = a, t.exports.generateIntegratorFunctionBody = n;
+  function a(r) {
+    let e = n(r);
+    return new Function("bodies", "timeStep", "adaptiveTimeStepWeight", e);
+  }
+  function n(r) {
+    let e = o(r);
+    return `
+  var length = bodies.length;
+  if (length === 0) return 0;
+
+  ${e("var d{var} = 0, t{var} = 0;", { indent: 2 })}
+
+  for (var i = 0; i < length; ++i) {
+    var body = bodies[i];
+    if (body.isPinned) continue;
+
+    if (adaptiveTimeStepWeight && body.springCount) {
+      timeStep = (adaptiveTimeStepWeight * body.springLength/body.springCount);
+    }
+
+    var coeff = timeStep / body.mass;
+
+    ${e("body.velocity.{var} += coeff * body.force.{var};", { indent: 4 })}
+    ${e("var v{var} = body.velocity.{var};", { indent: 4 })}
+    var v = Math.sqrt(${e("v{var} * v{var}", { join: " + " })});
+
+    if (v > 1) {
+      // We normalize it so that we move within timeStep range. 
+      // for the case when v <= 1 - we let velocity to fade out.
+      ${e("body.velocity.{var} = v{var} / v;", { indent: 6 })}
+    }
+
+    ${e("d{var} = timeStep * body.velocity.{var};", { indent: 4 })}
+
+    ${e("body.pos.{var} += d{var};", { indent: 4 })}
+
+    ${e("t{var} += Math.abs(d{var});", { indent: 4 })}
+  }
+
+  return (${e("t{var} * t{var}", { join: " + " })})/length;
+`;
+  }
+  return t.exports;
+}
+export {
+  p as __require
+};