react-sigma/lib/ForceAtlas2.js

Lightweight but powerful library for drawing network graphs built on top of SigmaJS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _react = _interopRequireDefault(require("react"));

require("../sigma/layout.forceAtlas2");

var _tools = require("./tools");

var _propTypes = _interopRequireDefault(require("prop-types"));

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**

ForceAtlas2 component, starts ForceAtlas2 sigma plugin once component is mounted.
It supposes that sigma graph is already in place, therefore component should not be
mounted while graph is unavailable. It can be used within Sigma component if graph is
preloaded, or within loader component, like NeoCypher.

It accepts all the parameters of ForceAtlas2 described on its github page:
@param {boolean} [worker=true]           Use a web worker to run calculations in separate thread
@param {boolean} barnesHutOptimize  Use the algorithm's Barnes-Hut to improve repulsion's scalability
									This is useful for large graph but harmful to small ones.
@param {number} barnesHutTheta
@param {boolean} adjustSizes
@param {number} iterationsPerRender
@param {boolean} [linLogMode=true]
@param {boolean} outboundAttractionDistribution
@param {number} edgeWeightInfluence
@param {number} scalingRatio
@param {boolean} strongGravityMode
@param {number} gravity
@param {number} slowDown
@param {number} timeout   how long algorythm should run. default=graph.nodes().length * 10

[see sigma plugin page for more details](https://github.com/jacomyal/sigma.js/tree/master/plugins/sigma.layout.forceAtlas2)

**/
class ForceAtlas2 extends _react.default.Component {
  constructor(props) {
    super(props);
    this.state = {
      running: false
    };
  }

  componentDidMount() {
    this._refreshGraph();
  }

  componentDidUpdate(prevProps, prevState) {
    let s = this.props.sigma;

    if (prevState.running && !this.state.running && s) {
      s.stopForceAtlas2();
      s.settings({
        drawEdges: prevState.drawEdges === false ? false : true
      });
      s.refresh();
    }
  }

  componentWillUnmount() {
    if (this.props.sigma) this.props.sigma.killForceAtlas2();
    if (this.state.timer) clearTimeout(this.state.timer);
  }

  render() {
    if (!this.state.running) {
      return /*#__PURE__*/_react.default.createElement("div", null, (0, _tools.embedProps)(this.props.children, {
        sigma: this.props.sigma
      }));
    }

    return null;
  }

  _refreshGraph() {
    let s = this.props.sigma;
    if (!sigma || !s) return;
    let drawEdges = s.settings("drawEdges");
    if (s.graph.edges().length > 1000) s.settings({
      drawEdges: false
    });
    s.startForceAtlas2(this._stripOptions(this.props)); // TODO: convert running status to state

    let timer = setTimeout(() => {
      this.setState({
        running: false,
        timer: undefined
      });
    }, this.props.timeout || s.graph.nodes().length * 8);
    this.setState({
      running: true,
      timer,
      drawEdges
    });
  } //strip force atlas options from component props


  _stripOptions(props) {
    return Object.assign({}, props, {
      sigma: undefined,
      children: undefined
    });
  }

}

_defineProperty(ForceAtlas2, "defaultProps", {
  worker: true,
  linLogMode: true
});

_defineProperty(ForceAtlas2, "propTypes", {
  worker: _propTypes.default.bool,
  barnesHutOptimize: _propTypes.default.bool,
  barnesHutTheta: _propTypes.default.number,
  adjustSizes: _propTypes.default.bool,
  iterationsPerRender: _propTypes.default.number,
  linLogMode: _propTypes.default.bool,
  outboundAttractionDistribution: _propTypes.default.bool,
  edgeWeightInfluence: _propTypes.default.number,
  scalingRatio: _propTypes.default.number,
  strongGravityMode: _propTypes.default.bool,
  slowDown: _propTypes.default.number,
  gravity: _propTypes.default.number,
  timeout: _propTypes.default.number,
  sigma: function () {
    return (typeof sigma === "function" ? _propTypes.default.instanceOf(sigma) : _propTypes.default.any).apply(this, arguments);
  },
  children: _propTypes.default.any
});

var _default = ForceAtlas2;
exports.default = _default;