cytoscape-cola.js

(function webpackUniversalModuleDefinition(root, factory) {
  if (typeof exports === "object" && typeof module === "object")
    module.exports = factory(require("webcola"));
  else if (typeof define === "function" && define.amd)
    define(["webcola"], factory);
  else if (typeof exports === "object")
    exports["cytoscapeCola"] = factory(require("webcola"));
  else root["cytoscapeCola"] = factory(root["webcola"]);
})(this, function (__WEBPACK_EXTERNAL_MODULE_5__) {
  return /******/ (function (modules) {
    // webpackBootstrap
    /******/ // The module cache
    /******/ var installedModules = {};
    /******/
    /******/ // The require function
    /******/ function __webpack_require__(moduleId) {
      /******/
      /******/ // Check if module is in cache
      /******/ if (installedModules[moduleId]) {
        /******/ return installedModules[moduleId].exports;
        /******/
      }
      /******/ // Create a new module (and put it into the cache)
      /******/ var module = (installedModules[moduleId] = {
        /******/ i: moduleId,
        /******/ l: false,
        /******/ exports: {},
        /******/
      });
      /******/
      /******/ // Execute the module function
      /******/ modules[moduleId].call(
        module.exports,
        module,
        module.exports,
        __webpack_require__
      );
      /******/
      /******/ // Flag the module as loaded
      /******/ module.l = true;
      /******/
      /******/ // Return the exports of the module
      /******/ return module.exports;
      /******/
    }
    /******/
    /******/
    /******/ // expose the modules object (__webpack_modules__)
    /******/ __webpack_require__.m = modules;
    /******/
    /******/ // expose the module cache
    /******/ __webpack_require__.c = installedModules;
    /******/
    /******/ // identity function for calling harmony imports with the correct context
    /******/ __webpack_require__.i = function (value) {
      return value;
    };
    /******/
    /******/ // define getter function for harmony exports
    /******/ __webpack_require__.d = function (exports, name, getter) {
      /******/ if (!__webpack_require__.o(exports, name)) {
        /******/ Object.defineProperty(exports, name, {
          /******/ configurable: false,
          /******/ enumerable: true,
          /******/ get: getter,
          /******/
        });
        /******/
      }
      /******/
    };
    /******/
    /******/ // getDefaultExport function for compatibility with non-harmony modules
    /******/ __webpack_require__.n = function (module) {
      /******/ var getter =
        module && module.__esModule
          ? /******/ function getDefault() {
              return module["default"];
            }
          : /******/ function getModuleExports() {
              return module;
            };
      /******/ __webpack_require__.d(getter, "a", getter);
      /******/ return getter;
      /******/
    };
    /******/
    /******/ // Object.prototype.hasOwnProperty.call
    /******/ __webpack_require__.o = function (object, property) {
      return Object.prototype.hasOwnProperty.call(object, property);
    };
    /******/
    /******/ // __webpack_public_path__
    /******/ __webpack_require__.p = "";
    /******/
    /******/ // Load entry module and return exports
    /******/ return __webpack_require__((__webpack_require__.s = 3));
    /******/
  })(
    /************************************************************************/
    /******/ [
      /* 0 */
      /***/ function (module, exports, __webpack_require__) {
        "use strict";

        var _typeof =
          typeof Symbol === "function" && typeof Symbol.iterator === "symbol"
            ? function (obj) {
                return typeof obj;
              }
            : function (obj) {
                return obj &&
                  typeof Symbol === "function" &&
                  obj.constructor === Symbol &&
                  obj !== Symbol.prototype
                  ? "symbol"
                  : typeof obj;
              };

        var assign = __webpack_require__(1);
        var defaults = __webpack_require__(2);
        var cola =
          __webpack_require__(5) ||
          (typeof window !== "undefined" ? window.cola : null);
        var raf = __webpack_require__(4);
        var isString = function isString(o) {
          return (
            (typeof o === "undefined" ? "undefined" : _typeof(o)) ===
            _typeof("")
          );
        };
        var isNumber = function isNumber(o) {
          return (
            (typeof o === "undefined" ? "undefined" : _typeof(o)) === _typeof(0)
          );
        };
        var isObject = function isObject(o) {
          return (
            o != null &&
            (typeof o === "undefined" ? "undefined" : _typeof(o)) ===
              _typeof({})
          );
        };
        var isFunction = function isFunction(o) {
          return (
            o != null &&
            (typeof o === "undefined" ? "undefined" : _typeof(o)) ===
              _typeof(function () {})
          );
        };
        var nop = function nop() {};

        var getOptVal = function getOptVal(val, ele) {
          if (isFunction(val)) {
            var fn = val;
            return fn.apply(ele, [ele]);
          } else {
            return val;
          }
        };

        // constructor
        // options : object containing layout options
        function ColaLayout(options) {
          this.options = assign({}, defaults, options);
        }

        // runs the layout
        ColaLayout.prototype.run = function () {
          var layout = this;
          var options = this.options;

          layout.manuallyStopped = false;

          var cy = options.cy; // cy is automatically populated for us in the constructor
          var eles = options.eles;
          var nodes = eles.nodes();
          var edges = eles.edges();
          var ready = false;

          var isParent = function isParent(ele) {
            return ele.isParent();
          };

          var parentNodes = nodes.filter(isParent);

          var nonparentNodes = nodes.subtract(parentNodes);

          var bb = options.boundingBox || {
            x1: 0,
            y1: 0,
            w: cy.width(),
            h: cy.height(),
          };
          if (bb.x2 === undefined) {
            bb.x2 = bb.x1 + bb.w;
          }
          if (bb.w === undefined) {
            bb.w = bb.x2 - bb.x1;
          }
          if (bb.y2 === undefined) {
            bb.y2 = bb.y1 + bb.h;
          }
          if (bb.h === undefined) {
            bb.h = bb.y2 - bb.y1;
          }

          var updateNodePositions = function updateNodePositions() {
            for (var i = 0; i < nodes.length; i++) {
              var node = nodes[i];
              var dimensions = node.layoutDimensions(options);
              var scratch = node.scratch("cola");

              // update node dims
              if (!scratch.updatedDims) {
                var padding = getOptVal(options.nodeSpacing, node);

                scratch.width = dimensions.w + 2 * padding;
                scratch.height = dimensions.h + 2 * padding;
              }
            }

            nodes.positions(function (node) {
              var scratch = node.scratch().cola;
              var retPos = void 0;

              if (!node.grabbed() && nonparentNodes.contains(node)) {
                retPos = {
                  x: bb.x1 + scratch.x,
                  y: bb.y1 + scratch.y,
                };

                if (!isNumber(retPos.x) || !isNumber(retPos.y)) {
                  retPos = undefined;
                }
              }

              return retPos;
            });

            nodes.updateCompoundBounds(); // because the way this layout sets positions is buggy for some reason; ref #878

            if (!ready) {
              onReady();
              ready = true;
            }

            if (options.fit) {
              cy.fit(options.padding);
            }
          };

          var onDone = function onDone() {
            if (options.ungrabifyWhileSimulating) {
              grabbableNodes.grabify();
            }

            cy.off("destroy", destroyHandler);

            nodes.off("grab free position", grabHandler);
            nodes.off("lock unlock", lockHandler);

            // trigger layoutstop when the layout stops (e.g. finishes)
            layout.one("layoutstop", options.stop);
            layout.trigger({ type: "layoutstop", layout: layout });
          };

          var onReady = function onReady() {
            // trigger layoutready when each node has had its position set at least once
            layout.one("layoutready", options.ready);
            layout.trigger({ type: "layoutready", layout: layout });
          };

          var ticksPerFrame = options.refresh;

          if (options.refresh < 0) {
            ticksPerFrame = 1;
          } else {
            ticksPerFrame = Math.max(1, ticksPerFrame); // at least 1
          }

          var adaptor = (layout.adaptor = cola.adaptor({
            trigger: function trigger(e) {
              // on sim event
              var TICK = cola.EventType ? cola.EventType.tick : null;
              var END = cola.EventType ? cola.EventType.end : null;

              switch (e.type) {
                case "tick":
                case TICK:
                  if (options.animate) {
                    updateNodePositions();
                  }
                  break;

                case "end":
                case END:
                  updateNodePositions();
                  if (!options.infinite) {
                    onDone();
                  }
                  break;
              }
            },

            kick: function kick() {
              // kick off the simulation
              //let skip = 0;

              var firstTick = true;

              var inftick = function inftick() {
                if (layout.manuallyStopped) {
                  onDone();

                  return true;
                }

                var ret = adaptor.tick();

                if (!options.infinite && !firstTick) {
                  adaptor.convergenceThreshold(options.convergenceThreshold);
                }

                firstTick = false;

                if (ret && options.infinite) {
                  // resume layout if done
                  adaptor.resume(); // resume => new kick
                }

                return ret; // allow regular finish b/c of new kick
              };

              var multitick = function multitick() {
                // multiple ticks in a row
                var ret = void 0;

                for (var i = 0; i < ticksPerFrame && !ret; i++) {
                  ret = ret || inftick(); // pick up true ret vals => sim done
                }

                return ret;
              };

              if (options.animate) {
                var frame = function frame() {
                  if (multitick()) {
                    return;
                  }

                  raf(frame);
                };

                raf(frame);
              } else {
                while (!inftick()) {
                  // keep going...
                }
              }
            },

            on: nop, // dummy; not needed

            drag: nop, // not needed for our case
          }));
          layout.adaptor = adaptor;

          // if set no grabbing during layout
          var grabbableNodes = nodes.filter(":grabbable");
          if (options.ungrabifyWhileSimulating) {
            grabbableNodes.ungrabify();
          }

          var destroyHandler = void 0;
          cy.one(
            "destroy",
            (destroyHandler = function destroyHandler() {
              layout.stop();
            })
          );

          // handle node dragging
          var grabHandler = void 0;
          nodes.on(
            "grab free position",
            (grabHandler = function grabHandler(e) {
              var node = this;
              var scrCola = node.scratch().cola;
              var pos = node.position();
              var nodeIsTarget = e.cyTarget === node || e.target === node;

              if (!nodeIsTarget) {
                return;
              }

              switch (e.type) {
                case "grab":
                  adaptor.dragstart(scrCola);
                  break;
                case "free":
                  adaptor.dragend(scrCola);
                  break;
                case "position":
                  // only update when different (i.e. manual .position() call or drag) so we don't loop needlessly
                  if (
                    scrCola.px !== pos.x - bb.x1 ||
                    scrCola.py !== pos.y - bb.y1
                  ) {
                    scrCola.px = pos.x - bb.x1;
                    scrCola.py = pos.y - bb.y1;
                  }
                  break;
              }
            })
          );

          var lockHandler = void 0;
          nodes.on(
            "lock unlock",
            (lockHandler = function lockHandler() {
              var node = this;
              var scrCola = node.scratch().cola;

              scrCola.fixed = node.locked();

              if (node.locked()) {
                adaptor.dragstart(scrCola);
              } else {
                adaptor.dragend(scrCola);
              }
            })
          );

          // add nodes to cola
          adaptor.nodes(
            nonparentNodes.map(function (node, i) {
              var padding = getOptVal(options.nodeSpacing, node);
              var pos = node.position();
              var dimensions = node.layoutDimensions(options);

              var struct = (node.scratch().cola = {
                x:
                  (options.randomize && !node.locked()) || pos.x === undefined
                    ? Math.round(Math.random() * bb.w)
                    : pos.x,
                y:
                  (options.randomize && !node.locked()) || pos.y === undefined
                    ? Math.round(Math.random() * bb.h)
                    : pos.y,
                width: dimensions.w + 2 * padding,
                height: dimensions.h + 2 * padding,
                index: i,
                fixed: node.locked(),
              });

              return struct;
            })
          );

          // the constraints to be added on nodes
          var constraints = [];

          if (options.alignment) {
            // then set alignment constraints

            if (options.alignment.vertical) {
              var verticalAlignments = options.alignment.vertical;
              verticalAlignments.forEach(function (alignment) {
                var offsetsX = [];
                alignment.forEach(function (nodeData) {
                  var node = nodeData.node;
                  var scrCola = node.scratch().cola;
                  var index = scrCola.index;
                  offsetsX.push({
                    node: index,
                    offset: nodeData.offset ? nodeData.offset : 0,
                  });
                });
                constraints.push({
                  type: "alignment",
                  axis: "x",
                  offsets: offsetsX,
                });
              });
            }

            if (options.alignment.horizontal) {
              var horizontalAlignments = options.alignment.horizontal;
              horizontalAlignments.forEach(function (alignment) {
                var offsetsY = [];
                alignment.forEach(function (nodeData) {
                  var node = nodeData.node;
                  var scrCola = node.scratch().cola;
                  var index = scrCola.index;
                  offsetsY.push({
                    node: index,
                    offset: nodeData.offset ? nodeData.offset : 0,
                  });
                });
                constraints.push({
                  type: "alignment",
                  axis: "y",
                  offsets: offsetsY,
                });
              });
            }
          }

          // if gapInequalities variable is set add each inequality constraint to list of constraints
          if (options.gapInequalities) {
            options.gapInequalities.forEach(function (inequality) {
              // for the constraints to be passed to cola layout adaptor use indices of nodes,
              // not the nodes themselves
              var leftIndex = inequality.left.scratch().cola.index;
              var rightIndex = inequality.right.scratch().cola.index;

              constraints.push({
                axis: inequality.axis,
                left: leftIndex,
                right: rightIndex,
                gap: inequality.gap,
                equality: inequality.equality,
              });
            });
          }

          // add constraints if any
          if (constraints.length > 0) {
            adaptor.constraints(constraints);
          }

          // add compound nodes to cola
          adaptor.groups(
            parentNodes
              .map(function (node, i) {
                // add basic group incl leaf nodes
                var optPadding = getOptVal(options.nodeSpacing, node);
                var getPadding = function getPadding(d) {
                  return parseFloat(node.style("padding-" + d));
                };

                var pleft = getPadding("left") + optPadding;
                var pright = getPadding("right") + optPadding;
                var ptop = getPadding("top") + optPadding;
                var pbottom = getPadding("bottom") + optPadding;

                node.scratch().cola = {
                  index: i,

                  padding: Math.max(pleft, pright, ptop, pbottom),

                  // leaves should only contain direct descendants (children),
                  // not the leaves of nested compound nodes or any nodes that are compounds themselves
                  leaves: node
                    .children()
                    .intersection(nonparentNodes)
                    .map(function (child) {
                      return child[0].scratch().cola.index;
                    }),

                  fixed: node.locked(),
                };

                return node;
              })
              .map(function (node) {
                // add subgroups
                node.scratch().cola.groups = node
                  .children()
                  .intersection(parentNodes)
                  .map(function (child) {
                    return child.scratch().cola.index;
                  });

                return node.scratch().cola;
              })
          );

          // get the edge length setting mechanism
          var length = void 0;
          var lengthFnName = void 0;
          if (options.edgeLength != null) {
            length = options.edgeLength;
            lengthFnName = "linkDistance";
          } else if (options.edgeSymDiffLength != null) {
            length = options.edgeSymDiffLength;
            lengthFnName = "symmetricDiffLinkLengths";
          } else if (options.edgeJaccardLength != null) {
            length = options.edgeJaccardLength;
            lengthFnName = "jaccardLinkLengths";
          } else {
            length = 100;
            lengthFnName = "linkDistance";
          }

          var lengthGetter = function lengthGetter(link) {
            return link.calcLength;
          };

          // add the edges to cola
          adaptor.links(
            edges
              .stdFilter(function (edge) {
                return (
                  nonparentNodes.contains(edge.source()) &&
                  nonparentNodes.contains(edge.target())
                );
              })
              .map(function (edge) {
                var c = (edge.scratch().cola = {
                  source: edge.source()[0].scratch().cola.index,
                  target: edge.target()[0].scratch().cola.index,
                });

                if (length != null) {
                  c.calcLength = getOptVal(length, edge);
                }

                return c;
              })
          );

          adaptor.size([bb.w, bb.h]);

          if (length != null) {
            adaptor[lengthFnName](lengthGetter);
          }

          // set the flow of cola
          if (options.flow) {
            var flow = void 0;
            var defAxis = "y";
            var defMinSep = 50;

            if (isString(options.flow)) {
              flow = {
                axis: options.flow,
                minSeparation: defMinSep,
              };
            } else if (isNumber(options.flow)) {
              flow = {
                axis: defAxis,
                minSeparation: options.flow,
              };
            } else if (isObject(options.flow)) {
              flow = options.flow;

              flow.axis = flow.axis || defAxis;
              flow.minSeparation =
                flow.minSeparation != null ? flow.minSeparation : defMinSep;
            } else {
              // e.g. options.flow: true
              flow = {
                axis: defAxis,
                minSeparation: defMinSep,
              };
            }

            adaptor.flowLayout(flow.axis, flow.minSeparation);
          }

          layout.trigger({ type: "layoutstart", layout: layout });

          adaptor
            .avoidOverlaps(options.avoidOverlap)
            .handleDisconnected(options.handleDisconnected)
            .start(
              options.unconstrIter,
              options.userConstIter,
              options.allConstIter,
              undefined, // gridSnapIterations = 0
              undefined, // keepRunning = true
              options.centerGraph
            );

          if (!options.infinite) {
            setTimeout(function () {
              if (!layout.manuallyStopped) {
                adaptor.stop();
              }
            }, options.maxSimulationTime);
          }

          return this; // chaining
        };

        // called on continuous layouts to stop them before they finish
        ColaLayout.prototype.stop = function () {
          if (this.adaptor) {
            this.manuallyStopped = true;
            this.adaptor.stop();
          }

          return this; // chaining
        };

        module.exports = ColaLayout;

        /***/
      },
      /* 1 */
      /***/ function (module, exports, __webpack_require__) {
        "use strict";

        // Simple, internal Object.assign() polyfill for options objects etc.

        module.exports =
          Object.assign != null
            ? Object.assign.bind(Object)
            : function (tgt) {
                for (
                  var _len = arguments.length,
                    srcs = Array(_len > 1 ? _len - 1 : 0),
                    _key = 1;
                  _key < _len;
                  _key++
                ) {
                  srcs[_key - 1] = arguments[_key];
                }

                srcs
                  .filter(function (src) {
                    return src != null;
                  })
                  .forEach(function (src) {
                    Object.keys(src).forEach(function (k) {
                      return (tgt[k] = src[k]);
                    });
                  });

                return tgt;
              };

        /***/
      },
      /* 2 */
      /***/ function (module, exports, __webpack_require__) {
        "use strict";

        // default layout options
        var defaults = {
          animate: true, // whether to show the layout as it's running
          refresh: 1, // number of ticks per frame; higher is faster but more jerky
          maxSimulationTime: 4000, // max length in ms to run the layout
          ungrabifyWhileSimulating: false, // so you can't drag nodes during layout
          fit: true, // on every layout reposition of nodes, fit the viewport
          padding: 30, // padding around the simulation
          boundingBox: undefined, // constrain layout bounds; { x1, y1, x2, y2 } or { x1, y1, w, h }
          nodeDimensionsIncludeLabels: false, // whether labels should be included in determining the space used by a node

          // layout event callbacks
          ready: function ready() {}, // on layoutready
          stop: function stop() {}, // on layoutstop

          // positioning options
          randomize: false, // use random node positions at beginning of layout
          avoidOverlap: true, // if true, prevents overlap of node bounding boxes
          handleDisconnected: true, // if true, avoids disconnected components from overlapping
          convergenceThreshold: 0.01, // when the alpha value (system energy) falls below this value, the layout stops
          nodeSpacing: function nodeSpacing(node) {
            return 10;
          }, // extra spacing around nodes
          flow: undefined, // use DAG/tree flow layout if specified, e.g. { axis: 'y', minSeparation: 30 }
          alignment: undefined, // relative alignment constraints on nodes, e.g. function( node ){ return { x: 0, y: 1 } }
          gapInequalities: undefined, // list of inequality constraints for the gap between the nodes, e.g. [{"axis":"y", "left":node1, "right":node2, "gap":25}]
          centerGraph: true, // adjusts the node positions initially to center the graph (pass false if you want to start the layout from the current position)

          // different methods of specifying edge length
          // each can be a constant numerical value or a function like `function( edge ){ return 2; }`
          edgeLength: undefined, // sets edge length directly in simulation
          edgeSymDiffLength: undefined, // symmetric diff edge length in simulation
          edgeJaccardLength: undefined, // jaccard edge length in simulation

          // iterations of cola algorithm; uses default values on undefined
          unconstrIter: undefined, // unconstrained initial layout iterations
          userConstIter: undefined, // initial layout iterations with user-specified constraints
          allConstIter: undefined, // initial layout iterations with all constraints including non-overlap

          // infinite layout options
          infinite: false, // overrides all other options for a forces-all-the-time mode
        };

        module.exports = defaults;

        /***/
      },
      /* 3 */
      /***/ function (module, exports, __webpack_require__) {
        "use strict";

        var impl = __webpack_require__(0);

        // registers the extension on a cytoscape lib ref
        var register = function register(cytoscape) {
          if (!cytoscape) {
            return;
          } // can't register if cytoscape unspecified

          cytoscape("layout", "cola", impl); // register with cytoscape.js
        };

        if (typeof cytoscape !== "undefined") {
          // expose to global cytoscape (i.e. window.cytoscape)
          register(cytoscape);
        }

        module.exports = register;

        /***/
      },
      /* 4 */
      /***/ function (module, exports, __webpack_require__) {
        "use strict";

        var _typeof =
          typeof Symbol === "function" && typeof Symbol.iterator === "symbol"
            ? function (obj) {
                return typeof obj;
              }
            : function (obj) {
                return obj &&
                  typeof Symbol === "function" &&
                  obj.constructor === Symbol &&
                  obj !== Symbol.prototype
                  ? "symbol"
                  : typeof obj;
              };

        var raf = void 0;

        if (
          (typeof window === "undefined" ? "undefined" : _typeof(window)) !==
          (true ? "undefined" : _typeof(undefined))
        ) {
          raf =
            window.requestAnimationFrame ||
            window.webkitRequestAnimationFrame ||
            window.mozRequestAnimationFrame ||
            window.msRequestAnimationFrame ||
            function (fn) {
              return setTimeout(fn, 16);
            };
        } else {
          // if not available, all you get is immediate calls
          raf = function raf(cb) {
            cb();
          };
        }

        module.exports = raf;

        /***/
      },
      /* 5 */
      /***/ function (module, exports) {
        module.exports = __WEBPACK_EXTERNAL_MODULE_5__;

        /***/
      },
      /******/
    ]
  );
});