|
(function webpackUniversalModuleDefinition(root, factory) { |
|
if(typeof exports === 'object' && typeof module === 'object') |
|
module.exports = factory(); |
|
else if(typeof define === 'function' && define.amd) |
|
define([], factory); |
|
else if(typeof exports === 'object') |
|
exports["labella"] = factory(); |
|
else |
|
root["labella"] = factory(); |
|
})(this, function() { |
|
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] = { |
|
/******/ exports: {}, |
|
/******/ id: moduleId, |
|
/******/ loaded: false |
|
/******/ }; |
|
|
|
/******/ // Execute the module function |
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); |
|
|
|
/******/ // Flag the module as loaded |
|
/******/ module.loaded = 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; |
|
|
|
/******/ // __webpack_public_path__ |
|
/******/ __webpack_require__.p = ""; |
|
|
|
/******/ // Load entry module and return exports |
|
/******/ return __webpack_require__(0); |
|
/******/ }) |
|
/************************************************************************/ |
|
/******/ ([ |
|
/* 0 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
/* |
|
Copyright 2015 Twitter, Inc. |
|
Licensed under the Apache License, Version 2.0 |
|
http://www.apache.org/licenses/LICENSE-2.0 |
|
*/ |
|
|
|
module.exports = { |
|
Node: __webpack_require__(1), |
|
Force: __webpack_require__(2), |
|
Distributor: __webpack_require__(3), |
|
Renderer: __webpack_require__(10) |
|
}; |
|
|
|
/***/ }, |
|
/* 1 */ |
|
/***/ function(module, exports) { |
|
|
|
'use strict'; |
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
var Node = function () { |
|
function Node(idealPos, width, data) { |
|
_classCallCheck(this, Node); |
|
|
|
this.idealPos = idealPos; |
|
this.currentPos = idealPos; |
|
this.width = width; |
|
this.data = data; |
|
this.layerIndex = 0; |
|
} |
|
|
|
// return negative if overlap |
|
|
|
_createClass(Node, [{ |
|
key: 'distanceFrom', |
|
value: function distanceFrom(node) { |
|
var halfWidth = this.width / 2; |
|
var nodeHalfWidth = node.width / 2; |
|
// max(a[0], b[0]) - min(a[1], b[1]) |
|
return Math.max(this.currentPos - halfWidth, node.currentPos - nodeHalfWidth) - Math.min(this.currentPos + halfWidth, node.currentPos + nodeHalfWidth); |
|
} |
|
}, { |
|
key: 'moveToIdealPosition', |
|
value: function moveToIdealPosition() { |
|
this.currentPos = this.idealPos; |
|
return this; |
|
} |
|
}, { |
|
key: 'displacement', |
|
value: function displacement() { |
|
return this.idealPos - this.currentPos; |
|
} |
|
}, { |
|
key: 'overlapWithNode', |
|
value: function overlapWithNode(node) { |
|
var buffer = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1]; |
|
|
|
return this.distanceFrom(node) - buffer < 0; |
|
} |
|
}, { |
|
key: 'overlapWithPoint', |
|
value: function overlapWithPoint(pos) { |
|
var halfWidth = this.width / 2; |
|
return pos >= this.currentPos - halfWidth && pos <= this.currentPos + halfWidth; |
|
} |
|
}, { |
|
key: 'positionBefore', |
|
value: function positionBefore(node) { |
|
var buffer = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1]; |
|
|
|
return node.currentLeft() - this.width / 2 - buffer; |
|
} |
|
}, { |
|
key: 'positionAfter', |
|
value: function positionAfter(node) { |
|
var buffer = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1]; |
|
|
|
return node.currentRight() + this.width / 2 + buffer; |
|
} |
|
}, { |
|
key: 'currentRight', |
|
value: function currentRight() { |
|
return this.currentPos + this.width / 2; |
|
} |
|
}, { |
|
key: 'currentLeft', |
|
value: function currentLeft() { |
|
return this.currentPos - this.width / 2; |
|
} |
|
}, { |
|
key: 'idealRight', |
|
value: function idealRight() { |
|
return this.idealPos + this.width / 2; |
|
} |
|
}, { |
|
key: 'idealLeft', |
|
value: function idealLeft() { |
|
return this.idealPos - this.width / 2; |
|
} |
|
}, { |
|
key: 'createStub', |
|
value: function createStub(width) { |
|
var stub = new Node(this.idealPos, width, this.data); |
|
stub.currentPos = this.currentPos; |
|
stub.child = this; |
|
this.parent = stub; |
|
return stub; |
|
} |
|
}, { |
|
key: 'removeStub', |
|
value: function removeStub() { |
|
if (this.parent) { |
|
this.parent.child = null; |
|
this.parent = null; |
|
} |
|
return this; |
|
} |
|
}, { |
|
key: 'isStub', |
|
value: function isStub() { |
|
return !!this.child; |
|
} |
|
}, { |
|
key: 'getPathToRoot', |
|
value: function getPathToRoot() { |
|
var path = []; |
|
var current = this; |
|
while (current) { |
|
path.push(current); |
|
current = current.parent; |
|
} |
|
return path; |
|
} |
|
}, { |
|
key: 'getPathFromRoot', |
|
value: function getPathFromRoot() { |
|
return this.getPathToRoot().reverse(); |
|
} |
|
}, { |
|
key: 'getPathToRootLength', |
|
value: function getPathToRootLength() { |
|
var length = 0; |
|
var current = this; |
|
while (current) { |
|
var targetPos = current.parent ? current.parent.currentPos : current.idealPos; |
|
length += Math.abs(current.currentPos - targetPos); |
|
current = current.parent; |
|
} |
|
|
|
return length; |
|
} |
|
|
|
// Trace back to the node without parent |
|
|
|
}, { |
|
key: 'getRoot', |
|
value: function getRoot() { |
|
var previous = this; |
|
var current = this; |
|
while (current) { |
|
previous = current; |
|
current = current.parent; |
|
} |
|
return previous; |
|
} |
|
}, { |
|
key: 'getLayerIndex', |
|
value: function getLayerIndex() { |
|
return this.layerIndex; |
|
} |
|
}, { |
|
key: 'clone', |
|
value: function clone() { |
|
var node = new Node(this.idealPos, this.width, this.data); |
|
node.currentPos = this.currentPos; |
|
node.layerIndex = this.layerIndex; |
|
return node; |
|
} |
|
}]); |
|
|
|
return Node; |
|
}(); |
|
|
|
module.exports = Node; |
|
|
|
/***/ }, |
|
/* 2 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var Distributor = __webpack_require__(3); |
|
var helper = __webpack_require__(4); |
|
var removeOverlap = __webpack_require__(8); |
|
|
|
var DEFAULT_OPTIONS = { |
|
nodeSpacing: 3, |
|
minPos: 0, |
|
maxPos: null, |
|
|
|
algorithm: 'overlap', |
|
removeOverlap: true, |
|
density: 0.85, |
|
stubWidth: 1 |
|
}; |
|
|
|
var Force = function Force(_options) { |
|
var force = {}; |
|
var options = helper.extend({}, DEFAULT_OPTIONS); |
|
var distributor = new Distributor(); |
|
var nodes = []; |
|
var layers = null; |
|
|
|
force.nodes = function (x) { |
|
if (!arguments.length) return nodes; |
|
nodes = x; |
|
layers = [x]; |
|
return force; |
|
}; |
|
|
|
force.getLayers = function () { |
|
return layers; |
|
}; |
|
|
|
force.options = function (x) { |
|
if (!arguments.length) return options; |
|
options = helper.extend(options, x); |
|
|
|
var disOptions = helper.pick(options, Object.keys(Distributor.DEFAULT_OPTIONS)); |
|
if (helper.isDefined(options.minPos) && helper.isDefined(options.maxPos)) { |
|
disOptions.layerWidth = options.maxPos - options.minPos; |
|
} else { |
|
disOptions.layerWidth = null; |
|
} |
|
distributor.options(disOptions); |
|
|
|
return force; |
|
}; |
|
|
|
force.options(_options); |
|
|
|
force.compute = function () { |
|
var overlapOptions = helper.pick(options, Object.keys(removeOverlap.DEFAULT_OPTIONS)); |
|
|
|
nodes.forEach(function (node) { |
|
node.removeStub(); |
|
}); |
|
|
|
layers = distributor.distribute(nodes); |
|
layers.map(function (nodes, layerIndex) { |
|
nodes.forEach(function (node) { |
|
node.layerIndex = layerIndex; |
|
}); |
|
if (options.removeOverlap) { |
|
removeOverlap(nodes, overlapOptions); |
|
} |
|
}); |
|
|
|
return force; |
|
}; |
|
|
|
force.start = function () { |
|
console.log('[warning] force.start() is deprecated. Please use force.compute() instead.'); |
|
}; |
|
|
|
return force; |
|
}; |
|
|
|
Force.DEFAULT_OPTIONS = DEFAULT_OPTIONS; |
|
|
|
module.exports = Force; |
|
|
|
/***/ }, |
|
/* 3 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var helper = __webpack_require__(4); |
|
var IntervalTree = __webpack_require__(6); |
|
|
|
var DEFAULT_OPTIONS = { |
|
algorithm: 'overlap', |
|
layerWidth: 1000, |
|
density: 0.75, |
|
nodeSpacing: 3, |
|
stubWidth: 1 |
|
}; |
|
|
|
var Distributor = function Distributor(options) { |
|
var distributor = {}; |
|
|
|
options = helper.extend({}, DEFAULT_OPTIONS, options); |
|
|
|
distributor.options = function (x) { |
|
if (!arguments.length) return options; |
|
options = helper.extend(options, x); |
|
return distributor; |
|
}; |
|
|
|
distributor.computeRequiredWidth = function (nodes) { |
|
return helper.sum(nodes, function (d) { |
|
return d.width + options.nodeSpacing; |
|
}) - options.nodeSpacing; |
|
}; |
|
|
|
distributor.maxWidthPerLayer = function () { |
|
return options.density * options.layerWidth; |
|
}; |
|
|
|
distributor.needToSplit = function (nodes) { |
|
return distributor.estimateRequiredLayers(nodes) > 1; |
|
}; |
|
|
|
distributor.estimateRequiredLayers = function (nodes) { |
|
return options.layerWidth ? Math.ceil(distributor.computeRequiredWidth(nodes) / distributor.maxWidthPerLayer()) : 1; |
|
}; |
|
|
|
var algorithms = { |
|
simple: function simple(nodes) { |
|
var numLayers = distributor.estimateRequiredLayers(nodes); |
|
|
|
var layers = []; |
|
for (var i = 0; i < numLayers; i++) { |
|
layers.push([]); |
|
} |
|
|
|
nodes.forEach(function (node, i) { |
|
var mod = i % numLayers; |
|
layers[mod].push(node); |
|
|
|
var stub = node; |
|
for (var j = mod - 1; j >= 0; j--) { |
|
stub = stub.createStub(options.stubWidth); |
|
layers[j].push(stub); |
|
} |
|
}); |
|
|
|
return layers; |
|
}, |
|
roundRobin: function roundRobin(nodes) { |
|
var layers = []; |
|
|
|
return layers; |
|
}, |
|
overlap: function overlap(nodes) { |
|
var layers = []; |
|
var maxWidth = distributor.maxWidthPerLayer(); |
|
|
|
var puntedNodes = nodes.concat(); |
|
var puntedWidth = distributor.computeRequiredWidth(puntedNodes); |
|
|
|
while (puntedWidth > maxWidth) { |
|
distributor.countIdealOverlaps(puntedNodes); |
|
|
|
var nodesInCurrentLayer = puntedNodes.concat(); |
|
var currentlayerWidth = puntedWidth; |
|
puntedNodes = []; |
|
|
|
while (nodesInCurrentLayer.length > 2 && currentlayerWidth > maxWidth) { |
|
// Sort by overlaps |
|
nodesInCurrentLayer.sort(function (a, b) { |
|
return b.overlapCount - a.overlapCount; |
|
}); |
|
|
|
// Remove the node with most overlap |
|
var first = nodesInCurrentLayer.shift(); |
|
|
|
// Update width |
|
currentlayerWidth -= first.width; |
|
currentlayerWidth += options.stubWidth; |
|
|
|
// Update overlap count for the remaining nodes |
|
first.overlaps.forEach(function (node) { |
|
node.overlapCount--; |
|
}); |
|
|
|
// Add removed node to the next layer |
|
puntedNodes.push(first); |
|
} |
|
|
|
layers.push(nodesInCurrentLayer); |
|
|
|
puntedWidth = distributor.computeRequiredWidth(puntedNodes); |
|
} |
|
|
|
if (puntedNodes.length > 0) { |
|
layers.push(puntedNodes); |
|
} |
|
|
|
// Create stubs |
|
// From last layer |
|
for (var i = layers.length - 1; i >= 1; i--) { |
|
var layer = layers[i]; |
|
// For each node in the layer |
|
for (var k = 0; k < layer.length; k++) { |
|
var node = layer[k]; |
|
// If it is not a stub |
|
if (node.isStub()) continue; |
|
// Create one stub for each layer above it |
|
var stub = node; |
|
for (var j = i - 1; j >= 0; j--) { |
|
stub = stub.createStub(options.stubWidth); |
|
layers[j].push(stub); |
|
} |
|
} |
|
} |
|
|
|
return layers; |
|
} |
|
}; |
|
|
|
distributor.countIdealOverlaps = function (nodes) { |
|
var iTree = new IntervalTree(options.layerWidth / 2); |
|
nodes.forEach(function (node) { |
|
iTree.add([node.idealLeft(), node.idealRight(), node]); |
|
}); |
|
|
|
nodes.forEach(function (node) { |
|
var overlaps = iTree.search(node.idealLeft(), node.idealRight()); |
|
node.overlaps = overlaps.map(function (x) { |
|
return x.data[2]; |
|
}); |
|
node.overlapCount = overlaps.length; |
|
}); |
|
|
|
return nodes; |
|
}; |
|
|
|
distributor.distribute = function (nodes) { |
|
if (!nodes || nodes.length === 0) return []; |
|
|
|
if (options.algorithm == 'none' || !helper.isDefined(options.algorithm)) { |
|
return [nodes]; |
|
} |
|
|
|
if (!distributor.needToSplit(nodes)) { |
|
return [nodes]; |
|
} |
|
|
|
nodes = nodes.concat().sort(function (a, b) { |
|
return a.idealPos - b.idealPos; |
|
}); |
|
|
|
if (typeof options.algorithm == 'function') { |
|
return options.algorithm(nodes, options); |
|
} else if (algorithms.hasOwnProperty(options.algorithm)) { |
|
return algorithms[options.algorithm](nodes); |
|
} else { |
|
throw 'Unknown algorithm: ' + options.algorithm; |
|
} |
|
}; |
|
|
|
return distributor; |
|
}; |
|
|
|
Distributor.DEFAULT_OPTIONS = DEFAULT_OPTIONS; |
|
|
|
// return module |
|
module.exports = Distributor; |
|
|
|
/***/ }, |
|
/* 4 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var helper = { |
|
isDefined: function isDefined(x) { |
|
return x !== null && x !== undefined; |
|
}, |
|
last: function last(array) { |
|
return array.length > 0 ? array[array.length - 1] : null; |
|
}, |
|
pick: function pick(object, keys) { |
|
return keys.reduce(function (prev, key) { |
|
prev[key] = object[key]; |
|
return prev; |
|
}, {}); |
|
}, |
|
sum: function sum(array, accessor) { |
|
return array.map(accessor).reduce(function (prev, current) { |
|
return prev + current; |
|
}, 0); |
|
} |
|
}; |
|
|
|
helper.extend = __webpack_require__(5); |
|
|
|
module.exports = helper; |
|
|
|
/***/ }, |
|
/* 5 */ |
|
/***/ function(module, exports) { |
|
|
|
'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 ? "symbol" : typeof obj; }; |
|
|
|
/* |
|
This file is modified from https://github.com/justmoon/node-extend |
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2014 Stefan Thomas |
|
|
|
Permission is hereby granted, free of charge, to any person obtaining |
|
a copy of this software and associated documentation files (the |
|
"Software"), to deal in the Software without restriction, including |
|
without limitation the rights to use, copy, modify, merge, publish, |
|
distribute, sublicense, and/or sell copies of the Software, and to |
|
permit persons to whom the Software is furnished to do so, subject to |
|
the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE |
|
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION |
|
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
|
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
*/ |
|
|
|
var hasOwn = Object.prototype.hasOwnProperty; |
|
var toStr = Object.prototype.toString; |
|
|
|
var isArray = function isArray(arr) { |
|
if (typeof Array.isArray === 'function') { |
|
return Array.isArray(arr); |
|
} |
|
|
|
return toStr.call(arr) === '[object Array]'; |
|
}; |
|
|
|
var isPlainObject = function isPlainObject(obj) { |
|
'use strict'; |
|
|
|
if (!obj || toStr.call(obj) !== '[object Object]') { |
|
return false; |
|
} |
|
|
|
var has_own_constructor = hasOwn.call(obj, 'constructor'); |
|
var has_is_property_of_method = obj.constructor && obj.constructor.prototype && hasOwn.call(obj.constructor.prototype, 'isPrototypeOf'); |
|
// Not own constructor property must be Object |
|
if (obj.constructor && !has_own_constructor && !has_is_property_of_method) { |
|
return false; |
|
} |
|
|
|
// Own properties are enumerated firstly, so to speed up, |
|
// if last one is own, then all properties are own. |
|
var key; |
|
for (key in obj) {} |
|
|
|
return key === undefined || hasOwn.call(obj, key); |
|
}; |
|
|
|
module.exports = function extend() { |
|
'use strict'; |
|
|
|
var options, |
|
name, |
|
src, |
|
copy, |
|
copyIsArray, |
|
clone, |
|
target = arguments[0], |
|
i = 1, |
|
length = arguments.length, |
|
deep = false; |
|
|
|
// Handle a deep copy situation |
|
if (typeof target === 'boolean') { |
|
deep = target; |
|
target = arguments[1] || {}; |
|
// skip the boolean and the target |
|
i = 2; |
|
} else if ((typeof target === 'undefined' ? 'undefined' : _typeof(target)) !== 'object' && typeof target !== 'function' || target == null) { |
|
target = {}; |
|
} |
|
|
|
for (; i < length; ++i) { |
|
options = arguments[i]; |
|
// Only deal with non-null/undefined values |
|
if (options != null) { |
|
// Extend the base object |
|
for (name in options) { |
|
src = target[name]; |
|
copy = options[name]; |
|
|
|
// Prevent never-ending loop |
|
if (target === copy) { |
|
continue; |
|
} |
|
|
|
// Recurse if we're merging plain objects or arrays |
|
if (deep && copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) { |
|
if (copyIsArray) { |
|
copyIsArray = false; |
|
clone = src && isArray(src) ? src : []; |
|
} else { |
|
clone = src && isPlainObject(src) ? src : {}; |
|
} |
|
|
|
// Never move original objects, clone them |
|
target[name] = extend(deep, clone, copy); |
|
|
|
// Don't bring in undefined values |
|
} else if (copy !== undefined) { |
|
target[name] = copy; |
|
} |
|
} |
|
} |
|
} |
|
|
|
// Return the modified object |
|
return target; |
|
}; |
|
|
|
/***/ }, |
|
/* 6 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
/* |
|
This file is modified from https://github.com/shinout/interval-tree |
|
|
|
(The MIT License) |
|
|
|
Copyright (c) 2012 SHIN Suzuki <shinout310@gmail.com> |
|
|
|
Permission is hereby granted, free of charge, to any person obtaining |
|
a copy of this software and associated documentation files (the |
|
'Software'), to deal in the Software without restriction, including |
|
without limitation the rights to use, copy, modify, merge, publish, |
|
distribute, sublicense, and/or sell copies of the Software, and to |
|
permit persons to whom the Software is furnished to do so, subject to |
|
the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
|
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
|
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
|
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
*/ |
|
|
|
var SortedList = __webpack_require__(7); |
|
|
|
/** |
|
* IntervalTree |
|
* |
|
* @param (object) data: |
|
* @param (number) center: |
|
* @param (object) options: |
|
* center: |
|
* |
|
**/ |
|
function IntervalTree(center, options) { |
|
options || (options = {}); |
|
|
|
this.startKey = options.startKey || 0; // start key |
|
this.endKey = options.endKey || 1; // end key |
|
this.intervalHash = {}; // id => interval object |
|
this.pointTree = new SortedList({ // b-tree of start, end points |
|
compare: function compare(a, b) { |
|
if (a == null) return -1; |
|
if (b == null) return 1; |
|
var c = a[0] - b[0]; |
|
return c > 0 ? 1 : c == 0 ? 0 : -1; |
|
} |
|
}); |
|
|
|
this._autoIncrement = 0; |
|
|
|
// index of the root node |
|
if (!center || typeof center != 'number') { |
|
throw new Error('you must specify center index as the 2nd argument.'); |
|
} |
|
|
|
this.root = new Node(center, this); |
|
} |
|
|
|
/** |
|
* publid methods |
|
**/ |
|
|
|
/** |
|
* add new range |
|
**/ |
|
IntervalTree.prototype.add = function (data, id) { |
|
if (this.intervalHash[id]) { |
|
throw new Error('id ' + id + ' is already registered.'); |
|
} |
|
|
|
if (id == undefined) { |
|
while (this.intervalHash[this._autoIncrement]) { |
|
this._autoIncrement++; |
|
} |
|
id = this._autoIncrement; |
|
} |
|
|
|
var itvl = new Interval(data, id, this.startKey, this.endKey); |
|
this.pointTree.insert([itvl.start, id]); |
|
this.pointTree.insert([itvl.end, id]); |
|
this.intervalHash[id] = itvl; |
|
this._autoIncrement++; |
|
_insert.call(this, this.root, itvl); |
|
}; |
|
|
|
/** |
|
* search |
|
* |
|
* @param (integer) val: |
|
* @return (array) |
|
**/ |
|
IntervalTree.prototype.search = function (val1, val2) { |
|
var ret = []; |
|
if (typeof val1 != 'number') { |
|
throw new Error(val1 + ': invalid input'); |
|
} |
|
|
|
if (val2 == undefined) { |
|
_pointSearch.call(this, this.root, val1, ret); |
|
} else if (typeof val2 == 'number') { |
|
_rangeSearch.call(this, val1, val2, ret); |
|
} else { |
|
throw new Error(val1 + ',' + val2 + ': invalid input'); |
|
} |
|
return ret; |
|
}; |
|
|
|
/** |
|
* remove: |
|
**/ |
|
IntervalTree.prototype.remove = function (interval_id) {}; |
|
|
|
/** |
|
* private methods |
|
**/ |
|
|
|
/** |
|
* _insert |
|
**/ |
|
function _insert(node, itvl) { |
|
if (itvl.end < node.idx) { |
|
if (!node.left) { |
|
node.left = new Node(itvl.start + itvl.end >> 1, this); |
|
} |
|
return _insert.call(this, node.left, itvl); |
|
} |
|
|
|
if (node.idx < itvl.start) { |
|
if (!node.right) { |
|
node.right = new Node(itvl.start + itvl.end >> 1, this); |
|
} |
|
return _insert.call(this, node.right, itvl); |
|
} |
|
return node.insert(itvl); |
|
} |
|
|
|
/** |
|
* _pointSearch |
|
* @param (Node) node |
|
* @param (integer) idx |
|
* @param (Array) arr |
|
**/ |
|
function _pointSearch(node, idx, arr) { |
|
if (!node) return; |
|
|
|
if (idx < node.idx) { |
|
node.starts.every(function (itvl) { |
|
var bool = itvl.start <= idx; |
|
if (bool) arr.push(itvl.result()); |
|
return bool; |
|
}); |
|
return _pointSearch.call(this, node.left, idx, arr); |
|
} else if (idx > node.idx) { |
|
node.ends.every(function (itvl) { |
|
var bool = itvl.end >= idx; |
|
if (bool) arr.push(itvl.result()); |
|
return bool; |
|
}); |
|
return _pointSearch.call(this, node.right, idx, arr); |
|
} |
|
// exact equal |
|
else { |
|
node.starts.map(function (itvl) { |
|
arr.push(itvl.result()); |
|
}); |
|
} |
|
} |
|
|
|
/** |
|
* _rangeSearch |
|
* @param (integer) start |
|
* @param (integer) end |
|
* @param (Array) arr |
|
**/ |
|
function _rangeSearch(start, end, arr) { |
|
if (end - start <= 0) { |
|
throw new Error('end must be greater than start. start: ' + start + ', end: ' + end); |
|
} |
|
var resultHash = {}; |
|
|
|
var wholeWraps = []; |
|
_pointSearch.call(this, this.root, start + end >> 1, wholeWraps, true); |
|
|
|
wholeWraps.forEach(function (result) { |
|
resultHash[result.id] = true; |
|
}); |
|
|
|
var idx1 = this.pointTree.bsearch([start, null]); |
|
var pointTreeArray = this.pointTree; |
|
while (idx1 >= 0 && pointTreeArray[idx1][0] == start) { |
|
idx1--; |
|
} |
|
|
|
var idx2 = this.pointTree.bsearch([end, null]); |
|
if (idx2 >= 0) { |
|
var len = pointTreeArray.length - 1; |
|
while (idx2 <= len && pointTreeArray[idx2][0] <= end) { |
|
idx2++; |
|
} |
|
|
|
pointTreeArray.slice(idx1 + 1, idx2).forEach(function (point) { |
|
var id = point[1]; |
|
resultHash[id] = true; |
|
}, this); |
|
|
|
Object.keys(resultHash).forEach(function (id) { |
|
var itvl = this.intervalHash[id]; |
|
arr.push(itvl.result(start, end)); |
|
}, this); |
|
} |
|
} |
|
|
|
/** |
|
* subclasses |
|
* |
|
**/ |
|
|
|
/** |
|
* Node : prototype of each node in a interval tree |
|
* |
|
**/ |
|
function Node(idx) { |
|
this.idx = idx; |
|
this.starts = new SortedList({ |
|
compare: function compare(a, b) { |
|
if (a == null) return -1; |
|
if (b == null) return 1; |
|
var c = a.start - b.start; |
|
return c > 0 ? 1 : c == 0 ? 0 : -1; |
|
} |
|
}); |
|
|
|
this.ends = new SortedList({ |
|
compare: function compare(a, b) { |
|
if (a == null) return -1; |
|
if (b == null) return 1; |
|
var c = a.end - b.end; |
|
return c < 0 ? 1 : c == 0 ? 0 : -1; |
|
} |
|
}); |
|
} |
|
|
|
/** |
|
* insert an Interval object to this node |
|
**/ |
|
Node.prototype.insert = function (interval) { |
|
this.starts.insert(interval); |
|
this.ends.insert(interval); |
|
}; |
|
|
|
/** |
|
* Interval : prototype of interval info |
|
**/ |
|
function Interval(data, id, s, e) { |
|
this.id = id; |
|
this.start = data[s]; |
|
this.end = data[e]; |
|
this.data = data; |
|
|
|
if (typeof this.start != 'number' || typeof this.end != 'number') { |
|
throw new Error('start, end must be number. start: ' + this.start + ', end: ' + this.end); |
|
} |
|
|
|
if (this.start >= this.end) { |
|
throw new Error('start must be smaller than end. start: ' + this.start + ', end: ' + this.end); |
|
} |
|
} |
|
|
|
/** |
|
* get result object |
|
**/ |
|
Interval.prototype.result = function (start, end) { |
|
var ret = { |
|
id: this.id, |
|
data: this.data |
|
}; |
|
if (typeof start == 'number' && typeof end == 'number') { |
|
/** |
|
* calc overlapping rate |
|
**/ |
|
var left = Math.max(this.start, start); |
|
var right = Math.min(this.end, end); |
|
var lapLn = right - left; |
|
ret.rate1 = lapLn / (end - start); |
|
ret.rate2 = lapLn / (this.end - this.start); |
|
} |
|
return ret; |
|
}; |
|
|
|
module.exports = IntervalTree; |
|
|
|
/***/ }, |
|
/* 7 */ |
|
/***/ function(module, exports) { |
|
|
|
"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 ? "symbol" : typeof obj; }; |
|
|
|
/* |
|
This file is modified from https://github.com/shinout/SortedList |
|
|
|
(The MIT License) |
|
|
|
Copyright (c) 2012 SHIN Suzuki <shinout310@gmail.com> |
|
|
|
Permission is hereby granted, free of charge, to any person obtaining |
|
a copy of this software and associated documentation files (the |
|
'Software'), to deal in the Software without restriction, including |
|
without limitation the rights to use, copy, modify, merge, publish, |
|
distribute, sublicense, and/or sell copies of the Software, and to |
|
permit persons to whom the Software is furnished to do so, subject to |
|
the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be |
|
included in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, |
|
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
|
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
|
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
|
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
*/ |
|
|
|
var SortedList = function SortedList() { |
|
var arr = null, |
|
options = {}, |
|
args = arguments; |
|
|
|
["0", "1"].forEach(function (n) { |
|
var val = args[n]; |
|
if (Array.isArray(val)) { |
|
arr = val; |
|
} else if (val && (typeof val === "undefined" ? "undefined" : _typeof(val)) == "object") { |
|
options = val; |
|
} |
|
}); |
|
|
|
if (typeof options.filter == 'function') { |
|
this._filter = options.filter; |
|
} |
|
|
|
if (typeof options.compare == 'function') { |
|
this._compare = options.compare; |
|
} else if (typeof options.compare == 'string' && SortedList.compares[options.compare]) { |
|
this._compare = SortedList.compares[options.compare]; |
|
} |
|
|
|
this._unique = !!options.unique; |
|
|
|
if (options.resume && arr) { |
|
arr.forEach(function (v, i) { |
|
this.push(v); |
|
}, this); |
|
} else if (arr) this.insert.apply(this, arr); |
|
}; |
|
|
|
/** |
|
* SortedList.create(val1, val2) |
|
* creates an instance |
|
**/ |
|
SortedList.create = function (val1, val2) { |
|
return new SortedList(val1, val2); |
|
}; |
|
|
|
SortedList.prototype = new Array(); |
|
SortedList.prototype.constructor = Array.prototype.constructor; |
|
|
|
/** |
|
* sorted.insertOne(val) |
|
* insert one value |
|
* returns false if failed, inserted position if succeed |
|
**/ |
|
SortedList.prototype.insertOne = function (val) { |
|
var pos = this.bsearch(val); |
|
if (this._unique && this.key(val, pos) != null) return false; |
|
if (!this._filter(val, pos)) return false; |
|
this.splice(pos + 1, 0, val); |
|
return pos + 1; |
|
}; |
|
|
|
/** |
|
* sorted.insert(val1, val2, ...) |
|
* insert multi values |
|
* returns the list of the results of insertOne() |
|
**/ |
|
SortedList.prototype.insert = function () { |
|
return Array.prototype.map.call(arguments, function (val) { |
|
return this.insertOne(val); |
|
}, this); |
|
}; |
|
|
|
/** |
|
* sorted.remove(pos) |
|
* remove the value in the given position |
|
**/ |
|
SortedList.prototype.remove = function (pos) { |
|
this.splice(pos, 1); |
|
return this; |
|
}; |
|
|
|
/** |
|
* sorted.bsearch(val) |
|
* @returns position of the value |
|
**/ |
|
SortedList.prototype.bsearch = function (val) { |
|
if (!this.length) return -1; |
|
var mpos, |
|
spos = 0, |
|
epos = this.length; |
|
while (epos - spos > 1) { |
|
mpos = Math.floor((spos + epos) / 2); |
|
var mval = this[mpos]; |
|
var comp = this._compare(val, mval); |
|
if (comp == 0) return mpos; |
|
if (comp > 0) spos = mpos;else epos = mpos; |
|
} |
|
return spos == 0 && this._compare(this[0], val) > 0 ? -1 : spos; |
|
}; |
|
|
|
/** |
|
* sorted.key(val) |
|
* @returns first index if exists, null if not |
|
**/ |
|
SortedList.prototype.key = function (val, bsResult) { |
|
if (bsResult == null) bsResult = this.bsearch(val); |
|
var pos = bsResult; |
|
if (pos == -1 || this._compare(this[pos], val) < 0) return pos + 1 < this.length && this._compare(this[pos + 1], val) == 0 ? pos + 1 : null; |
|
while (pos >= 1 && this._compare(this[pos - 1], val) == 0) { |
|
pos--; |
|
}return pos; |
|
}; |
|
|
|
/** |
|
* sorted.key(val) |
|
* @returns indexes if exists, null if not |
|
**/ |
|
SortedList.prototype.keys = function (val, bsResult) { |
|
var ret = []; |
|
if (bsResult == null) bsResult = this.bsearch(val); |
|
var pos = bsResult; |
|
while (pos >= 0 && this._compare(this[pos], val) == 0) { |
|
ret.push(pos); |
|
pos--; |
|
} |
|
|
|
var len = this.length; |
|
pos = bsResult + 1; |
|
while (pos < len && this._compare(this[pos], val) == 0) { |
|
ret.push(pos); |
|
pos++; |
|
} |
|
return ret.length ? ret : null; |
|
}; |
|
|
|
/** |
|
* sorted.unique() |
|
* @param createNew : create new instance |
|
* @returns first index if exists, null if not |
|
**/ |
|
SortedList.prototype.unique = function (createNew) { |
|
if (createNew) return this.filter(function (v, k) { |
|
return k == 0 || this._compare(this[k - 1], v) != 0; |
|
}, this); |
|
var total = 0; |
|
this.map(function (v, k) { |
|
if (k == 0 || this._compare(this[k - 1], v) != 0) return null; |
|
return k - total++; |
|
}, this).forEach(function (k) { |
|
if (k != null) this.remove(k); |
|
}, this); |
|
return this; |
|
}; |
|
|
|
/** |
|
* sorted.toArray() |
|
* get raw array |
|
**/ |
|
SortedList.prototype.toArray = function () { |
|
return this.slice(); |
|
}; |
|
|
|
/** |
|
* default filtration function |
|
**/ |
|
SortedList.prototype._filter = function (val, pos) { |
|
return true; |
|
}; |
|
|
|
/** |
|
* comparison functions |
|
**/ |
|
SortedList.compares = { |
|
"number": function number(a, b) { |
|
var c = a - b; |
|
return c > 0 ? 1 : c == 0 ? 0 : -1; |
|
}, |
|
|
|
"string": function string(a, b) { |
|
return a > b ? 1 : a == b ? 0 : -1; |
|
} |
|
}; |
|
|
|
/** |
|
* sorted.compare(a, b) |
|
* default comparison function |
|
**/ |
|
SortedList.prototype._compare = SortedList.compares["string"]; |
|
|
|
module.exports = SortedList; |
|
|
|
/***/ }, |
|
/* 8 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var helper = __webpack_require__(4); |
|
var vpsc = __webpack_require__(9); |
|
|
|
var DEFAULT_OPTIONS = { |
|
lineSpacing: 2, |
|
nodeSpacing: 3, |
|
minPos: 0, |
|
maxPos: null |
|
}; |
|
|
|
function nodeToVariable(node) { |
|
var v = new vpsc.Variable(node.targetPos); |
|
v.node = node; |
|
return v; |
|
} |
|
|
|
function removeOverlap(nodes, options) { |
|
if (nodes.length > 0) { |
|
options = helper.extend(DEFAULT_OPTIONS, options); |
|
|
|
// For nodes with stub, set target position to stub's current position |
|
nodes.forEach(function (node, index) { |
|
node.targetPos = node.parent ? node.parent.currentPos : node.idealPos; |
|
node.index = index; |
|
}); |
|
|
|
nodes.sort(function (a, b) { |
|
var diff = a.targetPos - b.targetPos; |
|
if (diff !== 0) return diff; |
|
var diff2 = a.isStub() - b.isStub(); |
|
if (diff2 !== 0) return diff2; |
|
// If same position, use original order |
|
return a.index - b.index; |
|
}); |
|
|
|
var variables = nodes.map(nodeToVariable); |
|
|
|
var constraints = []; |
|
for (var i = 1; i < variables.length; i++) { |
|
var v1 = variables[i - 1]; |
|
var v2 = variables[i]; |
|
|
|
var gap; |
|
if (v1.node.isStub() && v2.node.isStub()) { |
|
gap = (v1.node.width + v2.node.width) / 2 + options.lineSpacing; |
|
} else { |
|
gap = (v1.node.width + v2.node.width) / 2 + options.nodeSpacing; |
|
} |
|
constraints.push(new vpsc.Constraint(v1, v2, gap)); |
|
} |
|
|
|
if (helper.isDefined(options.minPos)) { |
|
var leftWall = new vpsc.Variable(options.minPos, 1e10); |
|
var v = variables[0]; |
|
constraints.push(new vpsc.Constraint(leftWall, v, v.node.width / 2)); |
|
variables.unshift(leftWall); |
|
} |
|
|
|
if (helper.isDefined(options.maxPos)) { |
|
var rightWall = new vpsc.Variable(options.maxPos, 1e10); |
|
var lastv = helper.last(variables); |
|
constraints.push(new vpsc.Constraint(lastv, rightWall, lastv.node.width / 2)); |
|
variables.push(rightWall); |
|
} |
|
|
|
new vpsc.Solver(variables, constraints).solve(); |
|
|
|
variables.filter(function (v) { |
|
return v.node; |
|
}).map(function (v) { |
|
v.node.currentPos = Math.round(v.position()); |
|
return v; |
|
}); |
|
} |
|
|
|
return nodes; |
|
} |
|
|
|
removeOverlap.DEFAULT_OPTIONS = DEFAULT_OPTIONS; |
|
|
|
module.exports = removeOverlap; |
|
|
|
/***/ }, |
|
/* 9 */ |
|
/***/ function(module, exports) { |
|
|
|
"use strict"; |
|
|
|
/* |
|
This file is compiled from https://github.com/tgdwyer/WebCola/blob/master/WebCola/src/vpsc.ts |
|
and modified slightly. |
|
|
|
The MIT License (MIT) |
|
|
|
Copyright (c) 2013 Tim Dwyer |
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy |
|
of this software and associated documentation files (the "Software"), to deal |
|
in the Software without restriction, including without limitation the rights |
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|
copies of the Software, and to permit persons to whom the Software is |
|
furnished to do so, subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be included in all |
|
copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|
SOFTWARE. |
|
*/ |
|
|
|
var vpsc = {}; |
|
|
|
var PositionStats = function () { |
|
function PositionStats(scale) { |
|
this.scale = scale; |
|
this.AB = 0; |
|
this.AD = 0; |
|
this.A2 = 0; |
|
} |
|
PositionStats.prototype.addVariable = function (v) { |
|
var ai = this.scale / v.scale; |
|
var bi = v.offset / v.scale; |
|
var wi = v.weight; |
|
this.AB += wi * ai * bi; |
|
this.AD += wi * ai * v.desiredPosition; |
|
this.A2 += wi * ai * ai; |
|
}; |
|
PositionStats.prototype.getPosn = function () { |
|
return (this.AD - this.AB) / this.A2; |
|
}; |
|
return PositionStats; |
|
}(); |
|
vpsc.PositionStats = PositionStats; |
|
var Constraint = function () { |
|
function Constraint(left, right, gap, equality) { |
|
if (equality === void 0) { |
|
equality = false; |
|
} |
|
this.left = left; |
|
this.right = right; |
|
this.gap = gap; |
|
this.equality = equality; |
|
this.active = false; |
|
this.unsatisfiable = false; |
|
this.left = left; |
|
this.right = right; |
|
this.gap = gap; |
|
this.equality = equality; |
|
} |
|
Constraint.prototype.slack = function () { |
|
return this.unsatisfiable ? Number.MAX_VALUE : this.right.scale * this.right.position() - this.gap - this.left.scale * this.left.position(); |
|
}; |
|
return Constraint; |
|
}(); |
|
vpsc.Constraint = Constraint; |
|
var Variable = function () { |
|
function Variable(desiredPosition, weight, scale) { |
|
if (weight === void 0) { |
|
weight = 1; |
|
} |
|
if (scale === void 0) { |
|
scale = 1; |
|
} |
|
this.desiredPosition = desiredPosition; |
|
this.weight = weight; |
|
this.scale = scale; |
|
this.offset = 0; |
|
} |
|
Variable.prototype.dfdv = function () { |
|
return 2.0 * this.weight * (this.position() - this.desiredPosition); |
|
}; |
|
Variable.prototype.position = function () { |
|
return (this.block.ps.scale * this.block.posn + this.offset) / this.scale; |
|
}; |
|
// visit neighbours by active constraints within the same block |
|
Variable.prototype.visitNeighbours = function (prev, f) { |
|
var ff = function ff(c, next) { |
|
return c.active && prev !== next && f(c, next); |
|
}; |
|
this.cOut.forEach(function (c) { |
|
return ff(c, c.right); |
|
}); |
|
this.cIn.forEach(function (c) { |
|
return ff(c, c.left); |
|
}); |
|
}; |
|
return Variable; |
|
}(); |
|
vpsc.Variable = Variable; |
|
var Block = function () { |
|
function Block(v) { |
|
this.vars = []; |
|
v.offset = 0; |
|
this.ps = new PositionStats(v.scale); |
|
this.addVariable(v); |
|
} |
|
Block.prototype.addVariable = function (v) { |
|
v.block = this; |
|
this.vars.push(v); |
|
this.ps.addVariable(v); |
|
this.posn = this.ps.getPosn(); |
|
}; |
|
// move the block where it needs to be to minimize cost |
|
Block.prototype.updateWeightedPosition = function () { |
|
this.ps.AB = this.ps.AD = this.ps.A2 = 0; |
|
for (var i = 0, n = this.vars.length; i < n; ++i) { |
|
this.ps.addVariable(this.vars[i]); |
|
}this.posn = this.ps.getPosn(); |
|
}; |
|
Block.prototype.compute_lm = function (v, u, postAction) { |
|
var _this = this; |
|
var dfdv = v.dfdv(); |
|
v.visitNeighbours(u, function (c, next) { |
|
var _dfdv = _this.compute_lm(next, v, postAction); |
|
if (next === c.right) { |
|
dfdv += _dfdv * c.left.scale; |
|
c.lm = _dfdv; |
|
} else { |
|
dfdv += _dfdv * c.right.scale; |
|
c.lm = -_dfdv; |
|
} |
|
postAction(c); |
|
}); |
|
return dfdv / v.scale; |
|
}; |
|
Block.prototype.populateSplitBlock = function (v, prev) { |
|
var _this = this; |
|
v.visitNeighbours(prev, function (c, next) { |
|
next.offset = v.offset + (next === c.right ? c.gap : -c.gap); |
|
_this.addVariable(next); |
|
_this.populateSplitBlock(next, v); |
|
}); |
|
}; |
|
// traverse the active constraint tree applying visit to each active constraint |
|
Block.prototype.traverse = function (visit, acc, v, prev) { |
|
var _this = this; |
|
if (v === void 0) { |
|
v = this.vars[0]; |
|
} |
|
if (prev === void 0) { |
|
prev = null; |
|
} |
|
v.visitNeighbours(prev, function (c, next) { |
|
acc.push(visit(c)); |
|
_this.traverse(visit, acc, next, v); |
|
}); |
|
}; |
|
// calculate lagrangian multipliers on constraints and |
|
// find the active constraint in this block with the smallest lagrangian. |
|
// if the lagrangian is negative, then the constraint is a split candidate. |
|
Block.prototype.findMinLM = function () { |
|
var m = null; |
|
this.compute_lm(this.vars[0], null, function (c) { |
|
if (!c.equality && (m === null || c.lm < m.lm)) m = c; |
|
}); |
|
return m; |
|
}; |
|
Block.prototype.findMinLMBetween = function (lv, rv) { |
|
this.compute_lm(lv, null, function () {}); |
|
var m = null; |
|
this.findPath(lv, null, rv, function (c, next) { |
|
if (!c.equality && c.right === next && (m === null || c.lm < m.lm)) m = c; |
|
}); |
|
return m; |
|
}; |
|
Block.prototype.findPath = function (v, prev, to, visit) { |
|
var _this = this; |
|
var endFound = false; |
|
v.visitNeighbours(prev, function (c, next) { |
|
if (!endFound && (next === to || _this.findPath(next, v, to, visit))) { |
|
endFound = true; |
|
visit(c, next); |
|
} |
|
}); |
|
return endFound; |
|
}; |
|
// Search active constraint tree from u to see if there is a directed path to v. |
|
// Returns true if path is found. |
|
Block.prototype.isActiveDirectedPathBetween = function (u, v) { |
|
if (u === v) return true; |
|
var i = u.cOut.length; |
|
while (i--) { |
|
var c = u.cOut[i]; |
|
if (c.active && this.isActiveDirectedPathBetween(c.right, v)) return true; |
|
} |
|
return false; |
|
}; |
|
// split the block into two by deactivating the specified constraint |
|
Block.split = function (c) { |
|
/* DEBUG |
|
console.log("split on " + c); |
|
console.assert(c.active, "attempt to split on inactive constraint"); |
|
DEBUG */ |
|
c.active = false; |
|
return [Block.createSplitBlock(c.left), Block.createSplitBlock(c.right)]; |
|
}; |
|
Block.createSplitBlock = function (startVar) { |
|
var b = new Block(startVar); |
|
b.populateSplitBlock(startVar, null); |
|
return b; |
|
}; |
|
// find a split point somewhere between the specified variables |
|
Block.prototype.splitBetween = function (vl, vr) { |
|
/* DEBUG |
|
console.assert(vl.block === this); |
|
console.assert(vr.block === this); |
|
DEBUG */ |
|
var c = this.findMinLMBetween(vl, vr); |
|
if (c !== null) { |
|
var bs = Block.split(c); |
|
return { constraint: c, lb: bs[0], rb: bs[1] }; |
|
} |
|
// couldn't find a split point - for example the active path is all equality constraints |
|
return null; |
|
}; |
|
Block.prototype.mergeAcross = function (b, c, dist) { |
|
c.active = true; |
|
for (var i = 0, n = b.vars.length; i < n; ++i) { |
|
var v = b.vars[i]; |
|
v.offset += dist; |
|
this.addVariable(v); |
|
} |
|
this.posn = this.ps.getPosn(); |
|
}; |
|
Block.prototype.cost = function () { |
|
var sum = 0, |
|
i = this.vars.length; |
|
while (i--) { |
|
var v = this.vars[i], |
|
d = v.position() - v.desiredPosition; |
|
sum += d * d * v.weight; |
|
} |
|
return sum; |
|
}; |
|
return Block; |
|
}(); |
|
vpsc.Block = Block; |
|
var Blocks = function () { |
|
function Blocks(vs) { |
|
this.vs = vs; |
|
var n = vs.length; |
|
this.list = new Array(n); |
|
while (n--) { |
|
var b = new Block(vs[n]); |
|
this.list[n] = b; |
|
b.blockInd = n; |
|
} |
|
} |
|
Blocks.prototype.cost = function () { |
|
var sum = 0, |
|
i = this.list.length; |
|
while (i--) { |
|
sum += this.list[i].cost(); |
|
}return sum; |
|
}; |
|
Blocks.prototype.insert = function (b) { |
|
/* DEBUG |
|
console.assert(!this.contains(b), "blocks error: tried to reinsert block " + b.blockInd) |
|
DEBUG */ |
|
b.blockInd = this.list.length; |
|
this.list.push(b); |
|
/* DEBUG |
|
console.log("insert block: " + b.blockInd); |
|
this.contains(b); |
|
DEBUG */ |
|
}; |
|
Blocks.prototype.remove = function (b) { |
|
/* DEBUG |
|
console.log("remove block: " + b.blockInd); |
|
console.assert(this.contains(b)); |
|
DEBUG */ |
|
var last = this.list.length - 1; |
|
var swapBlock = this.list[last]; |
|
this.list.length = last; |
|
if (b !== swapBlock) { |
|
this.list[b.blockInd] = swapBlock; |
|
swapBlock.blockInd = b.blockInd; |
|
} |
|
}; |
|
// merge the blocks on either side of the specified constraint, by copying the smaller block into the larger |
|
// and deleting the smaller. |
|
Blocks.prototype.merge = function (c) { |
|
var l = c.left.block, |
|
r = c.right.block; |
|
/* DEBUG |
|
console.assert(l!==r, "attempt to merge within the same block"); |
|
DEBUG */ |
|
var dist = c.right.offset - c.left.offset - c.gap; |
|
if (l.vars.length < r.vars.length) { |
|
r.mergeAcross(l, c, dist); |
|
this.remove(l); |
|
} else { |
|
l.mergeAcross(r, c, -dist); |
|
this.remove(r); |
|
} |
|
/* DEBUG |
|
console.assert(Math.abs(c.slack()) < 1e-6, "Error: Constraint should be at equality after merge!"); |
|
console.log("merged on " + c); |
|
DEBUG */ |
|
}; |
|
Blocks.prototype.forEach = function (f) { |
|
this.list.forEach(f); |
|
}; |
|
// useful, for example, after variable desired positions change. |
|
Blocks.prototype.updateBlockPositions = function () { |
|
this.list.forEach(function (b) { |
|
return b.updateWeightedPosition(); |
|
}); |
|
}; |
|
// split each block across its constraint with the minimum lagrangian |
|
Blocks.prototype.split = function (inactive) { |
|
var _this = this; |
|
this.updateBlockPositions(); |
|
this.list.forEach(function (b) { |
|
var v = b.findMinLM(); |
|
if (v !== null && v.lm < Solver.LAGRANGIAN_TOLERANCE) { |
|
b = v.left.block; |
|
Block.split(v).forEach(function (nb) { |
|
return _this.insert(nb); |
|
}); |
|
_this.remove(b); |
|
inactive.push(v); |
|
} |
|
}); |
|
}; |
|
return Blocks; |
|
}(); |
|
vpsc.Blocks = Blocks; |
|
var Solver = function () { |
|
function Solver(vs, cs) { |
|
this.vs = vs; |
|
this.cs = cs; |
|
this.vs = vs; |
|
vs.forEach(function (v) { |
|
v.cIn = [], v.cOut = []; |
|
/* DEBUG |
|
v.toString = () => "v" + vs.indexOf(v); |
|
DEBUG */ |
|
}); |
|
this.cs = cs; |
|
cs.forEach(function (c) { |
|
c.left.cOut.push(c); |
|
c.right.cIn.push(c); |
|
/* DEBUG |
|
c.toString = () => c.left + "+" + c.gap + "<=" + c.right + " slack=" + c.slack() + " active=" + c.active; |
|
DEBUG */ |
|
}); |
|
this.inactive = cs.map(function (c) { |
|
c.active = false;return c; |
|
}); |
|
this.bs = null; |
|
} |
|
Solver.prototype.cost = function () { |
|
return this.bs.cost(); |
|
}; |
|
// set starting positions without changing desired positions. |
|
// Note: it throws away any previous block structure. |
|
Solver.prototype.setStartingPositions = function (ps) { |
|
this.inactive = this.cs.map(function (c) { |
|
c.active = false;return c; |
|
}); |
|
this.bs = new Blocks(this.vs); |
|
this.bs.forEach(function (b, i) { |
|
return b.posn = ps[i]; |
|
}); |
|
}; |
|
Solver.prototype.setDesiredPositions = function (ps) { |
|
this.vs.forEach(function (v, i) { |
|
return v.desiredPosition = ps[i]; |
|
}); |
|
}; |
|
/* DEBUG |
|
private getId(v: Variable): number { |
|
return this.vs.indexOf(v); |
|
} |
|
// sanity check of the index integrity of the inactive list |
|
checkInactive(): void { |
|
var inactiveCount = 0; |
|
this.cs.forEach(c=> { |
|
var i = this.inactive.indexOf(c); |
|
console.assert(!c.active && i >= 0 || c.active && i < 0, "constraint should be in the inactive list if it is not active: " + c); |
|
if (i >= 0) { |
|
inactiveCount++; |
|
} else { |
|
console.assert(c.active, "inactive constraint not found in inactive list: " + c); |
|
} |
|
}); |
|
console.assert(inactiveCount === this.inactive.length, inactiveCount + " inactive constraints found, " + this.inactive.length + "in inactive list"); |
|
} |
|
// after every call to satisfy the following should check should pass |
|
checkSatisfied(): void { |
|
this.cs.forEach(c=>console.assert(c.slack() >= vpsc.Solver.ZERO_UPPERBOUND, "Error: Unsatisfied constraint! "+c)); |
|
} |
|
DEBUG */ |
|
Solver.prototype.mostViolated = function () { |
|
var minSlack = Number.MAX_VALUE, |
|
v = null, |
|
l = this.inactive, |
|
n = l.length, |
|
deletePoint = n; |
|
for (var i = 0; i < n; ++i) { |
|
var c = l[i]; |
|
if (c.unsatisfiable) continue; |
|
var slack = c.slack(); |
|
if (c.equality || slack < minSlack) { |
|
minSlack = slack; |
|
v = c; |
|
deletePoint = i; |
|
if (c.equality) break; |
|
} |
|
} |
|
if (deletePoint !== n && (minSlack < Solver.ZERO_UPPERBOUND && !v.active || v.equality)) { |
|
l[deletePoint] = l[n - 1]; |
|
l.length = n - 1; |
|
} |
|
return v; |
|
}; |
|
// satisfy constraints by building block structure over violated constraints |
|
// and moving the blocks to their desired positions |
|
Solver.prototype.satisfy = function () { |
|
if (this.bs == null) { |
|
this.bs = new Blocks(this.vs); |
|
} |
|
/* DEBUG |
|
console.log("satisfy: " + this.bs); |
|
DEBUG */ |
|
this.bs.split(this.inactive); |
|
var v = null; |
|
while ((v = this.mostViolated()) && (v.equality || v.slack() < Solver.ZERO_UPPERBOUND && !v.active)) { |
|
var lb = v.left.block, |
|
rb = v.right.block; |
|
/* DEBUG |
|
console.log("most violated is: " + v); |
|
this.bs.contains(lb); |
|
this.bs.contains(rb); |
|
DEBUG */ |
|
if (lb !== rb) { |
|
this.bs.merge(v); |
|
} else { |
|
if (lb.isActiveDirectedPathBetween(v.right, v.left)) { |
|
// cycle found! |
|
v.unsatisfiable = true; |
|
continue; |
|
} |
|
// constraint is within block, need to split first |
|
var split = lb.splitBetween(v.left, v.right); |
|
if (split !== null) { |
|
this.bs.insert(split.lb); |
|
this.bs.insert(split.rb); |
|
this.bs.remove(lb); |
|
this.inactive.push(split.constraint); |
|
} else { |
|
/* DEBUG |
|
console.log("unsatisfiable constraint found"); |
|
DEBUG */ |
|
v.unsatisfiable = true; |
|
continue; |
|
} |
|
if (v.slack() >= 0) { |
|
/* DEBUG |
|
console.log("violated constraint indirectly satisfied: " + v); |
|
DEBUG */ |
|
// v was satisfied by the above split! |
|
this.inactive.push(v); |
|
} else { |
|
/* DEBUG |
|
console.log("merge after split:"); |
|
DEBUG */ |
|
this.bs.merge(v); |
|
} |
|
} |
|
} |
|
/* DEBUG |
|
this.checkSatisfied(); |
|
DEBUG */ |
|
}; |
|
// repeatedly build and split block structure until we converge to an optimal solution |
|
Solver.prototype.solve = function () { |
|
this.satisfy(); |
|
var lastcost = Number.MAX_VALUE, |
|
cost = this.bs.cost(); |
|
while (Math.abs(lastcost - cost) > 0.0001) { |
|
this.satisfy(); |
|
lastcost = cost; |
|
cost = this.bs.cost(); |
|
} |
|
return cost; |
|
}; |
|
Solver.LAGRANGIAN_TOLERANCE = -1e-4; |
|
Solver.ZERO_UPPERBOUND = -1e-10; |
|
return Solver; |
|
}(); |
|
vpsc.Solver = Solver; |
|
|
|
module.exports = vpsc; |
|
|
|
/***/ }, |
|
/* 10 */ |
|
/***/ function(module, exports, __webpack_require__) { |
|
|
|
'use strict'; |
|
|
|
var helper = __webpack_require__(4); |
|
|
|
function Renderer(options) { |
|
this.options = helper.extend({ |
|
layerGap: 60, |
|
nodeHeight: 10, |
|
direction: 'down' |
|
}, options); |
|
} |
|
|
|
function lineTo(point) { |
|
return 'L ' + point.join(' '); |
|
} |
|
|
|
function moveTo(point) { |
|
return 'M ' + point.join(' '); |
|
} |
|
|
|
function curveTo(c1, c2, point2) { |
|
return 'C ' + c1.join(' ') + ' ' + c2.join(' ') + ' ' + point2.join(' '); |
|
} |
|
|
|
function vCurveBetween(point1, point2) { |
|
var midY = (point1[1] + point2[1]) / 2; |
|
return curveTo([point1[0], midY], [point2[0], midY], point2); |
|
} |
|
|
|
function hCurveBetween(point1, point2) { |
|
var midX = (point1[0] + point2[0]) / 2; |
|
return curveTo([midX, point1[1]], [midX, point2[1]], point2); |
|
} |
|
|
|
Renderer.lineTo = lineTo; |
|
Renderer.moveTo = moveTo; |
|
Renderer.curveTo = curveTo; |
|
Renderer.vCurveBetween = vCurveBetween; |
|
Renderer.hCurveBetween = hCurveBetween; |
|
|
|
Renderer.prototype.getWaypoints = function (node) { |
|
var options = this.options; |
|
var direction = options.direction; |
|
|
|
var hops = node.getPathFromRoot(); |
|
var gap = options.nodeHeight + options.layerGap; |
|
|
|
if (direction === 'left') { |
|
return [[[0, hops[0].idealPos]]].concat(hops.map(function (hop, level) { |
|
var xPos = gap * (level + 1) * -1; |
|
return [[xPos + options.nodeHeight, hop.currentPos], [xPos, hop.currentPos]]; |
|
})); |
|
} else if (direction === 'right') { |
|
return [[[0, hops[0].idealPos]]].concat(hops.map(function (hop, level) { |
|
var xPos = gap * (level + 1); |
|
return [[xPos - options.nodeHeight, hop.currentPos], [xPos, hop.currentPos]]; |
|
})); |
|
} else if (direction === 'up') { |
|
return [[[hops[0].idealPos, 0]]].concat(hops.map(function (hop, level) { |
|
var yPos = gap * (level + 1) * -1; |
|
return [[hop.currentPos, yPos + options.nodeHeight], [hop.currentPos, yPos]]; |
|
})); |
|
} else { |
|
return [[[hops[0].idealPos, 0]]].concat(hops.map(function (hop, level) { |
|
var yPos = gap * (level + 1); |
|
return [[hop.currentPos, yPos - options.nodeHeight], [hop.currentPos, yPos]]; |
|
})); |
|
} |
|
}; |
|
|
|
Renderer.prototype.layout = function (nodes) { |
|
var options = this.options; |
|
|
|
var gap = options.layerGap + options.nodeHeight; |
|
|
|
switch (options.direction) { |
|
case 'left': |
|
nodes.forEach(function (node) { |
|
var pos = node.getLayerIndex() * gap + options.layerGap; |
|
node.x = -pos - options.nodeHeight; |
|
node.y = node.currentPos; |
|
node.dx = options.nodeHeight; |
|
node.dy = node.width; |
|
}); |
|
break; |
|
case 'right': |
|
nodes.forEach(function (node) { |
|
var pos = node.getLayerIndex() * gap + options.layerGap; |
|
node.x = pos; |
|
node.y = node.currentPos; |
|
node.dx = options.nodeHeight; |
|
node.dy = node.width; |
|
}); |
|
break; |
|
case 'up': |
|
nodes.forEach(function (node) { |
|
var pos = node.getLayerIndex() * gap + options.layerGap; |
|
node.x = node.currentPos; |
|
node.y = -pos - options.nodeHeight; |
|
node.dx = node.width; |
|
node.dy = options.nodeHeight; |
|
}); |
|
break; |
|
default: |
|
case 'down': |
|
nodes.forEach(function (node) { |
|
var pos = node.getLayerIndex() * gap + options.layerGap; |
|
node.x = node.currentPos; |
|
node.y = pos; |
|
node.dx = node.width; |
|
node.dy = options.nodeHeight; |
|
}); |
|
break; |
|
} |
|
|
|
return nodes; |
|
}; |
|
|
|
Renderer.prototype.generatePath = function (node) { |
|
var options = this.options; |
|
var direction = options.direction; |
|
|
|
var waypoints = this.getWaypoints(node, direction); |
|
|
|
var steps = [moveTo(waypoints[0][0])]; |
|
|
|
if (direction === 'left' || direction === 'right') { |
|
waypoints.reduce(function (prev, current, level) { |
|
steps.push(hCurveBetween(prev[prev.length - 1], current[0])); |
|
if (level < waypoints.length - 1) { |
|
steps.push(lineTo(current[1])); |
|
} |
|
return current; |
|
}); |
|
} else { |
|
waypoints.reduce(function (prev, current, level) { |
|
steps.push(vCurveBetween(prev[prev.length - 1], current[0])); |
|
if (level < waypoints.length - 1) { |
|
steps.push(lineTo(current[1])); |
|
} |
|
return current; |
|
}); |
|
} |
|
|
|
return steps.join(' '); |
|
}; |
|
|
|
// return module |
|
module.exports = Renderer; |
|
|
|
/***/ } |
|
/******/ ]) |
|
}); |
|
; |
